dump.c 53.2 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * QEMU dump
 *
 * Copyright Fujitsu, Corp. 2011, 2012
 *
 * Authors:
 *     Wen Congyang <wency@cn.fujitsu.com>
 *
9 10
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
11 12 13
 *
 */

Peter Maydell's avatar
Peter Maydell committed
14
#include "qemu/osdep.h"
15
#include "qemu/cutils.h"
16 17
#include "elf.h"
#include "cpu.h"
18 19
#include "exec/cpu-all.h"
#include "exec/hwaddr.h"
20
#include "monitor/monitor.h"
21 22 23 24
#include "sysemu/kvm.h"
#include "sysemu/dump.h"
#include "sysemu/sysemu.h"
#include "sysemu/memory_mapping.h"
25
#include "sysemu/cpus.h"
26
#include "qapi/qmp/qerror.h"
27
#include "qmp-commands.h"
28
#include "qapi-event.h"
29

30 31 32 33 34 35 36
#include <zlib.h>
#ifdef CONFIG_LZO
#include <lzo/lzo1x.h>
#endif
#ifdef CONFIG_SNAPPY
#include <snappy-c.h>
#endif
37 38 39
#ifndef ELF_MACHINE_UNAME
#define ELF_MACHINE_UNAME "Unknown"
#endif
40

41
uint16_t cpu_to_dump16(DumpState *s, uint16_t val)
42
{
43
    if (s->dump_info.d_endian == ELFDATA2LSB) {
44 45 46 47 48 49 50 51
        val = cpu_to_le16(val);
    } else {
        val = cpu_to_be16(val);
    }

    return val;
}

52
uint32_t cpu_to_dump32(DumpState *s, uint32_t val)
53
{
54
    if (s->dump_info.d_endian == ELFDATA2LSB) {
55 56 57 58 59 60 61 62
        val = cpu_to_le32(val);
    } else {
        val = cpu_to_be32(val);
    }

    return val;
}

63
uint64_t cpu_to_dump64(DumpState *s, uint64_t val)
64
{
65
    if (s->dump_info.d_endian == ELFDATA2LSB) {
66 67 68 69 70 71 72 73 74 75
        val = cpu_to_le64(val);
    } else {
        val = cpu_to_be64(val);
    }

    return val;
}

static int dump_cleanup(DumpState *s)
{
76
    guest_phys_blocks_free(&s->guest_phys_blocks);
77
    memory_mapping_list_free(&s->list);
78
    close(s->fd);
79 80 81 82
    if (s->resume) {
        vm_start();
    }

83
    return 0;
84 85
}

86
static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
87 88
{
    DumpState *s = opaque;
89 90 91 92 93
    size_t written_size;

    written_size = qemu_write_full(s->fd, buf, size);
    if (written_size != size) {
        return -1;
94 95 96 97 98
    }

    return 0;
}

99
static void write_elf64_header(DumpState *s, Error **errp)
100 101 102 103 104 105 106 107 108
{
    Elf64_Ehdr elf_header;
    int ret;

    memset(&elf_header, 0, sizeof(Elf64_Ehdr));
    memcpy(&elf_header, ELFMAG, SELFMAG);
    elf_header.e_ident[EI_CLASS] = ELFCLASS64;
    elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
    elf_header.e_ident[EI_VERSION] = EV_CURRENT;
109 110 111 112 113 114 115
    elf_header.e_type = cpu_to_dump16(s, ET_CORE);
    elf_header.e_machine = cpu_to_dump16(s, s->dump_info.d_machine);
    elf_header.e_version = cpu_to_dump32(s, EV_CURRENT);
    elf_header.e_ehsize = cpu_to_dump16(s, sizeof(elf_header));
    elf_header.e_phoff = cpu_to_dump64(s, sizeof(Elf64_Ehdr));
    elf_header.e_phentsize = cpu_to_dump16(s, sizeof(Elf64_Phdr));
    elf_header.e_phnum = cpu_to_dump16(s, s->phdr_num);
116 117 118
    if (s->have_section) {
        uint64_t shoff = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) * s->sh_info;

119 120 121
        elf_header.e_shoff = cpu_to_dump64(s, shoff);
        elf_header.e_shentsize = cpu_to_dump16(s, sizeof(Elf64_Shdr));
        elf_header.e_shnum = cpu_to_dump16(s, 1);
122 123 124 125
    }

    ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
    if (ret < 0) {
126
        error_setg(errp, "dump: failed to write elf header");
127 128 129
    }
}

130
static void write_elf32_header(DumpState *s, Error **errp)
131 132 133 134 135 136 137
{
    Elf32_Ehdr elf_header;
    int ret;

    memset(&elf_header, 0, sizeof(Elf32_Ehdr));
    memcpy(&elf_header, ELFMAG, SELFMAG);
    elf_header.e_ident[EI_CLASS] = ELFCLASS32;
138
    elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
139
    elf_header.e_ident[EI_VERSION] = EV_CURRENT;
140 141 142 143 144 145 146
    elf_header.e_type = cpu_to_dump16(s, ET_CORE);
    elf_header.e_machine = cpu_to_dump16(s, s->dump_info.d_machine);
    elf_header.e_version = cpu_to_dump32(s, EV_CURRENT);
    elf_header.e_ehsize = cpu_to_dump16(s, sizeof(elf_header));
    elf_header.e_phoff = cpu_to_dump32(s, sizeof(Elf32_Ehdr));
    elf_header.e_phentsize = cpu_to_dump16(s, sizeof(Elf32_Phdr));
    elf_header.e_phnum = cpu_to_dump16(s, s->phdr_num);
147 148 149
    if (s->have_section) {
        uint32_t shoff = sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * s->sh_info;

150 151 152
        elf_header.e_shoff = cpu_to_dump32(s, shoff);
        elf_header.e_shentsize = cpu_to_dump16(s, sizeof(Elf32_Shdr));
        elf_header.e_shnum = cpu_to_dump16(s, 1);
153 154 155 156
    }

    ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
    if (ret < 0) {
157
        error_setg(errp, "dump: failed to write elf header");
158 159 160
    }
}

161 162 163
static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
                             int phdr_index, hwaddr offset,
                             hwaddr filesz, Error **errp)
164 165 166 167 168
{
    Elf64_Phdr phdr;
    int ret;

    memset(&phdr, 0, sizeof(Elf64_Phdr));
169 170 171 172 173 174
    phdr.p_type = cpu_to_dump32(s, PT_LOAD);
    phdr.p_offset = cpu_to_dump64(s, offset);
    phdr.p_paddr = cpu_to_dump64(s, memory_mapping->phys_addr);
    phdr.p_filesz = cpu_to_dump64(s, filesz);
    phdr.p_memsz = cpu_to_dump64(s, memory_mapping->length);
    phdr.p_vaddr = cpu_to_dump64(s, memory_mapping->virt_addr);
175

176 177
    assert(memory_mapping->length >= filesz);

178 179
    ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
    if (ret < 0) {
180
        error_setg(errp, "dump: failed to write program header table");
181 182 183
    }
}

184 185 186
static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
                             int phdr_index, hwaddr offset,
                             hwaddr filesz, Error **errp)
187 188 189 190 191
{
    Elf32_Phdr phdr;
    int ret;

    memset(&phdr, 0, sizeof(Elf32_Phdr));
192 193 194 195 196 197
    phdr.p_type = cpu_to_dump32(s, PT_LOAD);
    phdr.p_offset = cpu_to_dump32(s, offset);
    phdr.p_paddr = cpu_to_dump32(s, memory_mapping->phys_addr);
    phdr.p_filesz = cpu_to_dump32(s, filesz);
    phdr.p_memsz = cpu_to_dump32(s, memory_mapping->length);
    phdr.p_vaddr = cpu_to_dump32(s, memory_mapping->virt_addr);
198

199 200
    assert(memory_mapping->length >= filesz);

201 202
    ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
    if (ret < 0) {
203
        error_setg(errp, "dump: failed to write program header table");
204 205 206
    }
}

207
static void write_elf64_note(DumpState *s, Error **errp)
208 209
{
    Elf64_Phdr phdr;
210
    hwaddr begin = s->memory_offset - s->note_size;
211 212 213
    int ret;

    memset(&phdr, 0, sizeof(Elf64_Phdr));
214 215
    phdr.p_type = cpu_to_dump32(s, PT_NOTE);
    phdr.p_offset = cpu_to_dump64(s, begin);
216
    phdr.p_paddr = 0;
217 218
    phdr.p_filesz = cpu_to_dump64(s, s->note_size);
    phdr.p_memsz = cpu_to_dump64(s, s->note_size);
219 220 221 222
    phdr.p_vaddr = 0;

    ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
    if (ret < 0) {
223
        error_setg(errp, "dump: failed to write program header table");
224 225 226
    }
}

227 228 229 230 231
static inline int cpu_index(CPUState *cpu)
{
    return cpu->cpu_index + 1;
}

232 233
static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
                              Error **errp)
234
{
235
    CPUState *cpu;
236 237 238
    int ret;
    int id;

239
    CPU_FOREACH(cpu) {
240
        id = cpu_index(cpu);
241
        ret = cpu_write_elf64_note(f, cpu, id, s);
242
        if (ret < 0) {
243
            error_setg(errp, "dump: failed to write elf notes");
244
            return;
245 246 247
        }
    }

248
    CPU_FOREACH(cpu) {
249
        ret = cpu_write_elf64_qemunote(f, cpu, s);
250
        if (ret < 0) {
251
            error_setg(errp, "dump: failed to write CPU status");
252
            return;
253 254 255 256
        }
    }
}

257
static void write_elf32_note(DumpState *s, Error **errp)
258
{
259
    hwaddr begin = s->memory_offset - s->note_size;
260 261 262 263
    Elf32_Phdr phdr;
    int ret;

    memset(&phdr, 0, sizeof(Elf32_Phdr));
264 265
    phdr.p_type = cpu_to_dump32(s, PT_NOTE);
    phdr.p_offset = cpu_to_dump32(s, begin);
266
    phdr.p_paddr = 0;
267 268
    phdr.p_filesz = cpu_to_dump32(s, s->note_size);
    phdr.p_memsz = cpu_to_dump32(s, s->note_size);
269 270 271 272
    phdr.p_vaddr = 0;

    ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
    if (ret < 0) {
273
        error_setg(errp, "dump: failed to write program header table");
274 275 276
    }
}

277 278
static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
                              Error **errp)
279
{
280
    CPUState *cpu;
281 282 283
    int ret;
    int id;

284
    CPU_FOREACH(cpu) {
285
        id = cpu_index(cpu);
286
        ret = cpu_write_elf32_note(f, cpu, id, s);
287
        if (ret < 0) {
288
            error_setg(errp, "dump: failed to write elf notes");
289
            return;
290 291 292
        }
    }

293
    CPU_FOREACH(cpu) {
294
        ret = cpu_write_elf32_qemunote(f, cpu, s);
295
        if (ret < 0) {
296
            error_setg(errp, "dump: failed to write CPU status");
297
            return;
298 299 300 301
        }
    }
}

302
static void write_elf_section(DumpState *s, int type, Error **errp)
303 304 305 306 307 308 309 310 311 312
{
    Elf32_Shdr shdr32;
    Elf64_Shdr shdr64;
    int shdr_size;
    void *shdr;
    int ret;

    if (type == 0) {
        shdr_size = sizeof(Elf32_Shdr);
        memset(&shdr32, 0, shdr_size);
313
        shdr32.sh_info = cpu_to_dump32(s, s->sh_info);
314 315 316 317
        shdr = &shdr32;
    } else {
        shdr_size = sizeof(Elf64_Shdr);
        memset(&shdr64, 0, shdr_size);
318
        shdr64.sh_info = cpu_to_dump32(s, s->sh_info);
319 320 321 322 323
        shdr = &shdr64;
    }

    ret = fd_write_vmcore(&shdr, shdr_size, s);
    if (ret < 0) {
324
        error_setg(errp, "dump: failed to write section header table");
325 326 327
    }
}

328
static void write_data(DumpState *s, void *buf, int length, Error **errp)
329 330 331 332 333
{
    int ret;

    ret = fd_write_vmcore(buf, length, s);
    if (ret < 0) {
334
        error_setg(errp, "dump: failed to save memory");
335 336
    } else {
        s->written_size += length;
337 338 339
    }
}

340 341 342
/* write the memory to vmcore. 1 page per I/O. */
static void write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,
                         int64_t size, Error **errp)
343 344
{
    int64_t i;
345
    Error *local_err = NULL;
346

347 348 349
    for (i = 0; i < size / s->dump_info.page_size; i++) {
        write_data(s, block->host_addr + start + i * s->dump_info.page_size,
                   s->dump_info.page_size, &local_err);
350 351 352
        if (local_err) {
            error_propagate(errp, local_err);
            return;
353 354 355
        }
    }

356 357 358
    if ((size % s->dump_info.page_size) != 0) {
        write_data(s, block->host_addr + start + i * s->dump_info.page_size,
                   size % s->dump_info.page_size, &local_err);
359 360 361
        if (local_err) {
            error_propagate(errp, local_err);
            return;
362 363 364 365
        }
    }
}

366 367 368 369 370 371
/* get the memory's offset and size in the vmcore */
static void get_offset_range(hwaddr phys_addr,
                             ram_addr_t mapping_length,
                             DumpState *s,
                             hwaddr *p_offset,
                             hwaddr *p_filesz)
372
{
373
    GuestPhysBlock *block;
374
    hwaddr offset = s->memory_offset;
375 376
    int64_t size_in_block, start;

377 378 379 380
    /* When the memory is not stored into vmcore, offset will be -1 */
    *p_offset = -1;
    *p_filesz = 0;

381 382
    if (s->has_filter) {
        if (phys_addr < s->begin || phys_addr >= s->begin + s->length) {
383
            return;
384 385 386
        }
    }

387
    QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
388
        if (s->has_filter) {
389 390
            if (block->target_start >= s->begin + s->length ||
                block->target_end <= s->begin) {
391 392 393 394
                /* This block is out of the range */
                continue;
            }

395 396
            if (s->begin <= block->target_start) {
                start = block->target_start;
397 398 399 400
            } else {
                start = s->begin;
            }

401 402 403
            size_in_block = block->target_end - start;
            if (s->begin + s->length < block->target_end) {
                size_in_block -= block->target_end - (s->begin + s->length);
404 405
            }
        } else {
406 407
            start = block->target_start;
            size_in_block = block->target_end - block->target_start;
408 409 410
        }

        if (phys_addr >= start && phys_addr < start + size_in_block) {
411 412 413
            *p_offset = phys_addr - start + offset;

            /* The offset range mapped from the vmcore file must not spill over
414
             * the GuestPhysBlock, clamp it. The rest of the mapping will be
415 416 417 418 419 420 421
             * zero-filled in memory at load time; see
             * <http://refspecs.linuxbase.org/elf/gabi4+/ch5.pheader.html>.
             */
            *p_filesz = phys_addr + mapping_length <= start + size_in_block ?
                        mapping_length :
                        size_in_block - (phys_addr - start);
            return;
422 423 424 425 426 427
        }

        offset += size_in_block;
    }
}

428
static void write_elf_loads(DumpState *s, Error **errp)
429
{
430
    hwaddr offset, filesz;
431 432 433
    MemoryMapping *memory_mapping;
    uint32_t phdr_index = 1;
    uint32_t max_index;
434
    Error *local_err = NULL;
435 436 437 438 439 440 441 442

    if (s->have_section) {
        max_index = s->sh_info;
    } else {
        max_index = s->phdr_num;
    }

    QTAILQ_FOREACH(memory_mapping, &s->list.head, next) {
443 444 445
        get_offset_range(memory_mapping->phys_addr,
                         memory_mapping->length,
                         s, &offset, &filesz);
446
        if (s->dump_info.d_class == ELFCLASS64) {
447 448
            write_elf64_load(s, memory_mapping, phdr_index++, offset,
                             filesz, &local_err);
449
        } else {
450 451
            write_elf32_load(s, memory_mapping, phdr_index++, offset,
                             filesz, &local_err);
452 453
        }

454 455 456
        if (local_err) {
            error_propagate(errp, local_err);
            return;
457 458 459 460 461 462 463 464 465
        }

        if (phdr_index >= max_index) {
            break;
        }
    }
}

/* write elf header, PT_NOTE and elf note to vmcore. */
466
static void dump_begin(DumpState *s, Error **errp)
467
{
468
    Error *local_err = NULL;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

    /*
     * the vmcore's format is:
     *   --------------
     *   |  elf header |
     *   --------------
     *   |  PT_NOTE    |
     *   --------------
     *   |  PT_LOAD    |
     *   --------------
     *   |  ......     |
     *   --------------
     *   |  PT_LOAD    |
     *   --------------
     *   |  sec_hdr    |
     *   --------------
     *   |  elf note   |
     *   --------------
     *   |  memory     |
     *   --------------
     *
     * we only know where the memory is saved after we write elf note into
     * vmcore.
     */

    /* write elf header to vmcore */
    if (s->dump_info.d_class == ELFCLASS64) {
496
        write_elf64_header(s, &local_err);
497
    } else {
498
        write_elf32_header(s, &local_err);
499
    }
500 501 502
    if (local_err) {
        error_propagate(errp, local_err);
        return;
503 504 505 506
    }

    if (s->dump_info.d_class == ELFCLASS64) {
        /* write PT_NOTE to vmcore */
507 508 509 510
        write_elf64_note(s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
511 512 513
        }

        /* write all PT_LOAD to vmcore */
514 515 516 517
        write_elf_loads(s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
518 519 520 521
        }

        /* write section to vmcore */
        if (s->have_section) {
522 523 524 525
            write_elf_section(s, 1, &local_err);
            if (local_err) {
                error_propagate(errp, local_err);
                return;
526 527 528 529
            }
        }

        /* write notes to vmcore */
530 531 532 533
        write_elf64_notes(fd_write_vmcore, s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
534 535 536
        }
    } else {
        /* write PT_NOTE to vmcore */
537 538 539 540
        write_elf32_note(s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
541 542 543
        }

        /* write all PT_LOAD to vmcore */
544 545 546 547
        write_elf_loads(s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
548 549 550 551
        }

        /* write section to vmcore */
        if (s->have_section) {
552 553 554 555
            write_elf_section(s, 0, &local_err);
            if (local_err) {
                error_propagate(errp, local_err);
                return;
556 557 558 559
            }
        }

        /* write notes to vmcore */
560 561 562 563
        write_elf32_notes(fd_write_vmcore, s, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
564 565 566 567
        }
    }
}

568
static int get_next_block(DumpState *s, GuestPhysBlock *block)
569 570
{
    while (1) {
571
        block = QTAILQ_NEXT(block, next);
572 573 574 575 576 577
        if (!block) {
            /* no more block */
            return 1;
        }

        s->start = 0;
578
        s->next_block = block;
579
        if (s->has_filter) {
580 581
            if (block->target_start >= s->begin + s->length ||
                block->target_end <= s->begin) {
582 583 584 585
                /* This block is out of the range */
                continue;
            }

586 587
            if (s->begin > block->target_start) {
                s->start = s->begin - block->target_start;
588 589 590 591 592 593 594 595
            }
        }

        return 0;
    }
}

/* write all memory to vmcore */
596
static void dump_iterate(DumpState *s, Error **errp)
597
{
598
    GuestPhysBlock *block;
599
    int64_t size;
600
    Error *local_err = NULL;
601

602
    do {
603
        block = s->next_block;
604

605
        size = block->target_end - block->target_start;
606 607
        if (s->has_filter) {
            size -= s->start;
608 609
            if (s->begin + s->length < block->target_end) {
                size -= block->target_end - (s->begin + s->length);
610 611
            }
        }
612 613 614 615
        write_memory(s, block, s->start, size, &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
616 617
        }

618
    } while (!get_next_block(s, block));
619 620
}

621
static void create_vmcore(DumpState *s, Error **errp)
622
{
623
    Error *local_err = NULL;
624

625 626 627 628
    dump_begin(s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
629 630
    }

631
    dump_iterate(s, errp);
632 633
}

634 635
static int write_start_flat_header(int fd)
{
636
    MakedumpfileHeader *mh;
637 638
    int ret = 0;

639 640
    QEMU_BUILD_BUG_ON(sizeof *mh > MAX_SIZE_MDF_HEADER);
    mh = g_malloc0(MAX_SIZE_MDF_HEADER);
641

642 643
    memcpy(mh->signature, MAKEDUMPFILE_SIGNATURE,
           MIN(sizeof mh->signature, sizeof MAKEDUMPFILE_SIGNATURE));
644

645 646
    mh->type = cpu_to_be64(TYPE_FLAT_HEADER);
    mh->version = cpu_to_be64(VERSION_FLAT_HEADER);
647 648

    size_t written_size;
649
    written_size = qemu_write_full(fd, mh, MAX_SIZE_MDF_HEADER);
650 651 652 653
    if (written_size != MAX_SIZE_MDF_HEADER) {
        ret = -1;
    }

654
    g_free(mh);
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
    return ret;
}

static int write_end_flat_header(int fd)
{
    MakedumpfileDataHeader mdh;

    mdh.offset = END_FLAG_FLAT_HEADER;
    mdh.buf_size = END_FLAG_FLAT_HEADER;

    size_t written_size;
    written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
    if (written_size != sizeof(mdh)) {
        return -1;
    }

    return 0;
}

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
static int write_buffer(int fd, off_t offset, const void *buf, size_t size)
{
    size_t written_size;
    MakedumpfileDataHeader mdh;

    mdh.offset = cpu_to_be64(offset);
    mdh.buf_size = cpu_to_be64(size);

    written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
    if (written_size != sizeof(mdh)) {
        return -1;
    }

    written_size = qemu_write_full(fd, buf, size);
    if (written_size != size) {
        return -1;
    }

    return 0;
}

695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
static int buf_write_note(const void *buf, size_t size, void *opaque)
{
    DumpState *s = opaque;

    /* note_buf is not enough */
    if (s->note_buf_offset + size > s->note_size) {
        return -1;
    }

    memcpy(s->note_buf + s->note_buf_offset, buf, size);

    s->note_buf_offset += size;

    return 0;
}

711
/* write common header, sub header and elf note to vmcore */
712
static void create_header32(DumpState *s, Error **errp)
713 714 715 716 717 718 719 720 721
{
    DiskDumpHeader32 *dh = NULL;
    KdumpSubHeader32 *kh = NULL;
    size_t size;
    uint32_t block_size;
    uint32_t sub_hdr_size;
    uint32_t bitmap_blocks;
    uint32_t status = 0;
    uint64_t offset_note;
722
    Error *local_err = NULL;
723 724 725 726 727 728

    /* write common header, the version of kdump-compressed format is 6th */
    size = sizeof(DiskDumpHeader32);
    dh = g_malloc0(size);

    strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE));
729
    dh->header_version = cpu_to_dump32(s, 6);
730
    block_size = s->dump_info.page_size;
731
    dh->block_size = cpu_to_dump32(s, block_size);
732 733
    sub_hdr_size = sizeof(struct KdumpSubHeader32) + s->note_size;
    sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
734
    dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
735
    /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
736 737
    dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
    dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
738
    bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
739
    dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
740
    strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
741 742 743 744 745 746 747 748 749 750 751 752 753 754

    if (s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) {
        status |= DUMP_DH_COMPRESSED_ZLIB;
    }
#ifdef CONFIG_LZO
    if (s->flag_compress & DUMP_DH_COMPRESSED_LZO) {
        status |= DUMP_DH_COMPRESSED_LZO;
    }
#endif
#ifdef CONFIG_SNAPPY
    if (s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) {
        status |= DUMP_DH_COMPRESSED_SNAPPY;
    }
#endif
755
    dh->status = cpu_to_dump32(s, status);
756 757

    if (write_buffer(s->fd, 0, dh, size) < 0) {
758
        error_setg(errp, "dump: failed to write disk dump header");
759 760 761 762 763 764 765 766
        goto out;
    }

    /* write sub header */
    size = sizeof(KdumpSubHeader32);
    kh = g_malloc0(size);

    /* 64bit max_mapnr_64 */
767
    kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
768
    kh->phys_base = cpu_to_dump32(s, s->dump_info.phys_base);
769
    kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
770 771

    offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
772 773
    kh->offset_note = cpu_to_dump64(s, offset_note);
    kh->note_size = cpu_to_dump32(s, s->note_size);
774 775 776

    if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
                     block_size, kh, size) < 0) {
777
        error_setg(errp, "dump: failed to write kdump sub header");
778 779 780 781 782 783 784 785
        goto out;
    }

    /* write note */
    s->note_buf = g_malloc0(s->note_size);
    s->note_buf_offset = 0;

    /* use s->note_buf to store notes temporarily */
786 787 788
    write_elf32_notes(buf_write_note, s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
789 790 791 792
        goto out;
    }
    if (write_buffer(s->fd, offset_note, s->note_buf,
                     s->note_size) < 0) {
793
        error_setg(errp, "dump: failed to write notes");
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
        goto out;
    }

    /* get offset of dump_bitmap */
    s->offset_dump_bitmap = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size) *
                             block_size;

    /* get offset of page */
    s->offset_page = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size + bitmap_blocks) *
                     block_size;

out:
    g_free(dh);
    g_free(kh);
    g_free(s->note_buf);
}

/* write common header, sub header and elf note to vmcore */
812
static void create_header64(DumpState *s, Error **errp)
813 814 815 816 817 818 819 820 821
{
    DiskDumpHeader64 *dh = NULL;
    KdumpSubHeader64 *kh = NULL;
    size_t size;
    uint32_t block_size;
    uint32_t sub_hdr_size;
    uint32_t bitmap_blocks;
    uint32_t status = 0;
    uint64_t offset_note;
822
    Error *local_err = NULL;
823 824 825 826 827 828

    /* write common header, the version of kdump-compressed format is 6th */
    size = sizeof(DiskDumpHeader64);
    dh = g_malloc0(size);

    strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE));
829
    dh->header_version = cpu_to_dump32(s, 6);
830
    block_size = s->dump_info.page_size;
831
    dh->block_size = cpu_to_dump32(s, block_size);
832 833
    sub_hdr_size = sizeof(struct KdumpSubHeader64) + s->note_size;
    sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
834
    dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
835
    /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
836 837
    dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
    dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
838
    bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
839
    dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
840
    strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
841 842 843 844 845 846 847 848 849 850 851 852 853 854

    if (s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) {
        status |= DUMP_DH_COMPRESSED_ZLIB;
    }
#ifdef CONFIG_LZO
    if (s->flag_compress & DUMP_DH_COMPRESSED_LZO) {
        status |= DUMP_DH_COMPRESSED_LZO;
    }
#endif
#ifdef CONFIG_SNAPPY
    if (s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) {
        status |= DUMP_DH_COMPRESSED_SNAPPY;
    }
#endif
855
    dh->status = cpu_to_dump32(s, status);
856 857

    if (write_buffer(s->fd, 0, dh, size) < 0) {
858
        error_setg(errp, "dump: failed to write disk dump header");
859 860 861 862 863 864 865 866
        goto out;
    }

    /* write sub header */
    size = sizeof(KdumpSubHeader64);
    kh = g_malloc0(size);

    /* 64bit max_mapnr_64 */
867
    kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
868
    kh->phys_base = cpu_to_dump64(s, s->dump_info.phys_base);
869
    kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
870 871

    offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
872 873
    kh->offset_note = cpu_to_dump64(s, offset_note);
    kh->note_size = cpu_to_dump64(s, s->note_size);
874 875 876

    if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
                     block_size, kh, size) < 0) {
877
        error_setg(errp, "dump: failed to write kdump sub header");
878 879 880 881 882 883 884 885
        goto out;
    }

    /* write note */
    s->note_buf = g_malloc0(s->note_size);
    s->note_buf_offset = 0;

    /* use s->note_buf to store notes temporarily */
886 887 888
    write_elf64_notes(buf_write_note, s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
889 890 891 892 893
        goto out;
    }

    if (write_buffer(s->fd, offset_note, s->note_buf,
                     s->note_size) < 0) {
894
        error_setg(errp, "dump: failed to write notes");
895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
        goto out;
    }

    /* get offset of dump_bitmap */
    s->offset_dump_bitmap = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size) *
                             block_size;

    /* get offset of page */
    s->offset_page = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size + bitmap_blocks) *
                     block_size;

out:
    g_free(dh);
    g_free(kh);
    g_free(s->note_buf);
}

912
static void write_dump_header(DumpState *s, Error **errp)
913
{
914 915
     Error *local_err = NULL;

916
    if (s->dump_info.d_class == ELFCLASS32) {
917
        create_header32(s, &local_err);
918
    } else {
919 920 921 922
        create_header64(s, &local_err);
    }
    if (local_err) {
        error_propagate(errp, local_err);
923 924 925
    }
}

926 927 928 929 930
static size_t dump_bitmap_get_bufsize(DumpState *s)
{
    return s->dump_info.page_size;
}

931 932 933 934 935 936 937 938 939 940 941 942 943
/*
 * set dump_bitmap sequencely. the bit before last_pfn is not allowed to be
 * rewritten, so if need to set the first bit, set last_pfn and pfn to 0.
 * set_dump_bitmap will always leave the recently set bit un-sync. And setting
 * (last bit + sizeof(buf) * 8) to 0 will do flushing the content in buf into
 * vmcore, ie. synchronizing un-sync bit into vmcore.
 */
static int set_dump_bitmap(uint64_t last_pfn, uint64_t pfn, bool value,
                           uint8_t *buf, DumpState *s)
{
    off_t old_offset, new_offset;
    off_t offset_bitmap1, offset_bitmap2;
    uint32_t byte, bit;
944 945
    size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
    size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
946 947 948 949 950 951 952 953 954 955

    /* should not set the previous place */
    assert(last_pfn <= pfn);

    /*
     * if the bit needed to be set is not cached in buf, flush the data in buf
     * to vmcore firstly.
     * making new_offset be bigger than old_offset can also sync remained data
     * into vmcore.
     */
956 957
    old_offset = bitmap_bufsize * (last_pfn / bits_per_buf);
    new_offset = bitmap_bufsize * (pfn / bits_per_buf);
958 959 960 961 962

    while (old_offset < new_offset) {
        /* calculate the offset and write dump_bitmap */
        offset_bitmap1 = s->offset_dump_bitmap + old_offset;
        if (write_buffer(s->fd, offset_bitmap1, buf,
963
                         bitmap_bufsize) < 0) {
964 965 966 967 968 969 970
            return -1;
        }

        /* dump level 1 is chosen, so 1st and 2nd bitmap are same */
        offset_bitmap2 = s->offset_dump_bitmap + s->len_dump_bitmap +
                         old_offset;
        if (write_buffer(s->fd, offset_bitmap2, buf,
971
                         bitmap_bufsize) < 0) {
972 973 974
            return -1;
        }

975 976
        memset(buf, 0, bitmap_bufsize);
        old_offset += bitmap_bufsize;
977 978 979
    }

    /* get the exact place of the bit in the buf, and set it */
980 981
    byte = (pfn % bits_per_buf) / CHAR_BIT;
    bit = (pfn % bits_per_buf) % CHAR_BIT;
982 983 984 985 986 987 988 989 990
    if (value) {
        buf[byte] |= 1u << bit;
    } else {
        buf[byte] &= ~(1u << bit);
    }

    return 0;
}

991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
static uint64_t dump_paddr_to_pfn(DumpState *s, uint64_t addr)
{
    int target_page_shift = ctz32(s->dump_info.page_size);

    return (addr >> target_page_shift) - ARCH_PFN_OFFSET;
}

static uint64_t dump_pfn_to_paddr(DumpState *s, uint64_t pfn)
{
    int target_page_shift = ctz32(s->dump_info.page_size);

    return (pfn + ARCH_PFN_OFFSET) << target_page_shift;
}

1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
/*
 * exam every page and return the page frame number and the address of the page.
 * bufptr can be NULL. note: the blocks here is supposed to reflect guest-phys
 * blocks, so block->target_start and block->target_end should be interal
 * multiples of the target page size.
 */
static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr,
                          uint8_t **bufptr, DumpState *s)
{
    GuestPhysBlock *block = *blockptr;
1015
    hwaddr addr, target_page_mask = ~((hwaddr)s->dump_info.page_size - 1);
1016 1017 1018 1019 1020 1021
    uint8_t *buf;

    /* block == NULL means the start of the iteration */
    if (!block) {
        block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
        *blockptr = block;
1022 1023 1024
        assert((block->target_start & ~target_page_mask) == 0);
        assert((block->target_end & ~target_page_mask) == 0);
        *pfnptr = dump_paddr_to_pfn(s, block->target_start);
1025 1026 1027 1028 1029 1030 1031
        if (bufptr) {
            *bufptr = block->host_addr;
        }
        return true;
    }

    *pfnptr = *pfnptr + 1;
1032
    addr = dump_pfn_to_paddr(s, *pfnptr);
1033 1034

    if ((addr >= block->target_start) &&
1035
        (addr + s->dump_info.page_size <= block->target_end)) {
1036 1037 1038 1039 1040 1041 1042 1043
        buf = block->host_addr + (addr - block->target_start);
    } else {
        /* the next page is in the next block */
        block = QTAILQ_NEXT(block, next);
        *blockptr = block;
        if (!block) {
            return false;
        }
1044 1045 1046
        assert((block->target_start & ~target_page_mask) == 0);
        assert((block->target_end & ~target_page_mask) == 0);
        *pfnptr = dump_paddr_to_pfn(s, block->target_start);
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
        buf = block->host_addr;
    }

    if (bufptr) {
        *bufptr = buf;
    }

    return true;
}

1057
static void write_dump_bitmap(DumpState *s, Error **errp)
1058 1059 1060 1061 1062 1063
{
    int ret = 0;
    uint64_t last_pfn, pfn;
    void *dump_bitmap_buf;
    size_t num_dumpable;
    GuestPhysBlock *block_iter = NULL;
1064 1065
    size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
    size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
1066 1067

    /* dump_bitmap_buf is used to store dump_bitmap temporarily */
1068
    dump_bitmap_buf = g_malloc0(bitmap_bufsize);
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079

    num_dumpable = 0;
    last_pfn = 0;

    /*
     * exam memory page by page, and set the bit in dump_bitmap corresponded
     * to the existing page.
     */
    while (get_next_page(&block_iter, &pfn, NULL, s)) {
        ret = set_dump_bitmap(last_pfn, pfn, true, dump_bitmap_buf, s);
        if (ret < 0) {
1080
            error_setg(errp, "dump: failed to set dump_bitmap");
1081 1082 1083 1084 1085 1086 1087 1088 1089
            goto out;
        }

        last_pfn = pfn;
        num_dumpable++;
    }

    /*
     * set_dump_bitmap will always leave the recently set bit un-sync. Here we
1090 1091
     * set the remaining bits from last_pfn to the end of the bitmap buffer to
     * 0. With those set, the un-sync bit will be synchronized into the vmcore.
1092 1093
     */
    if (num_dumpable > 0) {
1094
        ret = set_dump_bitmap(last_pfn, last_pfn + bits_per_buf, false,
1095 1096
                              dump_bitmap_buf, s);
        if (ret < 0) {
1097
            error_setg(errp, "dump: failed to sync dump_bitmap");
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
            goto out;
        }
    }

    /* number of dumpable pages that will be dumped later */
    s->num_dumpable = num_dumpable;

out:
    g_free(dump_bitmap_buf);
}

1109 1110 1111 1112 1113
static void prepare_data_cache(DataCache *data_cache, DumpState *s,
                               off_t offset)
{
    data_cache->fd = s->fd;
    data_cache->data_size = 0;
1114 1115
    data_cache->buf_size = 4 * dump_bitmap_get_bufsize(s);
    data_cache->buf = g_malloc0(data_cache->buf_size);
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
    data_cache->offset = offset;
}

static int write_cache(DataCache *dc, const void *buf, size_t size,
                       bool flag_sync)
{
    /*
     * dc->buf_size should not be less than size, otherwise dc will never be
     * enough
     */
    assert(size <= dc->buf_size);

    /*
     * if flag_sync is set, synchronize data in dc->buf into vmcore.
     * otherwise check if the space is enough for caching data in buf, if not,
     * write the data in dc->buf to dc->fd and reset dc->buf
     */
    if ((!flag_sync && dc->data_size + size > dc->buf_size) ||
        (flag_sync && dc->data_size > 0)) {
        if (write_buffer(dc->fd, dc->offset, dc->buf, dc->data_size) < 0) {
            return -1;
        }

        dc->offset += dc->data_size;
        dc->data_size = 0;
    }

    if (!flag_sync) {
        memcpy(dc->buf + dc->data_size, buf, size);
        dc->data_size += size;
    }

    return 0;
}

static void free_data_cache(DataCache *data_cache)
{
    g_free(data_cache->buf);
}

1156 1157
static size_t get_len_buf_out(size_t page_size, uint32_t flag_compress)
{
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
    switch (flag_compress) {
    case DUMP_DH_COMPRESSED_ZLIB:
        return compressBound(page_size);

    case DUMP_DH_COMPRESSED_LZO:
        /*
         * LZO will expand incompressible data by a little amount. Please check
         * the following URL to see the expansion calculation:
         * http://www.oberhumer.com/opensource/lzo/lzofaq.php
         */
        return page_size + page_size / 16 + 64 + 3;
1169 1170

#ifdef CONFIG_SNAPPY
1171 1172
    case DUMP_DH_COMPRESSED_SNAPPY:
        return snappy_max_compressed_length(page_size);
1173
#endif
1174 1175
    }
    return 0;
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
}

/*
 * check if the page is all 0
 */
static inline bool is_zero_page(const uint8_t *buf, size_t page_size)
{
    return buffer_is_zero(buf, page_size);
}

1186
static void write_dump_pages(DumpState *s, Error **errp)
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
{
    int ret = 0;
    DataCache page_desc, page_data;
    size_t len_buf_out, size_out;
#ifdef CONFIG_LZO
    lzo_bytep wrkmem = NULL;
#endif
    uint8_t *buf_out = NULL;
    off_t offset_desc, offset_data;
    PageDescriptor pd, pd_zero;
    uint8_t *buf;
    GuestPhysBlock *block_iter = NULL;
    uint64_t pfn_iter;

    /* get offset of page_desc and page_data in dump file */
    offset_desc = s->offset_page;
    offset_data = offset_desc + sizeof(PageDescriptor) * s->num_dumpable;

    prepare_data_cache(&page_desc, s, offset_desc);
    prepare_data_cache(&page_data, s, offset_data);

    /* prepare buffer to store compressed data */
1209
    len_buf_out = get_len_buf_out(s->dump_info.page_size, s->flag_compress);
1210
    assert(len_buf_out != 0);
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221

#ifdef CONFIG_LZO
    wrkmem = g_malloc(LZO1X_1_MEM_COMPRESS);
#endif

    buf_out = g_malloc(len_buf_out);

    /*
     * init zero page's page_desc and page_data, because every zero page
     * uses the same page_data
     */
1222
    pd_zero.size = cpu_to_dump32(s, s->dump_info.page_size);
1223 1224 1225
    pd_zero.flags = cpu_to_dump32(s, 0);
    pd_zero.offset = cpu_to_dump64(s, offset_data);
    pd_zero.page_flags = cpu_to_dump64(s, 0);
1226 1227
    buf = g_malloc0(s->dump_info.page_size);
    ret = write_cache(&page_data, buf, s->dump_info.page_size, false);
1228 1229
    g_free(buf);
    if (ret < 0) {
1230
        error_setg(errp, "dump: failed to write page data (zero page)");
1231 1232 1233
        goto out;
    }

1234
    offset_data += s->dump_info.page_size;
1235 1236 1237 1238 1239 1240 1241

    /*
     * dump memory to vmcore page by page. zero page will all be resided in the
     * first page of page section
     */
    while (get_next_page(&block_iter, &pfn_iter, &buf, s)) {
        /* check zero page */
1242
        if (is_zero_page(buf, s->dump_info.page_size)) {
1243 1244 1245
            ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor),
                              false);
            if (ret < 0) {
1246
                error_setg(errp, "dump: failed to write page desc");
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
                goto out;
            }
        } else {
            /*
             * not zero page, then:
             * 1. compress the page
             * 2. write the compressed page into the cache of page_data
             * 3. get page desc of the compressed page and write it into the
             *    cache of page_desc
             *
             * only one compression format will be used here, for
             * s->flag_compress is set. But when compression fails to work,
             * we fall back to save in plaintext.
             */
             size_out = len_buf_out;
             if ((s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) &&
1263
                    (compress2(buf_out, (uLongf *)&size_out, buf,
1264 1265
                               s->dump_info.page_size, Z_BEST_SPEED) == Z_OK) &&
                    (size_out < s->dump_info.page_size)) {
1266 1267
                pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_ZLIB);
                pd.size  = cpu_to_dump32(s, size_out);
1268 1269 1270

                ret = write_cache(&page_data, buf_out, size_out, false);
                if (ret < 0) {
1271
                    error_setg(errp, "dump: failed to write page data");
1272 1273 1274 1275
                    goto out;
                }
#ifdef CONFIG_LZO
            } else if ((s->flag_compress & DUMP_DH_COMPRESSED_LZO) &&
1276
                    (lzo1x_1_compress(buf, s->dump_info.page_size, buf_out,
1277
                    (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) &&
1278
                    (size_out < s->dump_info.page_size)) {
1279 1280
                pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_LZO);
                pd.size  = cpu_to_dump32(s, size_out);
1281 1282 1283

                ret = write_cache(&page_data, buf_out, size_out, false);
                if (ret < 0) {
1284
                    error_setg(errp, "dump: failed to write page data");
1285 1286 1287 1288 1289
                    goto out;
                }
#endif
#ifdef CONFIG_SNAPPY
            } else if ((s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) &&
1290
                    (snappy_compress((char *)buf, s->dump_info.page_size,
1291
                    (char *)buf_out, &size_out) == SNAPPY_OK) &&
1292
                    (size_out < s->dump_info.page_size)) {
1293 1294
                pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_SNAPPY);
                pd.size  = cpu_to_dump32(s, size_out);
1295 1296 1297

                ret = write_cache(&page_data, buf_out, size_out, false);
                if (ret < 0) {
1298
                    error_setg(errp, "dump: failed to write page data");
1299 1300 1301 1302 1303 1304
                    goto out;
                }
#endif
            } else {
                /*
                 * fall back to save in plaintext, size_out should be
1305
                 * assigned the target's page size
1306
                 */
1307
                pd.flags = cpu_to_dump32(s, 0);
1308
                size_out = s->dump_info.page_size;
1309
                pd.size = cpu_to_dump32(s, size_out);
1310

1311 1312
                ret = write_cache(&page_data, buf,
                                  s->dump_info.page_size, false);
1313
                if (ret < 0) {
1314
                    error_setg(errp, "dump: failed to write page data");
1315 1316 1317 1318 1319
                    goto out;
                }
            }

            /* get and write page desc here */
1320 1321
            pd.page_flags = cpu_to_dump64(s, 0);
            pd.offset = cpu_to_dump64(s, offset_data);
1322 1323 1324 1325
            offset_data += size_out;

            ret = write_cache(&page_desc, &pd, sizeof(PageDescriptor), false);
            if (ret < 0) {
1326
                error_setg(errp, "dump: failed to write page desc");
1327 1328 1329
                goto out;
            }
        }
1330
        s->written_size += s->dump_info.page_size;
1331 1332 1333 1334
    }

    ret = write_cache(&page_desc, NULL, 0, true);
    if (ret < 0) {
1335
        error_setg(errp, "dump: failed to sync cache for page_desc");
1336 1337 1338 1339
        goto out;
    }
    ret = write_cache(&page_data, NULL, 0, true);
    if (ret < 0) {
1340
        error_setg(errp, "dump: failed to sync cache for page_data");
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
        goto out;
    }

out:
    free_data_cache(&page_desc);
    free_data_cache(&page_data);

#ifdef CONFIG_LZO
    g_free(wrkmem);
#endif

    g_free(buf_out);
}

1355
static void create_kdump_vmcore(DumpState *s, Error **errp)
1356 1357
{
    int ret;
1358
    Error *local_err = NULL;
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383

    /*
     * the kdump-compressed format is:
     *                                               File offset
     *  +------------------------------------------+ 0x0
     *  |    main header (struct disk_dump_header) |
     *  |------------------------------------------+ block 1
     *  |    sub header (struct kdump_sub_header)  |
     *  |------------------------------------------+ block 2
     *  |            1st-dump_bitmap               |
     *  |------------------------------------------+ block 2 + X blocks
     *  |            2nd-dump_bitmap               | (aligned by block)
     *  |------------------------------------------+ block 2 + 2 * X blocks
     *  |  page desc for pfn 0 (struct page_desc)  | (aligned by block)
     *  |  page desc for pfn 1 (struct page_desc)  |
     *  |                    :                     |
     *  |------------------------------------------| (not aligned by block)
     *  |         page data (pfn 0)                |
     *  |         page data (pfn 1)                |
     *  |                    :                     |
     *  +------------------------------------------+
     */

    ret = write_start_flat_header(s->fd);
    if (ret < 0) {
1384
        error_setg(errp, "dump: failed to write start flat header");
1385
        return;
1386 1387
    }

1388 1389 1390 1391
    write_dump_header(s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
1392 1393
    }

1394 1395 1396 1397
    write_dump_bitmap(s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
1398 1399
    }

1400 1401 1402 1403
    write_dump_pages(s, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
1404 1405 1406 1407
    }

    ret = write_end_flat_header(s->fd);
    if (ret < 0) {
1408
        error_setg(errp, "dump: failed to write end flat header");
1409
        return;
1410 1411 1412
    }
}

1413 1414
static ram_addr_t get_start_block(DumpState *s)
{
1415
    GuestPhysBlock *block;
1416 1417

    if (!s->has_filter) {
1418
        s->next_block = QTAILQ_FIRST(&s->guest_phys_blocks.head);