dump.c

   1 /*
   2  * QEMU dump
   3  *
   4  * Copyright Fujitsu, Corp. 2011, 2012
   5  *
   6  * Authors:
   7  *     Wen Congyang <[email protected]>
   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-common.h"
  15 #include "elf.h"
  16 #include "cpu.h"
  17 #include "exec/cpu-all.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 "qmp-commands.h"
  27
  28 static uint16_t cpu_convert_to_target16(uint16_t val, int endian)
  29 {
  30     if (endian == ELFDATA2LSB) {
  31         val = cpu_to_le16(val);
  32     } else {
  33         val = cpu_to_be16(val);
  34     }
  35
  36     return val;
  37 }
  38
  39 static uint32_t cpu_convert_to_target32(uint32_t val, int endian)
  40 {
  41     if (endian == ELFDATA2LSB) {
  42         val = cpu_to_le32(val);
  43     } else {
  44         val = cpu_to_be32(val);
  45     }
  46
  47     return val;
  48 }
  49
  50 static uint64_t cpu_convert_to_target64(uint64_t val, int endian)
  51 {
  52     if (endian == ELFDATA2LSB) {
  53         val = cpu_to_le64(val);
  54     } else {
  55         val = cpu_to_be64(val);
  56     }
  57
  58     return val;
  59 }
  60
  61 typedef struct DumpState {
  62     GuestPhysBlockList guest_phys_blocks;
  63     ArchDumpInfo dump_info;
  64     MemoryMappingList list;
  65     uint16_t phdr_num;
  66     uint32_t sh_info;
  67     bool have_section;
  68     bool resume;
  69     ssize_t note_size;
  70     hwaddr memory_offset;
  71     int fd;
  72
  73     GuestPhysBlock *next_block;
  74     ram_addr_t start;
  75     bool has_filter;
  76     int64_t begin;
  77     int64_t length;
  78     Error **errp;
  79
  80     uint8_t *note_buf;          /* buffer for notes */
  81     size_t note_buf_offset;     /* the writing place in note_buf */
  82     uint32_t nr_cpus;           /* number of guest's cpu */
  83     size_t page_size;           /* guest's page size */
  84     uint32_t page_shift;        /* guest's page shift */
  85     uint64_t max_mapnr;         /* the biggest guest's phys-mem's number */
  86     size_t len_dump_bitmap;     /* the size of the place used to store
  87                                    dump_bitmap in vmcore */
  88     off_t offset_dump_bitmap;   /* offset of dump_bitmap part in vmcore */
  89     off_t offset_page;          /* offset of page part in vmcore */
  90     size_t num_dumpable;        /* number of page that can be dumped */
  91     uint32_t flag_compress;     /* indicate the compression format */
  92 } DumpState;
  93
  94 static int dump_cleanup(DumpState *s)
  95 {
  96     int ret = 0;
  97
  98     guest_phys_blocks_free(&s->guest_phys_blocks);
  99     memory_mapping_list_free(&s->list);
 100     if (s->fd != -1) {
 101         close(s->fd);
 102     }
 103     if (s->resume) {
 104         vm_start();
 105     }
 106
 107     return ret;
 108 }
 109
 110 static void dump_error(DumpState *s, const char *reason)
 111 {
 112     dump_cleanup(s);
 113 }
 114
 115 static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
 116 {
 117     DumpState *s = opaque;
 118     size_t written_size;
 119
 120     written_size = qemu_write_full(s->fd, buf, size);
 121     if (written_size != size) {
 122         return -1;
 123     }
 124
 125     return 0;
 126 }
 127
 128 static int write_elf64_header(DumpState *s)
 129 {
 130     Elf64_Ehdr elf_header;
 131     int ret;
 132     int endian = s->dump_info.d_endian;
 133
 134     memset(&elf_header, 0, sizeof(Elf64_Ehdr));
 135     memcpy(&elf_header, ELFMAG, SELFMAG);
 136     elf_header.e_ident[EI_CLASS] = ELFCLASS64;
 137     elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
 138     elf_header.e_ident[EI_VERSION] = EV_CURRENT;
 139     elf_header.e_type = cpu_convert_to_target16(ET_CORE, endian);
 140     elf_header.e_machine = cpu_convert_to_target16(s->dump_info.d_machine,
 141                                                    endian);
 142     elf_header.e_version = cpu_convert_to_target32(EV_CURRENT, endian);
 143     elf_header.e_ehsize = cpu_convert_to_target16(sizeof(elf_header), endian);
 144     elf_header.e_phoff = cpu_convert_to_target64(sizeof(Elf64_Ehdr), endian);
 145     elf_header.e_phentsize = cpu_convert_to_target16(sizeof(Elf64_Phdr),
 146                                                      endian);
 147     elf_header.e_phnum = cpu_convert_to_target16(s->phdr_num, endian);
 148     if (s->have_section) {
 149         uint64_t shoff = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) * s->sh_info;
 150
 151         elf_header.e_shoff = cpu_convert_to_target64(shoff, endian);
 152         elf_header.e_shentsize = cpu_convert_to_target16(sizeof(Elf64_Shdr),
 153                                                          endian);
 154         elf_header.e_shnum = cpu_convert_to_target16(1, endian);
 155     }
 156
 157     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
 158     if (ret < 0) {
 159         dump_error(s, "dump: failed to write elf header.\n");
 160         return -1;
 161     }
 162
 163     return 0;
 164 }
 165
 166 static int write_elf32_header(DumpState *s)
 167 {
 168     Elf32_Ehdr elf_header;
 169     int ret;
 170     int endian = s->dump_info.d_endian;
 171
 172     memset(&elf_header, 0, sizeof(Elf32_Ehdr));
 173     memcpy(&elf_header, ELFMAG, SELFMAG);
 174     elf_header.e_ident[EI_CLASS] = ELFCLASS32;
 175     elf_header.e_ident[EI_DATA] = endian;
 176     elf_header.e_ident[EI_VERSION] = EV_CURRENT;
 177     elf_header.e_type = cpu_convert_to_target16(ET_CORE, endian);
 178     elf_header.e_machine = cpu_convert_to_target16(s->dump_info.d_machine,
 179                                                    endian);
 180     elf_header.e_version = cpu_convert_to_target32(EV_CURRENT, endian);
 181     elf_header.e_ehsize = cpu_convert_to_target16(sizeof(elf_header), endian);
 182     elf_header.e_phoff = cpu_convert_to_target32(sizeof(Elf32_Ehdr), endian);
 183     elf_header.e_phentsize = cpu_convert_to_target16(sizeof(Elf32_Phdr),
 184                                                      endian);
 185     elf_header.e_phnum = cpu_convert_to_target16(s->phdr_num, endian);
 186     if (s->have_section) {
 187         uint32_t shoff = sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * s->sh_info;
 188
 189         elf_header.e_shoff = cpu_convert_to_target32(shoff, endian);
 190         elf_header.e_shentsize = cpu_convert_to_target16(sizeof(Elf32_Shdr),
 191                                                          endian);
 192         elf_header.e_shnum = cpu_convert_to_target16(1, endian);
 193     }
 194
 195     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
 196     if (ret < 0) {
 197         dump_error(s, "dump: failed to write elf header.\n");
 198         return -1;
 199     }
 200
 201     return 0;
 202 }
 203
 204 static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
 205                             int phdr_index, hwaddr offset,
 206                             hwaddr filesz)
 207 {
 208     Elf64_Phdr phdr;
 209     int ret;
 210     int endian = s->dump_info.d_endian;
 211
 212     memset(&phdr, 0, sizeof(Elf64_Phdr));
 213     phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian);
 214     phdr.p_offset = cpu_convert_to_target64(offset, endian);
 215     phdr.p_paddr = cpu_convert_to_target64(memory_mapping->phys_addr, endian);
 216     phdr.p_filesz = cpu_convert_to_target64(filesz, endian);
 217     phdr.p_memsz = cpu_convert_to_target64(memory_mapping->length, endian);
 218     phdr.p_vaddr = cpu_convert_to_target64(memory_mapping->virt_addr, endian);
 219
 220     assert(memory_mapping->length >= filesz);
 221
 222     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
 223     if (ret < 0) {
 224         dump_error(s, "dump: failed to write program header table.\n");
 225         return -1;
 226     }
 227
 228     return 0;
 229 }
 230
 231 static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
 232                             int phdr_index, hwaddr offset,
 233                             hwaddr filesz)
 234 {
 235     Elf32_Phdr phdr;
 236     int ret;
 237     int endian = s->dump_info.d_endian;
 238
 239     memset(&phdr, 0, sizeof(Elf32_Phdr));
 240     phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian);
 241     phdr.p_offset = cpu_convert_to_target32(offset, endian);
 242     phdr.p_paddr = cpu_convert_to_target32(memory_mapping->phys_addr, endian);
 243     phdr.p_filesz = cpu_convert_to_target32(filesz, endian);
 244     phdr.p_memsz = cpu_convert_to_target32(memory_mapping->length, endian);
 245     phdr.p_vaddr = cpu_convert_to_target32(memory_mapping->virt_addr, endian);
 246
 247     assert(memory_mapping->length >= filesz);
 248
 249     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
 250     if (ret < 0) {
 251         dump_error(s, "dump: failed to write program header table.\n");
 252         return -1;
 253     }
 254
 255     return 0;
 256 }
 257
 258 static int write_elf64_note(DumpState *s)
 259 {
 260     Elf64_Phdr phdr;
 261     int endian = s->dump_info.d_endian;
 262     hwaddr begin = s->memory_offset - s->note_size;
 263     int ret;
 264
 265     memset(&phdr, 0, sizeof(Elf64_Phdr));
 266     phdr.p_type = cpu_convert_to_target32(PT_NOTE, endian);
 267     phdr.p_offset = cpu_convert_to_target64(begin, endian);
 268     phdr.p_paddr = 0;
 269     phdr.p_filesz = cpu_convert_to_target64(s->note_size, endian);
 270     phdr.p_memsz = cpu_convert_to_target64(s->note_size, endian);
 271     phdr.p_vaddr = 0;
 272
 273     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
 274     if (ret < 0) {
 275         dump_error(s, "dump: failed to write program header table.\n");
 276         return -1;
 277     }
 278
 279     return 0;
 280 }
 281
 282 static inline int cpu_index(CPUState *cpu)
 283 {
 284     return cpu->cpu_index + 1;
 285 }
 286
 287 static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s)
 288 {
 289     CPUState *cpu;
 290     int ret;
 291     int id;
 292
 293     CPU_FOREACH(cpu) {
 294         id = cpu_index(cpu);
 295         ret = cpu_write_elf64_note(f, cpu, id, s);
 296         if (ret < 0) {
 297             dump_error(s, "dump: failed to write elf notes.\n");
 298             return -1;
 299         }
 300     }
 301
 302     CPU_FOREACH(cpu) {
 303         ret = cpu_write_elf64_qemunote(f, cpu, s);
 304         if (ret < 0) {
 305             dump_error(s, "dump: failed to write CPU status.\n");
 306             return -1;
 307         }
 308     }
 309
 310     return 0;
 311 }
 312
 313 static int write_elf32_note(DumpState *s)
 314 {
 315     hwaddr begin = s->memory_offset - s->note_size;
 316     Elf32_Phdr phdr;
 317     int endian = s->dump_info.d_endian;
 318     int ret;
 319
 320     memset(&phdr, 0, sizeof(Elf32_Phdr));
 321     phdr.p_type = cpu_convert_to_target32(PT_NOTE, endian);
 322     phdr.p_offset = cpu_convert_to_target32(begin, endian);
 323     phdr.p_paddr = 0;
 324     phdr.p_filesz = cpu_convert_to_target32(s->note_size, endian);
 325     phdr.p_memsz = cpu_convert_to_target32(s->note_size, endian);
 326     phdr.p_vaddr = 0;
 327
 328     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
 329     if (ret < 0) {
 330         dump_error(s, "dump: failed to write program header table.\n");
 331         return -1;
 332     }
 333
 334     return 0;
 335 }
 336
 337 static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s)
 338 {
 339     CPUState *cpu;
 340     int ret;
 341     int id;
 342
 343     CPU_FOREACH(cpu) {
 344         id = cpu_index(cpu);
 345         ret = cpu_write_elf32_note(f, cpu, id, s);
 346         if (ret < 0) {
 347             dump_error(s, "dump: failed to write elf notes.\n");
 348             return -1;
 349         }
 350     }
 351
 352     CPU_FOREACH(cpu) {
 353         ret = cpu_write_elf32_qemunote(f, cpu, s);
 354         if (ret < 0) {
 355             dump_error(s, "dump: failed to write CPU status.\n");
 356             return -1;
 357         }
 358     }
 359
 360     return 0;
 361 }
 362
 363 static int write_elf_section(DumpState *s, int type)
 364 {
 365     Elf32_Shdr shdr32;
 366     Elf64_Shdr shdr64;
 367     int endian = s->dump_info.d_endian;
 368     int shdr_size;
 369     void *shdr;
 370     int ret;
 371
 372     if (type == 0) {
 373         shdr_size = sizeof(Elf32_Shdr);
 374         memset(&shdr32, 0, shdr_size);
 375         shdr32.sh_info = cpu_convert_to_target32(s->sh_info, endian);
 376         shdr = &shdr32;
 377     } else {
 378         shdr_size = sizeof(Elf64_Shdr);
 379         memset(&shdr64, 0, shdr_size);
 380         shdr64.sh_info = cpu_convert_to_target32(s->sh_info, endian);
 381         shdr = &shdr64;
 382     }
 383
 384     ret = fd_write_vmcore(&shdr, shdr_size, s);
 385     if (ret < 0) {
 386         dump_error(s, "dump: failed to write section header table.\n");
 387         return -1;
 388     }
 389
 390     return 0;
 391 }
 392
 393 static int write_data(DumpState *s, void *buf, int length)
 394 {
 395     int ret;
 396
 397     ret = fd_write_vmcore(buf, length, s);
 398     if (ret < 0) {
 399         dump_error(s, "dump: failed to save memory.\n");
 400         return -1;
 401     }
 402
 403     return 0;
 404 }
 405
 406 /* write the memroy to vmcore. 1 page per I/O. */
 407 static int write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,
 408                         int64_t size)
 409 {
 410     int64_t i;
 411     int ret;
 412
 413     for (i = 0; i < size / TARGET_PAGE_SIZE; i++) {
 414         ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
 415                          TARGET_PAGE_SIZE);
 416         if (ret < 0) {
 417             return ret;
 418         }
 419     }
 420
 421     if ((size % TARGET_PAGE_SIZE) != 0) {
 422         ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
 423                          size % TARGET_PAGE_SIZE);
 424         if (ret < 0) {
 425             return ret;
 426         }
 427     }
 428
 429     return 0;
 430 }
 431
 432 /* get the memory's offset and size in the vmcore */
 433 static void get_offset_range(hwaddr phys_addr,
 434                              ram_addr_t mapping_length,
 435                              DumpState *s,
 436                              hwaddr *p_offset,
 437                              hwaddr *p_filesz)
 438 {
 439     GuestPhysBlock *block;
 440     hwaddr offset = s->memory_offset;
 441     int64_t size_in_block, start;
 442
 443     /* When the memory is not stored into vmcore, offset will be -1 */
 444     *p_offset = -1;
 445     *p_filesz = 0;
 446
 447     if (s->has_filter) {
 448         if (phys_addr < s->begin || phys_addr >= s->begin + s->length) {
 449             return;
 450         }
 451     }
 452
 453     QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
 454         if (s->has_filter) {
 455             if (block->target_start >= s->begin + s->length ||
 456                 block->target_end <= s->begin) {
 457                 /* This block is out of the range */
 458                 continue;
 459             }
 460
 461             if (s->begin <= block->target_start) {
 462                 start = block->target_start;
 463             } else {
 464                 start = s->begin;
 465             }
 466
 467             size_in_block = block->target_end - start;
 468             if (s->begin + s->length < block->target_end) {
 469                 size_in_block -= block->target_end - (s->begin + s->length);
 470             }
 471         } else {
 472             start = block->target_start;
 473             size_in_block = block->target_end - block->target_start;
 474         }
 475
 476         if (phys_addr >= start && phys_addr < start + size_in_block) {
 477             *p_offset = phys_addr - start + offset;
 478
 479             /* The offset range mapped from the vmcore file must not spill over
 480              * the GuestPhysBlock, clamp it. The rest of the mapping will be
 481              * zero-filled in memory at load time; see
 482              * <http://refspecs.linuxbase.org/elf/gabi4+/ch5.pheader.html>.
 483              */
 484             *p_filesz = phys_addr + mapping_length <= start + size_in_block ?
 485                         mapping_length :
 486                         size_in_block - (phys_addr - start);
 487             return;
 488         }
 489
 490         offset += size_in_block;
 491     }
 492 }
 493
 494 static int write_elf_loads(DumpState *s)
 495 {
 496     hwaddr offset, filesz;
 497     MemoryMapping *memory_mapping;
 498     uint32_t phdr_index = 1;
 499     int ret;
 500     uint32_t max_index;
 501
 502     if (s->have_section) {
 503         max_index = s->sh_info;
 504     } else {
 505         max_index = s->phdr_num;
 506     }
 507
 508     QTAILQ_FOREACH(memory_mapping, &s->list.head, next) {
 509         get_offset_range(memory_mapping->phys_addr,
 510                          memory_mapping->length,
 511                          s, &offset, &filesz);
 512         if (s->dump_info.d_class == ELFCLASS64) {
 513             ret = write_elf64_load(s, memory_mapping, phdr_index++, offset,
 514                                    filesz);
 515         } else {
 516             ret = write_elf32_load(s, memory_mapping, phdr_index++, offset,
 517                                    filesz);
 518         }
 519
 520         if (ret < 0) {
 521             return -1;
 522         }
 523
 524         if (phdr_index >= max_index) {
 525             break;
 526         }
 527     }
 528
 529     return 0;
 530 }
 531
 532 /* write elf header, PT_NOTE and elf note to vmcore. */
 533 static int dump_begin(DumpState *s)
 534 {
 535     int ret;
 536
 537     /*
 538      * the vmcore's format is:
 539      *   --------------
 540      *   |  elf header |
 541      *   --------------
 542      *   |  PT_NOTE    |
 543      *   --------------
 544      *   |  PT_LOAD    |
 545      *   --------------
 546      *   |  ......     |
 547      *   --------------
 548      *   |  PT_LOAD    |
 549      *   --------------
 550      *   |  sec_hdr    |
 551      *   --------------
 552      *   |  elf note   |
 553      *   --------------
 554      *   |  memory     |
 555      *   --------------
 556      *
 557      * we only know where the memory is saved after we write elf note into
 558      * vmcore.
 559      */
 560
 561     /* write elf header to vmcore */
 562     if (s->dump_info.d_class == ELFCLASS64) {
 563         ret = write_elf64_header(s);
 564     } else {
 565         ret = write_elf32_header(s);
 566     }
 567     if (ret < 0) {
 568         return -1;
 569     }
 570
 571     if (s->dump_info.d_class == ELFCLASS64) {
 572         /* write PT_NOTE to vmcore */
 573         if (write_elf64_note(s) < 0) {
 574             return -1;
 575         }
 576
 577         /* write all PT_LOAD to vmcore */
 578         if (write_elf_loads(s) < 0) {
 579             return -1;
 580         }
 581
 582         /* write section to vmcore */
 583         if (s->have_section) {
 584             if (write_elf_section(s, 1) < 0) {
 585                 return -1;
 586             }
 587         }
 588
 589         /* write notes to vmcore */
 590         if (write_elf64_notes(fd_write_vmcore, s) < 0) {
 591             return -1;
 592         }
 593
 594     } else {
 595         /* write PT_NOTE to vmcore */
 596         if (write_elf32_note(s) < 0) {
 597             return -1;
 598         }
 599
 600         /* write all PT_LOAD to vmcore */
 601         if (write_elf_loads(s) < 0) {
 602             return -1;
 603         }
 604
 605         /* write section to vmcore */
 606         if (s->have_section) {
 607             if (write_elf_section(s, 0) < 0) {
 608                 return -1;
 609             }
 610         }
 611
 612         /* write notes to vmcore */
 613         if (write_elf32_notes(fd_write_vmcore, s) < 0) {
 614             return -1;
 615         }
 616     }
 617
 618     return 0;
 619 }
 620
 621 /* write PT_LOAD to vmcore */
 622 static int dump_completed(DumpState *s)
 623 {
 624     dump_cleanup(s);
 625     return 0;
 626 }
 627
 628 static int get_next_block(DumpState *s, GuestPhysBlock *block)
 629 {
 630     while (1) {
 631         block = QTAILQ_NEXT(block, next);
 632         if (!block) {
 633             /* no more block */
 634             return 1;
 635         }
 636
 637         s->start = 0;
 638         s->next_block = block;
 639         if (s->has_filter) {
 640             if (block->target_start >= s->begin + s->length ||
 641                 block->target_end <= s->begin) {
 642                 /* This block is out of the range */
 643                 continue;
 644             }
 645
 646             if (s->begin > block->target_start) {
 647                 s->start = s->begin - block->target_start;
 648             }
 649         }
 650
 651         return 0;
 652     }
 653 }
 654
 655 /* write all memory to vmcore */
 656 static int dump_iterate(DumpState *s)
 657 {
 658     GuestPhysBlock *block;
 659     int64_t size;
 660     int ret;
 661
 662     while (1) {
 663         block = s->next_block;
 664
 665         size = block->target_end - block->target_start;
 666         if (s->has_filter) {
 667             size -= s->start;
 668             if (s->begin + s->length < block->target_end) {
 669                 size -= block->target_end - (s->begin + s->length);
 670             }
 671         }
 672         ret = write_memory(s, block, s->start, size);
 673         if (ret == -1) {
 674             return ret;
 675         }
 676
 677         ret = get_next_block(s, block);
 678         if (ret == 1) {
 679             dump_completed(s);
 680             return 0;
 681         }
 682     }
 683 }
 684
 685 static int create_vmcore(DumpState *s)
 686 {
 687     int ret;
 688
 689     ret = dump_begin(s);
 690     if (ret < 0) {
 691         return -1;
 692     }
 693
 694     ret = dump_iterate(s);
 695     if (ret < 0) {
 696         return -1;
 697     }
 698
 699     return 0;
 700 }
 701
 702 static int write_start_flat_header(int fd)
 703 {
 704     uint8_t *buf;
 705     MakedumpfileHeader mh;
 706     int ret = 0;
 707
 708     memset(&mh, 0, sizeof(mh));
 709     strncpy(mh.signature, MAKEDUMPFILE_SIGNATURE,
 710             strlen(MAKEDUMPFILE_SIGNATURE));
 711
 712     mh.type = cpu_to_be64(TYPE_FLAT_HEADER);
 713     mh.version = cpu_to_be64(VERSION_FLAT_HEADER);
 714
 715     buf = g_malloc0(MAX_SIZE_MDF_HEADER);
 716     memcpy(buf, &mh, sizeof(mh));
 717
 718     size_t written_size;
 719     written_size = qemu_write_full(fd, buf, MAX_SIZE_MDF_HEADER);
 720     if (written_size != MAX_SIZE_MDF_HEADER) {
 721         ret = -1;
 722     }
 723
 724     g_free(buf);
 725     return ret;
 726 }
 727
 728 static int write_end_flat_header(int fd)
 729 {
 730     MakedumpfileDataHeader mdh;
 731
 732     mdh.offset = END_FLAG_FLAT_HEADER;
 733     mdh.buf_size = END_FLAG_FLAT_HEADER;
 734
 735     size_t written_size;
 736     written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
 737     if (written_size != sizeof(mdh)) {
 738         return -1;
 739     }
 740
 741     return 0;
 742 }
 743
 744 static int write_buffer(int fd, off_t offset, const void *buf, size_t size)
 745 {
 746     size_t written_size;
 747     MakedumpfileDataHeader mdh;
 748
 749     mdh.offset = cpu_to_be64(offset);
 750     mdh.buf_size = cpu_to_be64(size);
 751
 752     written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
 753     if (written_size != sizeof(mdh)) {
 754         return -1;
 755     }
 756
 757     written_size = qemu_write_full(fd, buf, size);
 758     if (written_size != size) {
 759         return -1;
 760     }
 761
 762     return 0;
 763 }
 764
 765 static int buf_write_note(const void *buf, size_t size, void *opaque)
 766 {
 767     DumpState *s = opaque;
 768
 769     /* note_buf is not enough */
 770     if (s->note_buf_offset + size > s->note_size) {
 771         return -1;
 772     }
 773
 774     memcpy(s->note_buf + s->note_buf_offset, buf, size);
 775
 776     s->note_buf_offset += size;
 777
 778     return 0;
 779 }
 780
 781 static ram_addr_t get_start_block(DumpState *s)
 782 {
 783     GuestPhysBlock *block;
 784
 785     if (!s->has_filter) {
 786         s->next_block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
 787         return 0;
 788     }
 789
 790     QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
 791         if (block->target_start >= s->begin + s->length ||
 792             block->target_end <= s->begin) {
 793             /* This block is out of the range */
 794             continue;
 795         }
 796
 797         s->next_block = block;
 798         if (s->begin > block->target_start) {
 799             s->start = s->begin - block->target_start;
 800         } else {
 801             s->start = 0;
 802         }
 803         return s->start;
 804     }
 805
 806     return -1;
 807 }
 808
 809 static void get_max_mapnr(DumpState *s)
 810 {
 811     GuestPhysBlock *last_block;
 812
 813     last_block = QTAILQ_LAST(&s->guest_phys_blocks.head, GuestPhysBlockHead);
 814     s->max_mapnr = paddr_to_pfn(last_block->target_end, s->page_shift);
 815 }
 816
 817 static int dump_init(DumpState *s, int fd, bool paging, bool has_filter,
 818                      int64_t begin, int64_t length, Error **errp)
 819 {
 820     CPUState *cpu;
 821     int nr_cpus;
 822     Error *err = NULL;
 823     int ret;
 824
 825     if (runstate_is_running()) {
 826         vm_stop(RUN_STATE_SAVE_VM);
 827         s->resume = true;
 828     } else {
 829         s->resume = false;
 830     }
 831
 832     /* If we use KVM, we should synchronize the registers before we get dump
 833      * info or physmap info.
 834      */
 835     cpu_synchronize_all_states();
 836     nr_cpus = 0;
 837     CPU_FOREACH(cpu) {
 838         nr_cpus++;
 839     }
 840
 841     s->errp = errp;
 842     s->fd = fd;
 843     s->has_filter = has_filter;
 844     s->begin = begin;
 845     s->length = length;
 846
 847     guest_phys_blocks_init(&s->guest_phys_blocks);
 848     guest_phys_blocks_append(&s->guest_phys_blocks);
 849
 850     s->start = get_start_block(s);
 851     if (s->start == -1) {
 852         error_set(errp, QERR_INVALID_PARAMETER, "begin");
 853         goto cleanup;
 854     }
 855
 856     /* get dump info: endian, class and architecture.
 857      * If the target architecture is not supported, cpu_get_dump_info() will
 858      * return -1.
 859      */
 860     ret = cpu_get_dump_info(&s->dump_info, &s->guest_phys_blocks);
 861     if (ret < 0) {
 862         error_set(errp, QERR_UNSUPPORTED);
 863         goto cleanup;
 864     }
 865
 866     s->note_size = cpu_get_note_size(s->dump_info.d_class,
 867                                      s->dump_info.d_machine, nr_cpus);
 868     if (s->note_size < 0) {
 869         error_set(errp, QERR_UNSUPPORTED);
 870         goto cleanup;
 871     }
 872
 873     /* get memory mapping */
 874     memory_mapping_list_init(&s->list);
 875     if (paging) {
 876         qemu_get_guest_memory_mapping(&s->list, &s->guest_phys_blocks, &err);
 877         if (err != NULL) {
 878             error_propagate(errp, err);
 879             goto cleanup;
 880         }
 881     } else {
 882         qemu_get_guest_simple_memory_mapping(&s->list, &s->guest_phys_blocks);
 883     }
 884
 885     s->nr_cpus = nr_cpus;
 886     s->page_size = TARGET_PAGE_SIZE;
 887     s->page_shift = ffs(s->page_size) - 1;
 888
 889     get_max_mapnr(s);
 890
 891     uint64_t tmp;
 892     tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT), s->page_size);
 893     s->len_dump_bitmap = tmp * s->page_size;
 894
 895     if (s->has_filter) {
 896         memory_mapping_filter(&s->list, s->begin, s->length);
 897     }
 898
 899     /*
 900      * calculate phdr_num
 901      *
 902      * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
 903      */
 904     s->phdr_num = 1; /* PT_NOTE */
 905     if (s->list.num < UINT16_MAX - 2) {
 906         s->phdr_num += s->list.num;
 907         s->have_section = false;
 908     } else {
 909         s->have_section = true;
 910         s->phdr_num = PN_XNUM;
 911         s->sh_info = 1; /* PT_NOTE */
 912
 913         /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
 914         if (s->list.num <= UINT32_MAX - 1) {
 915             s->sh_info += s->list.num;
 916         } else {
 917             s->sh_info = UINT32_MAX;
 918         }
 919     }
 920
 921     if (s->dump_info.d_class == ELFCLASS64) {
 922         if (s->have_section) {
 923             s->memory_offset = sizeof(Elf64_Ehdr) +
 924                                sizeof(Elf64_Phdr) * s->sh_info +
 925                                sizeof(Elf64_Shdr) + s->note_size;
 926         } else {
 927             s->memory_offset = sizeof(Elf64_Ehdr) +
 928                                sizeof(Elf64_Phdr) * s->phdr_num + s->note_size;
 929         }
 930     } else {
 931         if (s->have_section) {
 932             s->memory_offset = sizeof(Elf32_Ehdr) +
 933                                sizeof(Elf32_Phdr) * s->sh_info +
 934                                sizeof(Elf32_Shdr) + s->note_size;
 935         } else {
 936             s->memory_offset = sizeof(Elf32_Ehdr) +
 937                                sizeof(Elf32_Phdr) * s->phdr_num + s->note_size;
 938         }
 939     }
 940
 941     return 0;
 942
 943 cleanup:
 944     guest_phys_blocks_free(&s->guest_phys_blocks);
 945
 946     if (s->resume) {
 947         vm_start();
 948     }
 949
 950     return -1;
 951 }
 952
 953 void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,
 954                            int64_t begin, bool has_length, int64_t length,
 955                            Error **errp)
 956 {
 957     const char *p;
 958     int fd = -1;
 959     DumpState *s;
 960     int ret;
 961
 962     if (has_begin && !has_length) {
 963         error_set(errp, QERR_MISSING_PARAMETER, "length");
 964         return;
 965     }
 966     if (!has_begin && has_length) {
 967         error_set(errp, QERR_MISSING_PARAMETER, "begin");
 968         return;
 969     }
 970
 971 #if !defined(WIN32)
 972     if (strstart(file, "fd:", &p)) {
 973         fd = monitor_get_fd(cur_mon, p, errp);
 974         if (fd == -1) {
 975             return;
 976         }
 977     }
 978 #endif
 979
 980     if  (strstart(file, "file:", &p)) {
 981         fd = qemu_open(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR);
 982         if (fd < 0) {
 983             error_setg_file_open(errp, errno, p);
 984             return;
 985         }
 986     }
 987
 988     if (fd == -1) {
 989         error_set(errp, QERR_INVALID_PARAMETER, "protocol");
 990         return;
 991     }
 992
 993     s = g_malloc0(sizeof(DumpState));
 994
 995     ret = dump_init(s, fd, paging, has_begin, begin, length, errp);
 996     if (ret < 0) {
 997         g_free(s);
 998         return;
 999     }
1000
1001     if (create_vmcore(s) < 0 && !error_is_set(s->errp)) {
1002         error_set(errp, QERR_IO_ERROR);
1003     }
1004
1005     g_free(s);
1006 }