Dump
S: Supported
M: Marc-André Lureau <marcandre.lureau@redhat.com>
-F: dump.c
+F: dump/dump.c
F: hw/misc/vmcoreinfo.c
F: include/hw/misc/vmcoreinfo.h
F: include/sysemu/dump-arch.h
ifdef CONFIG_SOFTMMU
obj-y += arch_init.o cpus.o gdbstub.o balloon.o ioport.o
obj-y += qtest.o
+obj-y += dump/
obj-y += hw/
obj-y += monitor/
obj-y += qapi/
obj-y += memory.o
obj-y += memory_mapping.o
-obj-y += dump.o
-obj-$(TARGET_X86_64) += win_dump.o
obj-y += migration/ram.o
LIBS := $(libs_softmmu) $(LIBS)
+++ /dev/null
-/*
- * QEMU dump
- *
- * Copyright Fujitsu, Corp. 2011, 2012
- *
- * Authors:
- * Wen Congyang <wency@cn.fujitsu.com>
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- *
- */
-
-#include "qemu/osdep.h"
-#include "qemu-common.h"
-#include "qemu/cutils.h"
-#include "elf.h"
-#include "cpu.h"
-#include "exec/hwaddr.h"
-#include "monitor/monitor.h"
-#include "sysemu/kvm.h"
-#include "sysemu/dump.h"
-#include "sysemu/sysemu.h"
-#include "sysemu/memory_mapping.h"
-#include "sysemu/cpus.h"
-#include "qapi/error.h"
-#include "qapi/qapi-commands-dump.h"
-#include "qapi/qapi-events-dump.h"
-#include "qapi/qmp/qerror.h"
-#include "qemu/error-report.h"
-#include "hw/misc/vmcoreinfo.h"
-
-#ifdef TARGET_X86_64
-#include "win_dump.h"
-#endif
-
-#include <zlib.h>
-#ifdef CONFIG_LZO
-#include <lzo/lzo1x.h>
-#endif
-#ifdef CONFIG_SNAPPY
-#include <snappy-c.h>
-#endif
-#ifndef ELF_MACHINE_UNAME
-#define ELF_MACHINE_UNAME "Unknown"
-#endif
-
-#define MAX_GUEST_NOTE_SIZE (1 << 20) /* 1MB should be enough */
-
-#define ELF_NOTE_SIZE(hdr_size, name_size, desc_size) \
- ((DIV_ROUND_UP((hdr_size), 4) + \
- DIV_ROUND_UP((name_size), 4) + \
- DIV_ROUND_UP((desc_size), 4)) * 4)
-
-uint16_t cpu_to_dump16(DumpState *s, uint16_t val)
-{
- if (s->dump_info.d_endian == ELFDATA2LSB) {
- val = cpu_to_le16(val);
- } else {
- val = cpu_to_be16(val);
- }
-
- return val;
-}
-
-uint32_t cpu_to_dump32(DumpState *s, uint32_t val)
-{
- if (s->dump_info.d_endian == ELFDATA2LSB) {
- val = cpu_to_le32(val);
- } else {
- val = cpu_to_be32(val);
- }
-
- return val;
-}
-
-uint64_t cpu_to_dump64(DumpState *s, uint64_t val)
-{
- if (s->dump_info.d_endian == ELFDATA2LSB) {
- val = cpu_to_le64(val);
- } else {
- val = cpu_to_be64(val);
- }
-
- return val;
-}
-
-static int dump_cleanup(DumpState *s)
-{
- guest_phys_blocks_free(&s->guest_phys_blocks);
- memory_mapping_list_free(&s->list);
- close(s->fd);
- g_free(s->guest_note);
- s->guest_note = NULL;
- if (s->resume) {
- if (s->detached) {
- qemu_mutex_lock_iothread();
- }
- vm_start();
- if (s->detached) {
- qemu_mutex_unlock_iothread();
- }
- }
-
- return 0;
-}
-
-static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
-{
- DumpState *s = opaque;
- size_t written_size;
-
- written_size = qemu_write_full(s->fd, buf, size);
- if (written_size != size) {
- return -errno;
- }
-
- return 0;
-}
-
-static void write_elf64_header(DumpState *s, Error **errp)
-{
- 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;
- 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);
- if (s->have_section) {
- uint64_t shoff = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) * s->sh_info;
-
- 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);
- }
-
- ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret, "dump: failed to write elf header");
- }
-}
-
-static void write_elf32_header(DumpState *s, Error **errp)
-{
- 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;
- elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
- elf_header.e_ident[EI_VERSION] = EV_CURRENT;
- 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);
- if (s->have_section) {
- uint32_t shoff = sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * s->sh_info;
-
- 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);
- }
-
- ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret, "dump: failed to write elf header");
- }
-}
-
-static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
- int phdr_index, hwaddr offset,
- hwaddr filesz, Error **errp)
-{
- Elf64_Phdr phdr;
- int ret;
-
- memset(&phdr, 0, sizeof(Elf64_Phdr));
- 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) ?: phdr.p_paddr;
-
- assert(memory_mapping->length >= filesz);
-
- ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret,
- "dump: failed to write program header table");
- }
-}
-
-static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
- int phdr_index, hwaddr offset,
- hwaddr filesz, Error **errp)
-{
- Elf32_Phdr phdr;
- int ret;
-
- memset(&phdr, 0, sizeof(Elf32_Phdr));
- 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) ?: phdr.p_paddr;
-
- assert(memory_mapping->length >= filesz);
-
- ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret,
- "dump: failed to write program header table");
- }
-}
-
-static void write_elf64_note(DumpState *s, Error **errp)
-{
- Elf64_Phdr phdr;
- hwaddr begin = s->memory_offset - s->note_size;
- int ret;
-
- memset(&phdr, 0, sizeof(Elf64_Phdr));
- phdr.p_type = cpu_to_dump32(s, PT_NOTE);
- phdr.p_offset = cpu_to_dump64(s, begin);
- phdr.p_paddr = 0;
- phdr.p_filesz = cpu_to_dump64(s, s->note_size);
- phdr.p_memsz = cpu_to_dump64(s, s->note_size);
- phdr.p_vaddr = 0;
-
- ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret,
- "dump: failed to write program header table");
- }
-}
-
-static inline int cpu_index(CPUState *cpu)
-{
- return cpu->cpu_index + 1;
-}
-
-static void write_guest_note(WriteCoreDumpFunction f, DumpState *s,
- Error **errp)
-{
- int ret;
-
- if (s->guest_note) {
- ret = f(s->guest_note, s->guest_note_size, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write guest note");
- }
- }
-}
-
-static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
- Error **errp)
-{
- CPUState *cpu;
- int ret;
- int id;
-
- CPU_FOREACH(cpu) {
- id = cpu_index(cpu);
- ret = cpu_write_elf64_note(f, cpu, id, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write elf notes");
- return;
- }
- }
-
- CPU_FOREACH(cpu) {
- ret = cpu_write_elf64_qemunote(f, cpu, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write CPU status");
- return;
- }
- }
-
- write_guest_note(f, s, errp);
-}
-
-static void write_elf32_note(DumpState *s, Error **errp)
-{
- hwaddr begin = s->memory_offset - s->note_size;
- Elf32_Phdr phdr;
- int ret;
-
- memset(&phdr, 0, sizeof(Elf32_Phdr));
- phdr.p_type = cpu_to_dump32(s, PT_NOTE);
- phdr.p_offset = cpu_to_dump32(s, begin);
- phdr.p_paddr = 0;
- phdr.p_filesz = cpu_to_dump32(s, s->note_size);
- phdr.p_memsz = cpu_to_dump32(s, s->note_size);
- phdr.p_vaddr = 0;
-
- ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
- if (ret < 0) {
- error_setg_errno(errp, -ret,
- "dump: failed to write program header table");
- }
-}
-
-static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
- Error **errp)
-{
- CPUState *cpu;
- int ret;
- int id;
-
- CPU_FOREACH(cpu) {
- id = cpu_index(cpu);
- ret = cpu_write_elf32_note(f, cpu, id, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write elf notes");
- return;
- }
- }
-
- CPU_FOREACH(cpu) {
- ret = cpu_write_elf32_qemunote(f, cpu, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write CPU status");
- return;
- }
- }
-
- write_guest_note(f, s, errp);
-}
-
-static void write_elf_section(DumpState *s, int type, Error **errp)
-{
- 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);
- shdr32.sh_info = cpu_to_dump32(s, s->sh_info);
- shdr = &shdr32;
- } else {
- shdr_size = sizeof(Elf64_Shdr);
- memset(&shdr64, 0, shdr_size);
- shdr64.sh_info = cpu_to_dump32(s, s->sh_info);
- shdr = &shdr64;
- }
-
- ret = fd_write_vmcore(&shdr, shdr_size, s);
- if (ret < 0) {
- error_setg_errno(errp, -ret,
- "dump: failed to write section header table");
- }
-}
-
-static void write_data(DumpState *s, void *buf, int length, Error **errp)
-{
- int ret;
-
- ret = fd_write_vmcore(buf, length, s);
- if (ret < 0) {
- error_setg_errno(errp, -ret, "dump: failed to save memory");
- } else {
- s->written_size += length;
- }
-}
-
-/* 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)
-{
- int64_t i;
- Error *local_err = NULL;
-
- 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);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-
- 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);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-}
-
-/* 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)
-{
- GuestPhysBlock *block;
- hwaddr offset = s->memory_offset;
- int64_t size_in_block, start;
-
- /* When the memory is not stored into vmcore, offset will be -1 */
- *p_offset = -1;
- *p_filesz = 0;
-
- if (s->has_filter) {
- if (phys_addr < s->begin || phys_addr >= s->begin + s->length) {
- return;
- }
- }
-
- QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
- if (s->has_filter) {
- if (block->target_start >= s->begin + s->length ||
- block->target_end <= s->begin) {
- /* This block is out of the range */
- continue;
- }
-
- if (s->begin <= block->target_start) {
- start = block->target_start;
- } else {
- start = s->begin;
- }
-
- 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);
- }
- } else {
- start = block->target_start;
- size_in_block = block->target_end - block->target_start;
- }
-
- if (phys_addr >= start && phys_addr < start + size_in_block) {
- *p_offset = phys_addr - start + offset;
-
- /* The offset range mapped from the vmcore file must not spill over
- * the GuestPhysBlock, clamp it. The rest of the mapping will be
- * 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;
- }
-
- offset += size_in_block;
- }
-}
-
-static void write_elf_loads(DumpState *s, Error **errp)
-{
- hwaddr offset, filesz;
- MemoryMapping *memory_mapping;
- uint32_t phdr_index = 1;
- uint32_t max_index;
- Error *local_err = NULL;
-
- if (s->have_section) {
- max_index = s->sh_info;
- } else {
- max_index = s->phdr_num;
- }
-
- QTAILQ_FOREACH(memory_mapping, &s->list.head, next) {
- get_offset_range(memory_mapping->phys_addr,
- memory_mapping->length,
- s, &offset, &filesz);
- if (s->dump_info.d_class == ELFCLASS64) {
- write_elf64_load(s, memory_mapping, phdr_index++, offset,
- filesz, &local_err);
- } else {
- write_elf32_load(s, memory_mapping, phdr_index++, offset,
- filesz, &local_err);
- }
-
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- if (phdr_index >= max_index) {
- break;
- }
- }
-}
-
-/* write elf header, PT_NOTE and elf note to vmcore. */
-static void dump_begin(DumpState *s, Error **errp)
-{
- Error *local_err = NULL;
-
- /*
- * 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) {
- write_elf64_header(s, &local_err);
- } else {
- write_elf32_header(s, &local_err);
- }
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- if (s->dump_info.d_class == ELFCLASS64) {
- /* write PT_NOTE to vmcore */
- write_elf64_note(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- /* write all PT_LOAD to vmcore */
- write_elf_loads(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- /* write section to vmcore */
- if (s->have_section) {
- write_elf_section(s, 1, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-
- /* write notes to vmcore */
- write_elf64_notes(fd_write_vmcore, s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- } else {
- /* write PT_NOTE to vmcore */
- write_elf32_note(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- /* write all PT_LOAD to vmcore */
- write_elf_loads(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- /* write section to vmcore */
- if (s->have_section) {
- write_elf_section(s, 0, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-
- /* write notes to vmcore */
- write_elf32_notes(fd_write_vmcore, s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-}
-
-static int get_next_block(DumpState *s, GuestPhysBlock *block)
-{
- while (1) {
- block = QTAILQ_NEXT(block, next);
- if (!block) {
- /* no more block */
- return 1;
- }
-
- s->start = 0;
- s->next_block = block;
- if (s->has_filter) {
- if (block->target_start >= s->begin + s->length ||
- block->target_end <= s->begin) {
- /* This block is out of the range */
- continue;
- }
-
- if (s->begin > block->target_start) {
- s->start = s->begin - block->target_start;
- }
- }
-
- return 0;
- }
-}
-
-/* write all memory to vmcore */
-static void dump_iterate(DumpState *s, Error **errp)
-{
- GuestPhysBlock *block;
- int64_t size;
- Error *local_err = NULL;
-
- do {
- block = s->next_block;
-
- size = block->target_end - block->target_start;
- if (s->has_filter) {
- size -= s->start;
- if (s->begin + s->length < block->target_end) {
- size -= block->target_end - (s->begin + s->length);
- }
- }
- write_memory(s, block, s->start, size, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- } while (!get_next_block(s, block));
-}
-
-static void create_vmcore(DumpState *s, Error **errp)
-{
- Error *local_err = NULL;
-
- dump_begin(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- dump_iterate(s, errp);
-}
-
-static int write_start_flat_header(int fd)
-{
- MakedumpfileHeader *mh;
- int ret = 0;
-
- QEMU_BUILD_BUG_ON(sizeof *mh > MAX_SIZE_MDF_HEADER);
- mh = g_malloc0(MAX_SIZE_MDF_HEADER);
-
- memcpy(mh->signature, MAKEDUMPFILE_SIGNATURE,
- MIN(sizeof mh->signature, sizeof MAKEDUMPFILE_SIGNATURE));
-
- mh->type = cpu_to_be64(TYPE_FLAT_HEADER);
- mh->version = cpu_to_be64(VERSION_FLAT_HEADER);
-
- size_t written_size;
- written_size = qemu_write_full(fd, mh, MAX_SIZE_MDF_HEADER);
- if (written_size != MAX_SIZE_MDF_HEADER) {
- ret = -1;
- }
-
- g_free(mh);
- 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;
-}
-
-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;
-}
-
-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;
-}
-
-/*
- * This function retrieves various sizes from an elf header.
- *
- * @note has to be a valid ELF note. The return sizes are unmodified
- * (not padded or rounded up to be multiple of 4).
- */
-static void get_note_sizes(DumpState *s, const void *note,
- uint64_t *note_head_size,
- uint64_t *name_size,
- uint64_t *desc_size)
-{
- uint64_t note_head_sz;
- uint64_t name_sz;
- uint64_t desc_sz;
-
- if (s->dump_info.d_class == ELFCLASS64) {
- const Elf64_Nhdr *hdr = note;
- note_head_sz = sizeof(Elf64_Nhdr);
- name_sz = tswap64(hdr->n_namesz);
- desc_sz = tswap64(hdr->n_descsz);
- } else {
- const Elf32_Nhdr *hdr = note;
- note_head_sz = sizeof(Elf32_Nhdr);
- name_sz = tswap32(hdr->n_namesz);
- desc_sz = tswap32(hdr->n_descsz);
- }
-
- if (note_head_size) {
- *note_head_size = note_head_sz;
- }
- if (name_size) {
- *name_size = name_sz;
- }
- if (desc_size) {
- *desc_size = desc_sz;
- }
-}
-
-static bool note_name_equal(DumpState *s,
- const uint8_t *note, const char *name)
-{
- int len = strlen(name) + 1;
- uint64_t head_size, name_size;
-
- get_note_sizes(s, note, &head_size, &name_size, NULL);
- head_size = ROUND_UP(head_size, 4);
-
- return name_size == len && memcmp(note + head_size, name, len) == 0;
-}
-
-/* write common header, sub header and elf note to vmcore */
-static void create_header32(DumpState *s, Error **errp)
-{
- 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;
- Error *local_err = NULL;
-
- /* write common header, the version of kdump-compressed format is 6th */
- size = sizeof(DiskDumpHeader32);
- dh = g_malloc0(size);
-
- memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
- dh->header_version = cpu_to_dump32(s, 6);
- block_size = s->dump_info.page_size;
- dh->block_size = cpu_to_dump32(s, block_size);
- sub_hdr_size = sizeof(struct KdumpSubHeader32) + s->note_size;
- sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
- dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
- /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
- dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
- dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
- bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
- dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
- strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
-
- 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
- dh->status = cpu_to_dump32(s, status);
-
- if (write_buffer(s->fd, 0, dh, size) < 0) {
- error_setg(errp, "dump: failed to write disk dump header");
- goto out;
- }
-
- /* write sub header */
- size = sizeof(KdumpSubHeader32);
- kh = g_malloc0(size);
-
- /* 64bit max_mapnr_64 */
- kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
- kh->phys_base = cpu_to_dump32(s, s->dump_info.phys_base);
- kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
-
- offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
- if (s->guest_note &&
- note_name_equal(s, s->guest_note, "VMCOREINFO")) {
- uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
-
- get_note_sizes(s, s->guest_note,
- &hsize, &name_size, &size_vmcoreinfo_desc);
- offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
- (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
- kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
- kh->size_vmcoreinfo = cpu_to_dump32(s, size_vmcoreinfo_desc);
- }
-
- kh->offset_note = cpu_to_dump64(s, offset_note);
- kh->note_size = cpu_to_dump32(s, s->note_size);
-
- if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
- block_size, kh, size) < 0) {
- error_setg(errp, "dump: failed to write kdump sub header");
- 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 */
- write_elf32_notes(buf_write_note, s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- goto out;
- }
- if (write_buffer(s->fd, offset_note, s->note_buf,
- s->note_size) < 0) {
- error_setg(errp, "dump: failed to write notes");
- 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 */
-static void create_header64(DumpState *s, Error **errp)
-{
- 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;
- Error *local_err = NULL;
-
- /* write common header, the version of kdump-compressed format is 6th */
- size = sizeof(DiskDumpHeader64);
- dh = g_malloc0(size);
-
- memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
- dh->header_version = cpu_to_dump32(s, 6);
- block_size = s->dump_info.page_size;
- dh->block_size = cpu_to_dump32(s, block_size);
- sub_hdr_size = sizeof(struct KdumpSubHeader64) + s->note_size;
- sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
- dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
- /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
- dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
- dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
- bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
- dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
- strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
-
- 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
- dh->status = cpu_to_dump32(s, status);
-
- if (write_buffer(s->fd, 0, dh, size) < 0) {
- error_setg(errp, "dump: failed to write disk dump header");
- goto out;
- }
-
- /* write sub header */
- size = sizeof(KdumpSubHeader64);
- kh = g_malloc0(size);
-
- /* 64bit max_mapnr_64 */
- kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
- kh->phys_base = cpu_to_dump64(s, s->dump_info.phys_base);
- kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
-
- offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
- if (s->guest_note &&
- note_name_equal(s, s->guest_note, "VMCOREINFO")) {
- uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
-
- get_note_sizes(s, s->guest_note,
- &hsize, &name_size, &size_vmcoreinfo_desc);
- offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
- (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
- kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
- kh->size_vmcoreinfo = cpu_to_dump64(s, size_vmcoreinfo_desc);
- }
-
- kh->offset_note = cpu_to_dump64(s, offset_note);
- kh->note_size = cpu_to_dump64(s, s->note_size);
-
- if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
- block_size, kh, size) < 0) {
- error_setg(errp, "dump: failed to write kdump sub header");
- 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 */
- write_elf64_notes(buf_write_note, s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- goto out;
- }
-
- if (write_buffer(s->fd, offset_note, s->note_buf,
- s->note_size) < 0) {
- error_setg(errp, "dump: failed to write notes");
- 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);
-}
-
-static void write_dump_header(DumpState *s, Error **errp)
-{
- Error *local_err = NULL;
-
- if (s->dump_info.d_class == ELFCLASS32) {
- create_header32(s, &local_err);
- } else {
- create_header64(s, &local_err);
- }
- error_propagate(errp, local_err);
-}
-
-static size_t dump_bitmap_get_bufsize(DumpState *s)
-{
- return s->dump_info.page_size;
-}
-
-/*
- * 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;
- size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
- size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
-
- /* 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.
- */
- old_offset = bitmap_bufsize * (last_pfn / bits_per_buf);
- new_offset = bitmap_bufsize * (pfn / bits_per_buf);
-
- 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,
- bitmap_bufsize) < 0) {
- 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,
- bitmap_bufsize) < 0) {
- return -1;
- }
-
- memset(buf, 0, bitmap_bufsize);
- old_offset += bitmap_bufsize;
- }
-
- /* get the exact place of the bit in the buf, and set it */
- byte = (pfn % bits_per_buf) / CHAR_BIT;
- bit = (pfn % bits_per_buf) % CHAR_BIT;
- if (value) {
- buf[byte] |= 1u << bit;
- } else {
- buf[byte] &= ~(1u << bit);
- }
-
- return 0;
-}
-
-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;
-}
-
-/*
- * 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;
- hwaddr addr, target_page_mask = ~((hwaddr)s->dump_info.page_size - 1);
- uint8_t *buf;
-
- /* block == NULL means the start of the iteration */
- if (!block) {
- block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
- *blockptr = block;
- 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);
- if (bufptr) {
- *bufptr = block->host_addr;
- }
- return true;
- }
-
- *pfnptr = *pfnptr + 1;
- addr = dump_pfn_to_paddr(s, *pfnptr);
-
- if ((addr >= block->target_start) &&
- (addr + s->dump_info.page_size <= block->target_end)) {
- 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;
- }
- 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);
- buf = block->host_addr;
- }
-
- if (bufptr) {
- *bufptr = buf;
- }
-
- return true;
-}
-
-static void write_dump_bitmap(DumpState *s, Error **errp)
-{
- int ret = 0;
- uint64_t last_pfn, pfn;
- void *dump_bitmap_buf;
- size_t num_dumpable;
- GuestPhysBlock *block_iter = NULL;
- size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
- size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
-
- /* dump_bitmap_buf is used to store dump_bitmap temporarily */
- dump_bitmap_buf = g_malloc0(bitmap_bufsize);
-
- 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) {
- error_setg(errp, "dump: failed to set dump_bitmap");
- goto out;
- }
-
- last_pfn = pfn;
- num_dumpable++;
- }
-
- /*
- * set_dump_bitmap will always leave the recently set bit un-sync. Here we
- * 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.
- */
- if (num_dumpable > 0) {
- ret = set_dump_bitmap(last_pfn, last_pfn + bits_per_buf, false,
- dump_bitmap_buf, s);
- if (ret < 0) {
- error_setg(errp, "dump: failed to sync dump_bitmap");
- goto out;
- }
- }
-
- /* number of dumpable pages that will be dumped later */
- s->num_dumpable = num_dumpable;
-
-out:
- g_free(dump_bitmap_buf);
-}
-
-static void prepare_data_cache(DataCache *data_cache, DumpState *s,
- off_t offset)
-{
- data_cache->fd = s->fd;
- data_cache->data_size = 0;
- data_cache->buf_size = 4 * dump_bitmap_get_bufsize(s);
- data_cache->buf = g_malloc0(data_cache->buf_size);
- 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);
-}
-
-static size_t get_len_buf_out(size_t page_size, uint32_t flag_compress)
-{
- 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;
-
-#ifdef CONFIG_SNAPPY
- case DUMP_DH_COMPRESSED_SNAPPY:
- return snappy_max_compressed_length(page_size);
-#endif
- }
- return 0;
-}
-
-/*
- * 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);
-}
-
-static void write_dump_pages(DumpState *s, Error **errp)
-{
- 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 */
- len_buf_out = get_len_buf_out(s->dump_info.page_size, s->flag_compress);
- assert(len_buf_out != 0);
-
-#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
- */
- pd_zero.size = cpu_to_dump32(s, s->dump_info.page_size);
- 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);
- buf = g_malloc0(s->dump_info.page_size);
- ret = write_cache(&page_data, buf, s->dump_info.page_size, false);
- g_free(buf);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page data (zero page)");
- goto out;
- }
-
- offset_data += s->dump_info.page_size;
-
- /*
- * 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 */
- if (is_zero_page(buf, s->dump_info.page_size)) {
- ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor),
- false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page desc");
- 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) &&
- (compress2(buf_out, (uLongf *)&size_out, buf,
- s->dump_info.page_size, Z_BEST_SPEED) == Z_OK) &&
- (size_out < s->dump_info.page_size)) {
- pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_ZLIB);
- pd.size = cpu_to_dump32(s, size_out);
-
- ret = write_cache(&page_data, buf_out, size_out, false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page data");
- goto out;
- }
-#ifdef CONFIG_LZO
- } else if ((s->flag_compress & DUMP_DH_COMPRESSED_LZO) &&
- (lzo1x_1_compress(buf, s->dump_info.page_size, buf_out,
- (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) &&
- (size_out < s->dump_info.page_size)) {
- pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_LZO);
- pd.size = cpu_to_dump32(s, size_out);
-
- ret = write_cache(&page_data, buf_out, size_out, false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page data");
- goto out;
- }
-#endif
-#ifdef CONFIG_SNAPPY
- } else if ((s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) &&
- (snappy_compress((char *)buf, s->dump_info.page_size,
- (char *)buf_out, &size_out) == SNAPPY_OK) &&
- (size_out < s->dump_info.page_size)) {
- pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_SNAPPY);
- pd.size = cpu_to_dump32(s, size_out);
-
- ret = write_cache(&page_data, buf_out, size_out, false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page data");
- goto out;
- }
-#endif
- } else {
- /*
- * fall back to save in plaintext, size_out should be
- * assigned the target's page size
- */
- pd.flags = cpu_to_dump32(s, 0);
- size_out = s->dump_info.page_size;
- pd.size = cpu_to_dump32(s, size_out);
-
- ret = write_cache(&page_data, buf,
- s->dump_info.page_size, false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page data");
- goto out;
- }
- }
-
- /* get and write page desc here */
- pd.page_flags = cpu_to_dump64(s, 0);
- pd.offset = cpu_to_dump64(s, offset_data);
- offset_data += size_out;
-
- ret = write_cache(&page_desc, &pd, sizeof(PageDescriptor), false);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write page desc");
- goto out;
- }
- }
- s->written_size += s->dump_info.page_size;
- }
-
- ret = write_cache(&page_desc, NULL, 0, true);
- if (ret < 0) {
- error_setg(errp, "dump: failed to sync cache for page_desc");
- goto out;
- }
- ret = write_cache(&page_data, NULL, 0, true);
- if (ret < 0) {
- error_setg(errp, "dump: failed to sync cache for page_data");
- goto out;
- }
-
-out:
- free_data_cache(&page_desc);
- free_data_cache(&page_data);
-
-#ifdef CONFIG_LZO
- g_free(wrkmem);
-#endif
-
- g_free(buf_out);
-}
-
-static void create_kdump_vmcore(DumpState *s, Error **errp)
-{
- int ret;
- Error *local_err = NULL;
-
- /*
- * 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) {
- error_setg(errp, "dump: failed to write start flat header");
- return;
- }
-
- write_dump_header(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- write_dump_bitmap(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- write_dump_pages(s, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- ret = write_end_flat_header(s->fd);
- if (ret < 0) {
- error_setg(errp, "dump: failed to write end flat header");
- return;
- }
-}
-
-static ram_addr_t get_start_block(DumpState *s)
-{
- GuestPhysBlock *block;
-
- if (!s->has_filter) {
- s->next_block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
- return 0;
- }
-
- QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
- if (block->target_start >= s->begin + s->length ||
- block->target_end <= s->begin) {
- /* This block is out of the range */
- continue;
- }
-
- s->next_block = block;
- if (s->begin > block->target_start) {
- s->start = s->begin - block->target_start;
- } else {
- s->start = 0;
- }
- return s->start;
- }
-
- return -1;
-}
-
-static void get_max_mapnr(DumpState *s)
-{
- GuestPhysBlock *last_block;
-
- last_block = QTAILQ_LAST(&s->guest_phys_blocks.head);
- s->max_mapnr = dump_paddr_to_pfn(s, last_block->target_end);
-}
-
-static DumpState dump_state_global = { .status = DUMP_STATUS_NONE };
-
-static void dump_state_prepare(DumpState *s)
-{
- /* zero the struct, setting status to active */
- *s = (DumpState) { .status = DUMP_STATUS_ACTIVE };
-}
-
-bool dump_in_progress(void)
-{
- DumpState *state = &dump_state_global;
- return (atomic_read(&state->status) == DUMP_STATUS_ACTIVE);
-}
-
-/* calculate total size of memory to be dumped (taking filter into
- * acoount.) */
-static int64_t dump_calculate_size(DumpState *s)
-{
- GuestPhysBlock *block;
- int64_t size = 0, total = 0, left = 0, right = 0;
-
- QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
- if (s->has_filter) {
- /* calculate the overlapped region. */
- left = MAX(s->begin, block->target_start);
- right = MIN(s->begin + s->length, block->target_end);
- size = right - left;
- size = size > 0 ? size : 0;
- } else {
- /* count the whole region in */
- size = (block->target_end - block->target_start);
- }
- total += size;
- }
-
- return total;
-}
-
-static void vmcoreinfo_update_phys_base(DumpState *s)
-{
- uint64_t size, note_head_size, name_size, phys_base;
- char **lines;
- uint8_t *vmci;
- size_t i;
-
- if (!note_name_equal(s, s->guest_note, "VMCOREINFO")) {
- return;
- }
-
- get_note_sizes(s, s->guest_note, ¬e_head_size, &name_size, &size);
- note_head_size = ROUND_UP(note_head_size, 4);
-
- vmci = s->guest_note + note_head_size + ROUND_UP(name_size, 4);
- *(vmci + size) = '\0';
-
- lines = g_strsplit((char *)vmci, "\n", -1);
- for (i = 0; lines[i]; i++) {
- const char *prefix = NULL;
-
- if (s->dump_info.d_machine == EM_X86_64) {
- prefix = "NUMBER(phys_base)=";
- } else if (s->dump_info.d_machine == EM_AARCH64) {
- prefix = "NUMBER(PHYS_OFFSET)=";
- }
-
- if (prefix && g_str_has_prefix(lines[i], prefix)) {
- if (qemu_strtou64(lines[i] + strlen(prefix), NULL, 16,
- &phys_base) < 0) {
- warn_report("Failed to read %s", prefix);
- } else {
- s->dump_info.phys_base = phys_base;
- }
- break;
- }
- }
-
- g_strfreev(lines);
-}
-
-static void dump_init(DumpState *s, int fd, bool has_format,
- DumpGuestMemoryFormat format, bool paging, bool has_filter,
- int64_t begin, int64_t length, Error **errp)
-{
- VMCoreInfoState *vmci = vmcoreinfo_find();
- CPUState *cpu;
- int nr_cpus;
- Error *err = NULL;
- int ret;
-
- s->has_format = has_format;
- s->format = format;
- s->written_size = 0;
-
- /* kdump-compressed is conflict with paging and filter */
- if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
- assert(!paging && !has_filter);
- }
-
- if (runstate_is_running()) {
- vm_stop(RUN_STATE_SAVE_VM);
- s->resume = true;
- } else {
- s->resume = false;
- }
-
- /* If we use KVM, we should synchronize the registers before we get dump
- * info or physmap info.
- */
- cpu_synchronize_all_states();
- nr_cpus = 0;
- CPU_FOREACH(cpu) {
- nr_cpus++;
- }
-
- s->fd = fd;
- s->has_filter = has_filter;
- s->begin = begin;
- s->length = length;
-
- memory_mapping_list_init(&s->list);
-
- guest_phys_blocks_init(&s->guest_phys_blocks);
- guest_phys_blocks_append(&s->guest_phys_blocks);
- s->total_size = dump_calculate_size(s);
-#ifdef DEBUG_DUMP_GUEST_MEMORY
- fprintf(stderr, "DUMP: total memory to dump: %lu\n", s->total_size);
-#endif
-
- /* it does not make sense to dump non-existent memory */
- if (!s->total_size) {
- error_setg(errp, "dump: no guest memory to dump");
- goto cleanup;
- }
-
- s->start = get_start_block(s);
- if (s->start == -1) {
- error_setg(errp, QERR_INVALID_PARAMETER, "begin");
- goto cleanup;
- }
-
- /* get dump info: endian, class and architecture.
- * If the target architecture is not supported, cpu_get_dump_info() will
- * return -1.
- */
- ret = cpu_get_dump_info(&s->dump_info, &s->guest_phys_blocks);
- if (ret < 0) {
- error_setg(errp, QERR_UNSUPPORTED);
- goto cleanup;
- }
-
- if (!s->dump_info.page_size) {
- s->dump_info.page_size = TARGET_PAGE_SIZE;
- }
-
- s->note_size = cpu_get_note_size(s->dump_info.d_class,
- s->dump_info.d_machine, nr_cpus);
- if (s->note_size < 0) {
- error_setg(errp, QERR_UNSUPPORTED);
- goto cleanup;
- }
-
- /*
- * The goal of this block is to (a) update the previously guessed
- * phys_base, (b) copy the guest note out of the guest.
- * Failure to do so is not fatal for dumping.
- */
- if (vmci) {
- uint64_t addr, note_head_size, name_size, desc_size;
- uint32_t size;
- uint16_t format;
-
- note_head_size = s->dump_info.d_class == ELFCLASS32 ?
- sizeof(Elf32_Nhdr) : sizeof(Elf64_Nhdr);
-
- format = le16_to_cpu(vmci->vmcoreinfo.guest_format);
- size = le32_to_cpu(vmci->vmcoreinfo.size);
- addr = le64_to_cpu(vmci->vmcoreinfo.paddr);
- if (!vmci->has_vmcoreinfo) {
- warn_report("guest note is not present");
- } else if (size < note_head_size || size > MAX_GUEST_NOTE_SIZE) {
- warn_report("guest note size is invalid: %" PRIu32, size);
- } else if (format != FW_CFG_VMCOREINFO_FORMAT_ELF) {
- warn_report("guest note format is unsupported: %" PRIu16, format);
- } else {
- s->guest_note = g_malloc(size + 1); /* +1 for adding \0 */
- cpu_physical_memory_read(addr, s->guest_note, size);
-
- get_note_sizes(s, s->guest_note, NULL, &name_size, &desc_size);
- s->guest_note_size = ELF_NOTE_SIZE(note_head_size, name_size,
- desc_size);
- if (name_size > MAX_GUEST_NOTE_SIZE ||
- desc_size > MAX_GUEST_NOTE_SIZE ||
- s->guest_note_size > size) {
- warn_report("Invalid guest note header");
- g_free(s->guest_note);
- s->guest_note = NULL;
- } else {
- vmcoreinfo_update_phys_base(s);
- s->note_size += s->guest_note_size;
- }
- }
- }
-
- /* get memory mapping */
- if (paging) {
- qemu_get_guest_memory_mapping(&s->list, &s->guest_phys_blocks, &err);
- if (err != NULL) {
- error_propagate(errp, err);
- goto cleanup;
- }
- } else {
- qemu_get_guest_simple_memory_mapping(&s->list, &s->guest_phys_blocks);
- }
-
- s->nr_cpus = nr_cpus;
-
- get_max_mapnr(s);
-
- uint64_t tmp;
- tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT),
- s->dump_info.page_size);
- s->len_dump_bitmap = tmp * s->dump_info.page_size;
-
- /* init for kdump-compressed format */
- if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
- switch (format) {
- case DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB:
- s->flag_compress = DUMP_DH_COMPRESSED_ZLIB;
- break;
-
- case DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO:
-#ifdef CONFIG_LZO
- if (lzo_init() != LZO_E_OK) {
- error_setg(errp, "failed to initialize the LZO library");
- goto cleanup;
- }
-#endif
- s->flag_compress = DUMP_DH_COMPRESSED_LZO;
- break;
-
- case DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY:
- s->flag_compress = DUMP_DH_COMPRESSED_SNAPPY;
- break;
-
- default:
- s->flag_compress = 0;
- }
-
- return;
- }
-
- if (s->has_filter) {
- memory_mapping_filter(&s->list, s->begin, s->length);
- }
-
- /*
- * calculate phdr_num
- *
- * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
- */
- s->phdr_num = 1; /* PT_NOTE */
- if (s->list.num < UINT16_MAX - 2) {
- s->phdr_num += s->list.num;
- s->have_section = false;
- } else {
- s->have_section = true;
- s->phdr_num = PN_XNUM;
- s->sh_info = 1; /* PT_NOTE */
-
- /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
- if (s->list.num <= UINT32_MAX - 1) {
- s->sh_info += s->list.num;
- } else {
- s->sh_info = UINT32_MAX;
- }
- }
-
- if (s->dump_info.d_class == ELFCLASS64) {
- if (s->have_section) {
- s->memory_offset = sizeof(Elf64_Ehdr) +
- sizeof(Elf64_Phdr) * s->sh_info +
- sizeof(Elf64_Shdr) + s->note_size;
- } else {
- s->memory_offset = sizeof(Elf64_Ehdr) +
- sizeof(Elf64_Phdr) * s->phdr_num + s->note_size;
- }
- } else {
- if (s->have_section) {
- s->memory_offset = sizeof(Elf32_Ehdr) +
- sizeof(Elf32_Phdr) * s->sh_info +
- sizeof(Elf32_Shdr) + s->note_size;
- } else {
- s->memory_offset = sizeof(Elf32_Ehdr) +
- sizeof(Elf32_Phdr) * s->phdr_num + s->note_size;
- }
- }
-
- return;
-
-cleanup:
- dump_cleanup(s);
-}
-
-/* this operation might be time consuming. */
-static void dump_process(DumpState *s, Error **errp)
-{
- Error *local_err = NULL;
- DumpQueryResult *result = NULL;
-
- if (s->has_format && s->format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
-#ifdef TARGET_X86_64
- create_win_dump(s, &local_err);
-#endif
- } else if (s->has_format && s->format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
- create_kdump_vmcore(s, &local_err);
- } else {
- create_vmcore(s, &local_err);
- }
-
- /* make sure status is written after written_size updates */
- smp_wmb();
- atomic_set(&s->status,
- (local_err ? DUMP_STATUS_FAILED : DUMP_STATUS_COMPLETED));
-
- /* send DUMP_COMPLETED message (unconditionally) */
- result = qmp_query_dump(NULL);
- /* should never fail */
- assert(result);
- qapi_event_send_dump_completed(result, !!local_err, (local_err ? \
- error_get_pretty(local_err) : NULL));
- qapi_free_DumpQueryResult(result);
-
- error_propagate(errp, local_err);
- dump_cleanup(s);
-}
-
-static void *dump_thread(void *data)
-{
- DumpState *s = (DumpState *)data;
- dump_process(s, NULL);
- return NULL;
-}
-
-DumpQueryResult *qmp_query_dump(Error **errp)
-{
- DumpQueryResult *result = g_new(DumpQueryResult, 1);
- DumpState *state = &dump_state_global;
- result->status = atomic_read(&state->status);
- /* make sure we are reading status and written_size in order */
- smp_rmb();
- result->completed = state->written_size;
- result->total = state->total_size;
- return result;
-}
-
-void qmp_dump_guest_memory(bool paging, const char *file,
- bool has_detach, bool detach,
- bool has_begin, int64_t begin, bool has_length,
- int64_t length, bool has_format,
- DumpGuestMemoryFormat format, Error **errp)
-{
- const char *p;
- int fd = -1;
- DumpState *s;
- Error *local_err = NULL;
- bool detach_p = false;
-
- if (runstate_check(RUN_STATE_INMIGRATE)) {
- error_setg(errp, "Dump not allowed during incoming migration.");
- return;
- }
-
- /* if there is a dump in background, we should wait until the dump
- * finished */
- if (dump_in_progress()) {
- error_setg(errp, "There is a dump in process, please wait.");
- return;
- }
-
- /*
- * kdump-compressed format need the whole memory dumped, so paging or
- * filter is not supported here.
- */
- if ((has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) &&
- (paging || has_begin || has_length)) {
- error_setg(errp, "kdump-compressed format doesn't support paging or "
- "filter");
- return;
- }
- if (has_begin && !has_length) {
- error_setg(errp, QERR_MISSING_PARAMETER, "length");
- return;
- }
- if (!has_begin && has_length) {
- error_setg(errp, QERR_MISSING_PARAMETER, "begin");
- return;
- }
- if (has_detach) {
- detach_p = detach;
- }
-
- /* check whether lzo/snappy is supported */
-#ifndef CONFIG_LZO
- if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO) {
- error_setg(errp, "kdump-lzo is not available now");
- return;
- }
-#endif
-
-#ifndef CONFIG_SNAPPY
- if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY) {
- error_setg(errp, "kdump-snappy is not available now");
- return;
- }
-#endif
-
-#ifndef TARGET_X86_64
- if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
- error_setg(errp, "Windows dump is only available for x86-64");
- return;
- }
-#endif
-
-#if !defined(WIN32)
- if (strstart(file, "fd:", &p)) {
- fd = monitor_get_fd(cur_mon, p, errp);
- if (fd == -1) {
- return;
- }
- }
-#endif
-
- if (strstart(file, "file:", &p)) {
- fd = qemu_open(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR);
- if (fd < 0) {
- error_setg_file_open(errp, errno, p);
- return;
- }
- }
-
- if (fd == -1) {
- error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
- return;
- }
-
- s = &dump_state_global;
- dump_state_prepare(s);
-
- dump_init(s, fd, has_format, format, paging, has_begin,
- begin, length, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- atomic_set(&s->status, DUMP_STATUS_FAILED);
- return;
- }
-
- if (detach_p) {
- /* detached dump */
- s->detached = true;
- qemu_thread_create(&s->dump_thread, "dump_thread", dump_thread,
- s, QEMU_THREAD_DETACHED);
- } else {
- /* sync dump */
- dump_process(s, errp);
- }
-}
-
-DumpGuestMemoryCapability *qmp_query_dump_guest_memory_capability(Error **errp)
-{
- DumpGuestMemoryFormatList *item;
- DumpGuestMemoryCapability *cap =
- g_malloc0(sizeof(DumpGuestMemoryCapability));
-
- /* elf is always available */
- item = g_malloc0(sizeof(DumpGuestMemoryFormatList));
- cap->formats = item;
- item->value = DUMP_GUEST_MEMORY_FORMAT_ELF;
-
- /* kdump-zlib is always available */
- item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
- item = item->next;
- item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
-
- /* add new item if kdump-lzo is available */
-#ifdef CONFIG_LZO
- item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
- item = item->next;
- item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
-#endif
-
- /* add new item if kdump-snappy is available */
-#ifdef CONFIG_SNAPPY
- item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
- item = item->next;
- item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
-#endif
-
- /* Windows dump is available only if target is x86_64 */
-#ifdef TARGET_X86_64
- item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
- item = item->next;
- item->value = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP;
-#endif
-
- return cap;
-}
--- /dev/null
+obj-y += dump.o
+obj-$(TARGET_X86_64) += win_dump.o
--- /dev/null
+/*
+ * QEMU dump
+ *
+ * Copyright Fujitsu, Corp. 2011, 2012
+ *
+ * Authors:
+ * Wen Congyang <wency@cn.fujitsu.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "qemu/cutils.h"
+#include "elf.h"
+#include "cpu.h"
+#include "exec/hwaddr.h"
+#include "monitor/monitor.h"
+#include "sysemu/kvm.h"
+#include "sysemu/dump.h"
+#include "sysemu/sysemu.h"
+#include "sysemu/memory_mapping.h"
+#include "sysemu/cpus.h"
+#include "qapi/error.h"
+#include "qapi/qapi-commands-dump.h"
+#include "qapi/qapi-events-dump.h"
+#include "qapi/qmp/qerror.h"
+#include "qemu/error-report.h"
+#include "hw/misc/vmcoreinfo.h"
+
+#ifdef TARGET_X86_64
+#include "win_dump.h"
+#endif
+
+#include <zlib.h>
+#ifdef CONFIG_LZO
+#include <lzo/lzo1x.h>
+#endif
+#ifdef CONFIG_SNAPPY
+#include <snappy-c.h>
+#endif
+#ifndef ELF_MACHINE_UNAME
+#define ELF_MACHINE_UNAME "Unknown"
+#endif
+
+#define MAX_GUEST_NOTE_SIZE (1 << 20) /* 1MB should be enough */
+
+#define ELF_NOTE_SIZE(hdr_size, name_size, desc_size) \
+ ((DIV_ROUND_UP((hdr_size), 4) + \
+ DIV_ROUND_UP((name_size), 4) + \
+ DIV_ROUND_UP((desc_size), 4)) * 4)
+
+uint16_t cpu_to_dump16(DumpState *s, uint16_t val)
+{
+ if (s->dump_info.d_endian == ELFDATA2LSB) {
+ val = cpu_to_le16(val);
+ } else {
+ val = cpu_to_be16(val);
+ }
+
+ return val;
+}
+
+uint32_t cpu_to_dump32(DumpState *s, uint32_t val)
+{
+ if (s->dump_info.d_endian == ELFDATA2LSB) {
+ val = cpu_to_le32(val);
+ } else {
+ val = cpu_to_be32(val);
+ }
+
+ return val;
+}
+
+uint64_t cpu_to_dump64(DumpState *s, uint64_t val)
+{
+ if (s->dump_info.d_endian == ELFDATA2LSB) {
+ val = cpu_to_le64(val);
+ } else {
+ val = cpu_to_be64(val);
+ }
+
+ return val;
+}
+
+static int dump_cleanup(DumpState *s)
+{
+ guest_phys_blocks_free(&s->guest_phys_blocks);
+ memory_mapping_list_free(&s->list);
+ close(s->fd);
+ g_free(s->guest_note);
+ s->guest_note = NULL;
+ if (s->resume) {
+ if (s->detached) {
+ qemu_mutex_lock_iothread();
+ }
+ vm_start();
+ if (s->detached) {
+ qemu_mutex_unlock_iothread();
+ }
+ }
+
+ return 0;
+}
+
+static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
+{
+ DumpState *s = opaque;
+ size_t written_size;
+
+ written_size = qemu_write_full(s->fd, buf, size);
+ if (written_size != size) {
+ return -errno;
+ }
+
+ return 0;
+}
+
+static void write_elf64_header(DumpState *s, Error **errp)
+{
+ 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;
+ 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);
+ if (s->have_section) {
+ uint64_t shoff = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) * s->sh_info;
+
+ 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);
+ }
+
+ ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret, "dump: failed to write elf header");
+ }
+}
+
+static void write_elf32_header(DumpState *s, Error **errp)
+{
+ 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;
+ elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
+ elf_header.e_ident[EI_VERSION] = EV_CURRENT;
+ 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);
+ if (s->have_section) {
+ uint32_t shoff = sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * s->sh_info;
+
+ 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);
+ }
+
+ ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret, "dump: failed to write elf header");
+ }
+}
+
+static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
+ int phdr_index, hwaddr offset,
+ hwaddr filesz, Error **errp)
+{
+ Elf64_Phdr phdr;
+ int ret;
+
+ memset(&phdr, 0, sizeof(Elf64_Phdr));
+ 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) ?: phdr.p_paddr;
+
+ assert(memory_mapping->length >= filesz);
+
+ ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret,
+ "dump: failed to write program header table");
+ }
+}
+
+static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
+ int phdr_index, hwaddr offset,
+ hwaddr filesz, Error **errp)
+{
+ Elf32_Phdr phdr;
+ int ret;
+
+ memset(&phdr, 0, sizeof(Elf32_Phdr));
+ 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) ?: phdr.p_paddr;
+
+ assert(memory_mapping->length >= filesz);
+
+ ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret,
+ "dump: failed to write program header table");
+ }
+}
+
+static void write_elf64_note(DumpState *s, Error **errp)
+{
+ Elf64_Phdr phdr;
+ hwaddr begin = s->memory_offset - s->note_size;
+ int ret;
+
+ memset(&phdr, 0, sizeof(Elf64_Phdr));
+ phdr.p_type = cpu_to_dump32(s, PT_NOTE);
+ phdr.p_offset = cpu_to_dump64(s, begin);
+ phdr.p_paddr = 0;
+ phdr.p_filesz = cpu_to_dump64(s, s->note_size);
+ phdr.p_memsz = cpu_to_dump64(s, s->note_size);
+ phdr.p_vaddr = 0;
+
+ ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret,
+ "dump: failed to write program header table");
+ }
+}
+
+static inline int cpu_index(CPUState *cpu)
+{
+ return cpu->cpu_index + 1;
+}
+
+static void write_guest_note(WriteCoreDumpFunction f, DumpState *s,
+ Error **errp)
+{
+ int ret;
+
+ if (s->guest_note) {
+ ret = f(s->guest_note, s->guest_note_size, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write guest note");
+ }
+ }
+}
+
+static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
+ Error **errp)
+{
+ CPUState *cpu;
+ int ret;
+ int id;
+
+ CPU_FOREACH(cpu) {
+ id = cpu_index(cpu);
+ ret = cpu_write_elf64_note(f, cpu, id, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write elf notes");
+ return;
+ }
+ }
+
+ CPU_FOREACH(cpu) {
+ ret = cpu_write_elf64_qemunote(f, cpu, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write CPU status");
+ return;
+ }
+ }
+
+ write_guest_note(f, s, errp);
+}
+
+static void write_elf32_note(DumpState *s, Error **errp)
+{
+ hwaddr begin = s->memory_offset - s->note_size;
+ Elf32_Phdr phdr;
+ int ret;
+
+ memset(&phdr, 0, sizeof(Elf32_Phdr));
+ phdr.p_type = cpu_to_dump32(s, PT_NOTE);
+ phdr.p_offset = cpu_to_dump32(s, begin);
+ phdr.p_paddr = 0;
+ phdr.p_filesz = cpu_to_dump32(s, s->note_size);
+ phdr.p_memsz = cpu_to_dump32(s, s->note_size);
+ phdr.p_vaddr = 0;
+
+ ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret,
+ "dump: failed to write program header table");
+ }
+}
+
+static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
+ Error **errp)
+{
+ CPUState *cpu;
+ int ret;
+ int id;
+
+ CPU_FOREACH(cpu) {
+ id = cpu_index(cpu);
+ ret = cpu_write_elf32_note(f, cpu, id, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write elf notes");
+ return;
+ }
+ }
+
+ CPU_FOREACH(cpu) {
+ ret = cpu_write_elf32_qemunote(f, cpu, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write CPU status");
+ return;
+ }
+ }
+
+ write_guest_note(f, s, errp);
+}
+
+static void write_elf_section(DumpState *s, int type, Error **errp)
+{
+ 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);
+ shdr32.sh_info = cpu_to_dump32(s, s->sh_info);
+ shdr = &shdr32;
+ } else {
+ shdr_size = sizeof(Elf64_Shdr);
+ memset(&shdr64, 0, shdr_size);
+ shdr64.sh_info = cpu_to_dump32(s, s->sh_info);
+ shdr = &shdr64;
+ }
+
+ ret = fd_write_vmcore(&shdr, shdr_size, s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret,
+ "dump: failed to write section header table");
+ }
+}
+
+static void write_data(DumpState *s, void *buf, int length, Error **errp)
+{
+ int ret;
+
+ ret = fd_write_vmcore(buf, length, s);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret, "dump: failed to save memory");
+ } else {
+ s->written_size += length;
+ }
+}
+
+/* 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)
+{
+ int64_t i;
+ Error *local_err = NULL;
+
+ 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);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+
+ 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);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+}
+
+/* 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)
+{
+ GuestPhysBlock *block;
+ hwaddr offset = s->memory_offset;
+ int64_t size_in_block, start;
+
+ /* When the memory is not stored into vmcore, offset will be -1 */
+ *p_offset = -1;
+ *p_filesz = 0;
+
+ if (s->has_filter) {
+ if (phys_addr < s->begin || phys_addr >= s->begin + s->length) {
+ return;
+ }
+ }
+
+ QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
+ if (s->has_filter) {
+ if (block->target_start >= s->begin + s->length ||
+ block->target_end <= s->begin) {
+ /* This block is out of the range */
+ continue;
+ }
+
+ if (s->begin <= block->target_start) {
+ start = block->target_start;
+ } else {
+ start = s->begin;
+ }
+
+ 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);
+ }
+ } else {
+ start = block->target_start;
+ size_in_block = block->target_end - block->target_start;
+ }
+
+ if (phys_addr >= start && phys_addr < start + size_in_block) {
+ *p_offset = phys_addr - start + offset;
+
+ /* The offset range mapped from the vmcore file must not spill over
+ * the GuestPhysBlock, clamp it. The rest of the mapping will be
+ * 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;
+ }
+
+ offset += size_in_block;
+ }
+}
+
+static void write_elf_loads(DumpState *s, Error **errp)
+{
+ hwaddr offset, filesz;
+ MemoryMapping *memory_mapping;
+ uint32_t phdr_index = 1;
+ uint32_t max_index;
+ Error *local_err = NULL;
+
+ if (s->have_section) {
+ max_index = s->sh_info;
+ } else {
+ max_index = s->phdr_num;
+ }
+
+ QTAILQ_FOREACH(memory_mapping, &s->list.head, next) {
+ get_offset_range(memory_mapping->phys_addr,
+ memory_mapping->length,
+ s, &offset, &filesz);
+ if (s->dump_info.d_class == ELFCLASS64) {
+ write_elf64_load(s, memory_mapping, phdr_index++, offset,
+ filesz, &local_err);
+ } else {
+ write_elf32_load(s, memory_mapping, phdr_index++, offset,
+ filesz, &local_err);
+ }
+
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ if (phdr_index >= max_index) {
+ break;
+ }
+ }
+}
+
+/* write elf header, PT_NOTE and elf note to vmcore. */
+static void dump_begin(DumpState *s, Error **errp)
+{
+ Error *local_err = NULL;
+
+ /*
+ * 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) {
+ write_elf64_header(s, &local_err);
+ } else {
+ write_elf32_header(s, &local_err);
+ }
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ if (s->dump_info.d_class == ELFCLASS64) {
+ /* write PT_NOTE to vmcore */
+ write_elf64_note(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ /* write all PT_LOAD to vmcore */
+ write_elf_loads(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ /* write section to vmcore */
+ if (s->have_section) {
+ write_elf_section(s, 1, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+
+ /* write notes to vmcore */
+ write_elf64_notes(fd_write_vmcore, s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ } else {
+ /* write PT_NOTE to vmcore */
+ write_elf32_note(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ /* write all PT_LOAD to vmcore */
+ write_elf_loads(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ /* write section to vmcore */
+ if (s->have_section) {
+ write_elf_section(s, 0, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+
+ /* write notes to vmcore */
+ write_elf32_notes(fd_write_vmcore, s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+}
+
+static int get_next_block(DumpState *s, GuestPhysBlock *block)
+{
+ while (1) {
+ block = QTAILQ_NEXT(block, next);
+ if (!block) {
+ /* no more block */
+ return 1;
+ }
+
+ s->start = 0;
+ s->next_block = block;
+ if (s->has_filter) {
+ if (block->target_start >= s->begin + s->length ||
+ block->target_end <= s->begin) {
+ /* This block is out of the range */
+ continue;
+ }
+
+ if (s->begin > block->target_start) {
+ s->start = s->begin - block->target_start;
+ }
+ }
+
+ return 0;
+ }
+}
+
+/* write all memory to vmcore */
+static void dump_iterate(DumpState *s, Error **errp)
+{
+ GuestPhysBlock *block;
+ int64_t size;
+ Error *local_err = NULL;
+
+ do {
+ block = s->next_block;
+
+ size = block->target_end - block->target_start;
+ if (s->has_filter) {
+ size -= s->start;
+ if (s->begin + s->length < block->target_end) {
+ size -= block->target_end - (s->begin + s->length);
+ }
+ }
+ write_memory(s, block, s->start, size, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ } while (!get_next_block(s, block));
+}
+
+static void create_vmcore(DumpState *s, Error **errp)
+{
+ Error *local_err = NULL;
+
+ dump_begin(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ dump_iterate(s, errp);
+}
+
+static int write_start_flat_header(int fd)
+{
+ MakedumpfileHeader *mh;
+ int ret = 0;
+
+ QEMU_BUILD_BUG_ON(sizeof *mh > MAX_SIZE_MDF_HEADER);
+ mh = g_malloc0(MAX_SIZE_MDF_HEADER);
+
+ memcpy(mh->signature, MAKEDUMPFILE_SIGNATURE,
+ MIN(sizeof mh->signature, sizeof MAKEDUMPFILE_SIGNATURE));
+
+ mh->type = cpu_to_be64(TYPE_FLAT_HEADER);
+ mh->version = cpu_to_be64(VERSION_FLAT_HEADER);
+
+ size_t written_size;
+ written_size = qemu_write_full(fd, mh, MAX_SIZE_MDF_HEADER);
+ if (written_size != MAX_SIZE_MDF_HEADER) {
+ ret = -1;
+ }
+
+ g_free(mh);
+ 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;
+}
+
+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;
+}
+
+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;
+}
+
+/*
+ * This function retrieves various sizes from an elf header.
+ *
+ * @note has to be a valid ELF note. The return sizes are unmodified
+ * (not padded or rounded up to be multiple of 4).
+ */
+static void get_note_sizes(DumpState *s, const void *note,
+ uint64_t *note_head_size,
+ uint64_t *name_size,
+ uint64_t *desc_size)
+{
+ uint64_t note_head_sz;
+ uint64_t name_sz;
+ uint64_t desc_sz;
+
+ if (s->dump_info.d_class == ELFCLASS64) {
+ const Elf64_Nhdr *hdr = note;
+ note_head_sz = sizeof(Elf64_Nhdr);
+ name_sz = tswap64(hdr->n_namesz);
+ desc_sz = tswap64(hdr->n_descsz);
+ } else {
+ const Elf32_Nhdr *hdr = note;
+ note_head_sz = sizeof(Elf32_Nhdr);
+ name_sz = tswap32(hdr->n_namesz);
+ desc_sz = tswap32(hdr->n_descsz);
+ }
+
+ if (note_head_size) {
+ *note_head_size = note_head_sz;
+ }
+ if (name_size) {
+ *name_size = name_sz;
+ }
+ if (desc_size) {
+ *desc_size = desc_sz;
+ }
+}
+
+static bool note_name_equal(DumpState *s,
+ const uint8_t *note, const char *name)
+{
+ int len = strlen(name) + 1;
+ uint64_t head_size, name_size;
+
+ get_note_sizes(s, note, &head_size, &name_size, NULL);
+ head_size = ROUND_UP(head_size, 4);
+
+ return name_size == len && memcmp(note + head_size, name, len) == 0;
+}
+
+/* write common header, sub header and elf note to vmcore */
+static void create_header32(DumpState *s, Error **errp)
+{
+ 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;
+ Error *local_err = NULL;
+
+ /* write common header, the version of kdump-compressed format is 6th */
+ size = sizeof(DiskDumpHeader32);
+ dh = g_malloc0(size);
+
+ memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
+ dh->header_version = cpu_to_dump32(s, 6);
+ block_size = s->dump_info.page_size;
+ dh->block_size = cpu_to_dump32(s, block_size);
+ sub_hdr_size = sizeof(struct KdumpSubHeader32) + s->note_size;
+ sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
+ dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
+ /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
+ dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
+ dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
+ bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
+ dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
+ strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
+
+ 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
+ dh->status = cpu_to_dump32(s, status);
+
+ if (write_buffer(s->fd, 0, dh, size) < 0) {
+ error_setg(errp, "dump: failed to write disk dump header");
+ goto out;
+ }
+
+ /* write sub header */
+ size = sizeof(KdumpSubHeader32);
+ kh = g_malloc0(size);
+
+ /* 64bit max_mapnr_64 */
+ kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
+ kh->phys_base = cpu_to_dump32(s, s->dump_info.phys_base);
+ kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
+
+ offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
+ if (s->guest_note &&
+ note_name_equal(s, s->guest_note, "VMCOREINFO")) {
+ uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
+
+ get_note_sizes(s, s->guest_note,
+ &hsize, &name_size, &size_vmcoreinfo_desc);
+ offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
+ (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
+ kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
+ kh->size_vmcoreinfo = cpu_to_dump32(s, size_vmcoreinfo_desc);
+ }
+
+ kh->offset_note = cpu_to_dump64(s, offset_note);
+ kh->note_size = cpu_to_dump32(s, s->note_size);
+
+ if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
+ block_size, kh, size) < 0) {
+ error_setg(errp, "dump: failed to write kdump sub header");
+ 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 */
+ write_elf32_notes(buf_write_note, s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ goto out;
+ }
+ if (write_buffer(s->fd, offset_note, s->note_buf,
+ s->note_size) < 0) {
+ error_setg(errp, "dump: failed to write notes");
+ 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 */
+static void create_header64(DumpState *s, Error **errp)
+{
+ 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;
+ Error *local_err = NULL;
+
+ /* write common header, the version of kdump-compressed format is 6th */
+ size = sizeof(DiskDumpHeader64);
+ dh = g_malloc0(size);
+
+ memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
+ dh->header_version = cpu_to_dump32(s, 6);
+ block_size = s->dump_info.page_size;
+ dh->block_size = cpu_to_dump32(s, block_size);
+ sub_hdr_size = sizeof(struct KdumpSubHeader64) + s->note_size;
+ sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
+ dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
+ /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
+ dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
+ dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
+ bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
+ dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
+ strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
+
+ 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
+ dh->status = cpu_to_dump32(s, status);
+
+ if (write_buffer(s->fd, 0, dh, size) < 0) {
+ error_setg(errp, "dump: failed to write disk dump header");
+ goto out;
+ }
+
+ /* write sub header */
+ size = sizeof(KdumpSubHeader64);
+ kh = g_malloc0(size);
+
+ /* 64bit max_mapnr_64 */
+ kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
+ kh->phys_base = cpu_to_dump64(s, s->dump_info.phys_base);
+ kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
+
+ offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
+ if (s->guest_note &&
+ note_name_equal(s, s->guest_note, "VMCOREINFO")) {
+ uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
+
+ get_note_sizes(s, s->guest_note,
+ &hsize, &name_size, &size_vmcoreinfo_desc);
+ offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
+ (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
+ kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
+ kh->size_vmcoreinfo = cpu_to_dump64(s, size_vmcoreinfo_desc);
+ }
+
+ kh->offset_note = cpu_to_dump64(s, offset_note);
+ kh->note_size = cpu_to_dump64(s, s->note_size);
+
+ if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
+ block_size, kh, size) < 0) {
+ error_setg(errp, "dump: failed to write kdump sub header");
+ 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 */
+ write_elf64_notes(buf_write_note, s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ goto out;
+ }
+
+ if (write_buffer(s->fd, offset_note, s->note_buf,
+ s->note_size) < 0) {
+ error_setg(errp, "dump: failed to write notes");
+ 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);
+}
+
+static void write_dump_header(DumpState *s, Error **errp)
+{
+ Error *local_err = NULL;
+
+ if (s->dump_info.d_class == ELFCLASS32) {
+ create_header32(s, &local_err);
+ } else {
+ create_header64(s, &local_err);
+ }
+ error_propagate(errp, local_err);
+}
+
+static size_t dump_bitmap_get_bufsize(DumpState *s)
+{
+ return s->dump_info.page_size;
+}
+
+/*
+ * 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;
+ size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
+ size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
+
+ /* 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.
+ */
+ old_offset = bitmap_bufsize * (last_pfn / bits_per_buf);
+ new_offset = bitmap_bufsize * (pfn / bits_per_buf);
+
+ 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,
+ bitmap_bufsize) < 0) {
+ 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,
+ bitmap_bufsize) < 0) {
+ return -1;
+ }
+
+ memset(buf, 0, bitmap_bufsize);
+ old_offset += bitmap_bufsize;
+ }
+
+ /* get the exact place of the bit in the buf, and set it */
+ byte = (pfn % bits_per_buf) / CHAR_BIT;
+ bit = (pfn % bits_per_buf) % CHAR_BIT;
+ if (value) {
+ buf[byte] |= 1u << bit;
+ } else {
+ buf[byte] &= ~(1u << bit);
+ }
+
+ return 0;
+}
+
+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;
+}
+
+/*
+ * 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;
+ hwaddr addr, target_page_mask = ~((hwaddr)s->dump_info.page_size - 1);
+ uint8_t *buf;
+
+ /* block == NULL means the start of the iteration */
+ if (!block) {
+ block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
+ *blockptr = block;
+ 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);
+ if (bufptr) {
+ *bufptr = block->host_addr;
+ }
+ return true;
+ }
+
+ *pfnptr = *pfnptr + 1;
+ addr = dump_pfn_to_paddr(s, *pfnptr);
+
+ if ((addr >= block->target_start) &&
+ (addr + s->dump_info.page_size <= block->target_end)) {
+ 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;
+ }
+ 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);
+ buf = block->host_addr;
+ }
+
+ if (bufptr) {
+ *bufptr = buf;
+ }
+
+ return true;
+}
+
+static void write_dump_bitmap(DumpState *s, Error **errp)
+{
+ int ret = 0;
+ uint64_t last_pfn, pfn;
+ void *dump_bitmap_buf;
+ size_t num_dumpable;
+ GuestPhysBlock *block_iter = NULL;
+ size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
+ size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
+
+ /* dump_bitmap_buf is used to store dump_bitmap temporarily */
+ dump_bitmap_buf = g_malloc0(bitmap_bufsize);
+
+ 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) {
+ error_setg(errp, "dump: failed to set dump_bitmap");
+ goto out;
+ }
+
+ last_pfn = pfn;
+ num_dumpable++;
+ }
+
+ /*
+ * set_dump_bitmap will always leave the recently set bit un-sync. Here we
+ * 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.
+ */
+ if (num_dumpable > 0) {
+ ret = set_dump_bitmap(last_pfn, last_pfn + bits_per_buf, false,
+ dump_bitmap_buf, s);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to sync dump_bitmap");
+ goto out;
+ }
+ }
+
+ /* number of dumpable pages that will be dumped later */
+ s->num_dumpable = num_dumpable;
+
+out:
+ g_free(dump_bitmap_buf);
+}
+
+static void prepare_data_cache(DataCache *data_cache, DumpState *s,
+ off_t offset)
+{
+ data_cache->fd = s->fd;
+ data_cache->data_size = 0;
+ data_cache->buf_size = 4 * dump_bitmap_get_bufsize(s);
+ data_cache->buf = g_malloc0(data_cache->buf_size);
+ 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);
+}
+
+static size_t get_len_buf_out(size_t page_size, uint32_t flag_compress)
+{
+ 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;
+
+#ifdef CONFIG_SNAPPY
+ case DUMP_DH_COMPRESSED_SNAPPY:
+ return snappy_max_compressed_length(page_size);
+#endif
+ }
+ return 0;
+}
+
+/*
+ * 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);
+}
+
+static void write_dump_pages(DumpState *s, Error **errp)
+{
+ 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 */
+ len_buf_out = get_len_buf_out(s->dump_info.page_size, s->flag_compress);
+ assert(len_buf_out != 0);
+
+#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
+ */
+ pd_zero.size = cpu_to_dump32(s, s->dump_info.page_size);
+ 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);
+ buf = g_malloc0(s->dump_info.page_size);
+ ret = write_cache(&page_data, buf, s->dump_info.page_size, false);
+ g_free(buf);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page data (zero page)");
+ goto out;
+ }
+
+ offset_data += s->dump_info.page_size;
+
+ /*
+ * 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 */
+ if (is_zero_page(buf, s->dump_info.page_size)) {
+ ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor),
+ false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page desc");
+ 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) &&
+ (compress2(buf_out, (uLongf *)&size_out, buf,
+ s->dump_info.page_size, Z_BEST_SPEED) == Z_OK) &&
+ (size_out < s->dump_info.page_size)) {
+ pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_ZLIB);
+ pd.size = cpu_to_dump32(s, size_out);
+
+ ret = write_cache(&page_data, buf_out, size_out, false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page data");
+ goto out;
+ }
+#ifdef CONFIG_LZO
+ } else if ((s->flag_compress & DUMP_DH_COMPRESSED_LZO) &&
+ (lzo1x_1_compress(buf, s->dump_info.page_size, buf_out,
+ (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) &&
+ (size_out < s->dump_info.page_size)) {
+ pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_LZO);
+ pd.size = cpu_to_dump32(s, size_out);
+
+ ret = write_cache(&page_data, buf_out, size_out, false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page data");
+ goto out;
+ }
+#endif
+#ifdef CONFIG_SNAPPY
+ } else if ((s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) &&
+ (snappy_compress((char *)buf, s->dump_info.page_size,
+ (char *)buf_out, &size_out) == SNAPPY_OK) &&
+ (size_out < s->dump_info.page_size)) {
+ pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_SNAPPY);
+ pd.size = cpu_to_dump32(s, size_out);
+
+ ret = write_cache(&page_data, buf_out, size_out, false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page data");
+ goto out;
+ }
+#endif
+ } else {
+ /*
+ * fall back to save in plaintext, size_out should be
+ * assigned the target's page size
+ */
+ pd.flags = cpu_to_dump32(s, 0);
+ size_out = s->dump_info.page_size;
+ pd.size = cpu_to_dump32(s, size_out);
+
+ ret = write_cache(&page_data, buf,
+ s->dump_info.page_size, false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page data");
+ goto out;
+ }
+ }
+
+ /* get and write page desc here */
+ pd.page_flags = cpu_to_dump64(s, 0);
+ pd.offset = cpu_to_dump64(s, offset_data);
+ offset_data += size_out;
+
+ ret = write_cache(&page_desc, &pd, sizeof(PageDescriptor), false);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write page desc");
+ goto out;
+ }
+ }
+ s->written_size += s->dump_info.page_size;
+ }
+
+ ret = write_cache(&page_desc, NULL, 0, true);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to sync cache for page_desc");
+ goto out;
+ }
+ ret = write_cache(&page_data, NULL, 0, true);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to sync cache for page_data");
+ goto out;
+ }
+
+out:
+ free_data_cache(&page_desc);
+ free_data_cache(&page_data);
+
+#ifdef CONFIG_LZO
+ g_free(wrkmem);
+#endif
+
+ g_free(buf_out);
+}
+
+static void create_kdump_vmcore(DumpState *s, Error **errp)
+{
+ int ret;
+ Error *local_err = NULL;
+
+ /*
+ * 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) {
+ error_setg(errp, "dump: failed to write start flat header");
+ return;
+ }
+
+ write_dump_header(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ write_dump_bitmap(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ write_dump_pages(s, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ ret = write_end_flat_header(s->fd);
+ if (ret < 0) {
+ error_setg(errp, "dump: failed to write end flat header");
+ return;
+ }
+}
+
+static ram_addr_t get_start_block(DumpState *s)
+{
+ GuestPhysBlock *block;
+
+ if (!s->has_filter) {
+ s->next_block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
+ return 0;
+ }
+
+ QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
+ if (block->target_start >= s->begin + s->length ||
+ block->target_end <= s->begin) {
+ /* This block is out of the range */
+ continue;
+ }
+
+ s->next_block = block;
+ if (s->begin > block->target_start) {
+ s->start = s->begin - block->target_start;
+ } else {
+ s->start = 0;
+ }
+ return s->start;
+ }
+
+ return -1;
+}
+
+static void get_max_mapnr(DumpState *s)
+{
+ GuestPhysBlock *last_block;
+
+ last_block = QTAILQ_LAST(&s->guest_phys_blocks.head);
+ s->max_mapnr = dump_paddr_to_pfn(s, last_block->target_end);
+}
+
+static DumpState dump_state_global = { .status = DUMP_STATUS_NONE };
+
+static void dump_state_prepare(DumpState *s)
+{
+ /* zero the struct, setting status to active */
+ *s = (DumpState) { .status = DUMP_STATUS_ACTIVE };
+}
+
+bool dump_in_progress(void)
+{
+ DumpState *state = &dump_state_global;
+ return (atomic_read(&state->status) == DUMP_STATUS_ACTIVE);
+}
+
+/* calculate total size of memory to be dumped (taking filter into
+ * acoount.) */
+static int64_t dump_calculate_size(DumpState *s)
+{
+ GuestPhysBlock *block;
+ int64_t size = 0, total = 0, left = 0, right = 0;
+
+ QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
+ if (s->has_filter) {
+ /* calculate the overlapped region. */
+ left = MAX(s->begin, block->target_start);
+ right = MIN(s->begin + s->length, block->target_end);
+ size = right - left;
+ size = size > 0 ? size : 0;
+ } else {
+ /* count the whole region in */
+ size = (block->target_end - block->target_start);
+ }
+ total += size;
+ }
+
+ return total;
+}
+
+static void vmcoreinfo_update_phys_base(DumpState *s)
+{
+ uint64_t size, note_head_size, name_size, phys_base;
+ char **lines;
+ uint8_t *vmci;
+ size_t i;
+
+ if (!note_name_equal(s, s->guest_note, "VMCOREINFO")) {
+ return;
+ }
+
+ get_note_sizes(s, s->guest_note, ¬e_head_size, &name_size, &size);
+ note_head_size = ROUND_UP(note_head_size, 4);
+
+ vmci = s->guest_note + note_head_size + ROUND_UP(name_size, 4);
+ *(vmci + size) = '\0';
+
+ lines = g_strsplit((char *)vmci, "\n", -1);
+ for (i = 0; lines[i]; i++) {
+ const char *prefix = NULL;
+
+ if (s->dump_info.d_machine == EM_X86_64) {
+ prefix = "NUMBER(phys_base)=";
+ } else if (s->dump_info.d_machine == EM_AARCH64) {
+ prefix = "NUMBER(PHYS_OFFSET)=";
+ }
+
+ if (prefix && g_str_has_prefix(lines[i], prefix)) {
+ if (qemu_strtou64(lines[i] + strlen(prefix), NULL, 16,
+ &phys_base) < 0) {
+ warn_report("Failed to read %s", prefix);
+ } else {
+ s->dump_info.phys_base = phys_base;
+ }
+ break;
+ }
+ }
+
+ g_strfreev(lines);
+}
+
+static void dump_init(DumpState *s, int fd, bool has_format,
+ DumpGuestMemoryFormat format, bool paging, bool has_filter,
+ int64_t begin, int64_t length, Error **errp)
+{
+ VMCoreInfoState *vmci = vmcoreinfo_find();
+ CPUState *cpu;
+ int nr_cpus;
+ Error *err = NULL;
+ int ret;
+
+ s->has_format = has_format;
+ s->format = format;
+ s->written_size = 0;
+
+ /* kdump-compressed is conflict with paging and filter */
+ if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
+ assert(!paging && !has_filter);
+ }
+
+ if (runstate_is_running()) {
+ vm_stop(RUN_STATE_SAVE_VM);
+ s->resume = true;
+ } else {
+ s->resume = false;
+ }
+
+ /* If we use KVM, we should synchronize the registers before we get dump
+ * info or physmap info.
+ */
+ cpu_synchronize_all_states();
+ nr_cpus = 0;
+ CPU_FOREACH(cpu) {
+ nr_cpus++;
+ }
+
+ s->fd = fd;
+ s->has_filter = has_filter;
+ s->begin = begin;
+ s->length = length;
+
+ memory_mapping_list_init(&s->list);
+
+ guest_phys_blocks_init(&s->guest_phys_blocks);
+ guest_phys_blocks_append(&s->guest_phys_blocks);
+ s->total_size = dump_calculate_size(s);
+#ifdef DEBUG_DUMP_GUEST_MEMORY
+ fprintf(stderr, "DUMP: total memory to dump: %lu\n", s->total_size);
+#endif
+
+ /* it does not make sense to dump non-existent memory */
+ if (!s->total_size) {
+ error_setg(errp, "dump: no guest memory to dump");
+ goto cleanup;
+ }
+
+ s->start = get_start_block(s);
+ if (s->start == -1) {
+ error_setg(errp, QERR_INVALID_PARAMETER, "begin");
+ goto cleanup;
+ }
+
+ /* get dump info: endian, class and architecture.
+ * If the target architecture is not supported, cpu_get_dump_info() will
+ * return -1.
+ */
+ ret = cpu_get_dump_info(&s->dump_info, &s->guest_phys_blocks);
+ if (ret < 0) {
+ error_setg(errp, QERR_UNSUPPORTED);
+ goto cleanup;
+ }
+
+ if (!s->dump_info.page_size) {
+ s->dump_info.page_size = TARGET_PAGE_SIZE;
+ }
+
+ s->note_size = cpu_get_note_size(s->dump_info.d_class,
+ s->dump_info.d_machine, nr_cpus);
+ if (s->note_size < 0) {
+ error_setg(errp, QERR_UNSUPPORTED);
+ goto cleanup;
+ }
+
+ /*
+ * The goal of this block is to (a) update the previously guessed
+ * phys_base, (b) copy the guest note out of the guest.
+ * Failure to do so is not fatal for dumping.
+ */
+ if (vmci) {
+ uint64_t addr, note_head_size, name_size, desc_size;
+ uint32_t size;
+ uint16_t format;
+
+ note_head_size = s->dump_info.d_class == ELFCLASS32 ?
+ sizeof(Elf32_Nhdr) : sizeof(Elf64_Nhdr);
+
+ format = le16_to_cpu(vmci->vmcoreinfo.guest_format);
+ size = le32_to_cpu(vmci->vmcoreinfo.size);
+ addr = le64_to_cpu(vmci->vmcoreinfo.paddr);
+ if (!vmci->has_vmcoreinfo) {
+ warn_report("guest note is not present");
+ } else if (size < note_head_size || size > MAX_GUEST_NOTE_SIZE) {
+ warn_report("guest note size is invalid: %" PRIu32, size);
+ } else if (format != FW_CFG_VMCOREINFO_FORMAT_ELF) {
+ warn_report("guest note format is unsupported: %" PRIu16, format);
+ } else {
+ s->guest_note = g_malloc(size + 1); /* +1 for adding \0 */
+ cpu_physical_memory_read(addr, s->guest_note, size);
+
+ get_note_sizes(s, s->guest_note, NULL, &name_size, &desc_size);
+ s->guest_note_size = ELF_NOTE_SIZE(note_head_size, name_size,
+ desc_size);
+ if (name_size > MAX_GUEST_NOTE_SIZE ||
+ desc_size > MAX_GUEST_NOTE_SIZE ||
+ s->guest_note_size > size) {
+ warn_report("Invalid guest note header");
+ g_free(s->guest_note);
+ s->guest_note = NULL;
+ } else {
+ vmcoreinfo_update_phys_base(s);
+ s->note_size += s->guest_note_size;
+ }
+ }
+ }
+
+ /* get memory mapping */
+ if (paging) {
+ qemu_get_guest_memory_mapping(&s->list, &s->guest_phys_blocks, &err);
+ if (err != NULL) {
+ error_propagate(errp, err);
+ goto cleanup;
+ }
+ } else {
+ qemu_get_guest_simple_memory_mapping(&s->list, &s->guest_phys_blocks);
+ }
+
+ s->nr_cpus = nr_cpus;
+
+ get_max_mapnr(s);
+
+ uint64_t tmp;
+ tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT),
+ s->dump_info.page_size);
+ s->len_dump_bitmap = tmp * s->dump_info.page_size;
+
+ /* init for kdump-compressed format */
+ if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
+ switch (format) {
+ case DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB:
+ s->flag_compress = DUMP_DH_COMPRESSED_ZLIB;
+ break;
+
+ case DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO:
+#ifdef CONFIG_LZO
+ if (lzo_init() != LZO_E_OK) {
+ error_setg(errp, "failed to initialize the LZO library");
+ goto cleanup;
+ }
+#endif
+ s->flag_compress = DUMP_DH_COMPRESSED_LZO;
+ break;
+
+ case DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY:
+ s->flag_compress = DUMP_DH_COMPRESSED_SNAPPY;
+ break;
+
+ default:
+ s->flag_compress = 0;
+ }
+
+ return;
+ }
+
+ if (s->has_filter) {
+ memory_mapping_filter(&s->list, s->begin, s->length);
+ }
+
+ /*
+ * calculate phdr_num
+ *
+ * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
+ */
+ s->phdr_num = 1; /* PT_NOTE */
+ if (s->list.num < UINT16_MAX - 2) {
+ s->phdr_num += s->list.num;
+ s->have_section = false;
+ } else {
+ s->have_section = true;
+ s->phdr_num = PN_XNUM;
+ s->sh_info = 1; /* PT_NOTE */
+
+ /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
+ if (s->list.num <= UINT32_MAX - 1) {
+ s->sh_info += s->list.num;
+ } else {
+ s->sh_info = UINT32_MAX;
+ }
+ }
+
+ if (s->dump_info.d_class == ELFCLASS64) {
+ if (s->have_section) {
+ s->memory_offset = sizeof(Elf64_Ehdr) +
+ sizeof(Elf64_Phdr) * s->sh_info +
+ sizeof(Elf64_Shdr) + s->note_size;
+ } else {
+ s->memory_offset = sizeof(Elf64_Ehdr) +
+ sizeof(Elf64_Phdr) * s->phdr_num + s->note_size;
+ }
+ } else {
+ if (s->have_section) {
+ s->memory_offset = sizeof(Elf32_Ehdr) +
+ sizeof(Elf32_Phdr) * s->sh_info +
+ sizeof(Elf32_Shdr) + s->note_size;
+ } else {
+ s->memory_offset = sizeof(Elf32_Ehdr) +
+ sizeof(Elf32_Phdr) * s->phdr_num + s->note_size;
+ }
+ }
+
+ return;
+
+cleanup:
+ dump_cleanup(s);
+}
+
+/* this operation might be time consuming. */
+static void dump_process(DumpState *s, Error **errp)
+{
+ Error *local_err = NULL;
+ DumpQueryResult *result = NULL;
+
+ if (s->has_format && s->format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
+#ifdef TARGET_X86_64
+ create_win_dump(s, &local_err);
+#endif
+ } else if (s->has_format && s->format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
+ create_kdump_vmcore(s, &local_err);
+ } else {
+ create_vmcore(s, &local_err);
+ }
+
+ /* make sure status is written after written_size updates */
+ smp_wmb();
+ atomic_set(&s->status,
+ (local_err ? DUMP_STATUS_FAILED : DUMP_STATUS_COMPLETED));
+
+ /* send DUMP_COMPLETED message (unconditionally) */
+ result = qmp_query_dump(NULL);
+ /* should never fail */
+ assert(result);
+ qapi_event_send_dump_completed(result, !!local_err, (local_err ? \
+ error_get_pretty(local_err) : NULL));
+ qapi_free_DumpQueryResult(result);
+
+ error_propagate(errp, local_err);
+ dump_cleanup(s);
+}
+
+static void *dump_thread(void *data)
+{
+ DumpState *s = (DumpState *)data;
+ dump_process(s, NULL);
+ return NULL;
+}
+
+DumpQueryResult *qmp_query_dump(Error **errp)
+{
+ DumpQueryResult *result = g_new(DumpQueryResult, 1);
+ DumpState *state = &dump_state_global;
+ result->status = atomic_read(&state->status);
+ /* make sure we are reading status and written_size in order */
+ smp_rmb();
+ result->completed = state->written_size;
+ result->total = state->total_size;
+ return result;
+}
+
+void qmp_dump_guest_memory(bool paging, const char *file,
+ bool has_detach, bool detach,
+ bool has_begin, int64_t begin, bool has_length,
+ int64_t length, bool has_format,
+ DumpGuestMemoryFormat format, Error **errp)
+{
+ const char *p;
+ int fd = -1;
+ DumpState *s;
+ Error *local_err = NULL;
+ bool detach_p = false;
+
+ if (runstate_check(RUN_STATE_INMIGRATE)) {
+ error_setg(errp, "Dump not allowed during incoming migration.");
+ return;
+ }
+
+ /* if there is a dump in background, we should wait until the dump
+ * finished */
+ if (dump_in_progress()) {
+ error_setg(errp, "There is a dump in process, please wait.");
+ return;
+ }
+
+ /*
+ * kdump-compressed format need the whole memory dumped, so paging or
+ * filter is not supported here.
+ */
+ if ((has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) &&
+ (paging || has_begin || has_length)) {
+ error_setg(errp, "kdump-compressed format doesn't support paging or "
+ "filter");
+ return;
+ }
+ if (has_begin && !has_length) {
+ error_setg(errp, QERR_MISSING_PARAMETER, "length");
+ return;
+ }
+ if (!has_begin && has_length) {
+ error_setg(errp, QERR_MISSING_PARAMETER, "begin");
+ return;
+ }
+ if (has_detach) {
+ detach_p = detach;
+ }
+
+ /* check whether lzo/snappy is supported */
+#ifndef CONFIG_LZO
+ if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO) {
+ error_setg(errp, "kdump-lzo is not available now");
+ return;
+ }
+#endif
+
+#ifndef CONFIG_SNAPPY
+ if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY) {
+ error_setg(errp, "kdump-snappy is not available now");
+ return;
+ }
+#endif
+
+#ifndef TARGET_X86_64
+ if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
+ error_setg(errp, "Windows dump is only available for x86-64");
+ return;
+ }
+#endif
+
+#if !defined(WIN32)
+ if (strstart(file, "fd:", &p)) {
+ fd = monitor_get_fd(cur_mon, p, errp);
+ if (fd == -1) {
+ return;
+ }
+ }
+#endif
+
+ if (strstart(file, "file:", &p)) {
+ fd = qemu_open(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR);
+ if (fd < 0) {
+ error_setg_file_open(errp, errno, p);
+ return;
+ }
+ }
+
+ if (fd == -1) {
+ error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
+ return;
+ }
+
+ s = &dump_state_global;
+ dump_state_prepare(s);
+
+ dump_init(s, fd, has_format, format, paging, has_begin,
+ begin, length, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ atomic_set(&s->status, DUMP_STATUS_FAILED);
+ return;
+ }
+
+ if (detach_p) {
+ /* detached dump */
+ s->detached = true;
+ qemu_thread_create(&s->dump_thread, "dump_thread", dump_thread,
+ s, QEMU_THREAD_DETACHED);
+ } else {
+ /* sync dump */
+ dump_process(s, errp);
+ }
+}
+
+DumpGuestMemoryCapability *qmp_query_dump_guest_memory_capability(Error **errp)
+{
+ DumpGuestMemoryFormatList *item;
+ DumpGuestMemoryCapability *cap =
+ g_malloc0(sizeof(DumpGuestMemoryCapability));
+
+ /* elf is always available */
+ item = g_malloc0(sizeof(DumpGuestMemoryFormatList));
+ cap->formats = item;
+ item->value = DUMP_GUEST_MEMORY_FORMAT_ELF;
+
+ /* kdump-zlib is always available */
+ item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
+ item = item->next;
+ item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
+
+ /* add new item if kdump-lzo is available */
+#ifdef CONFIG_LZO
+ item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
+ item = item->next;
+ item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
+#endif
+
+ /* add new item if kdump-snappy is available */
+#ifdef CONFIG_SNAPPY
+ item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
+ item = item->next;
+ item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
+#endif
+
+ /* Windows dump is available only if target is x86_64 */
+#ifdef TARGET_X86_64
+ item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
+ item = item->next;
+ item->value = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP;
+#endif
+
+ return cap;
+}
--- /dev/null
+/*
+ * Windows crashdump
+ *
+ * Copyright (c) 2018 Virtuozzo International GmbH
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "qemu/cutils.h"
+#include "elf.h"
+#include "cpu.h"
+#include "exec/hwaddr.h"
+#include "monitor/monitor.h"
+#include "sysemu/kvm.h"
+#include "sysemu/dump.h"
+#include "sysemu/sysemu.h"
+#include "sysemu/memory_mapping.h"
+#include "sysemu/cpus.h"
+#include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
+#include "qemu/error-report.h"
+#include "hw/misc/vmcoreinfo.h"
+#include "win_dump.h"
+
+static size_t write_run(WinDumpPhyMemRun64 *run, int fd, Error **errp)
+{
+ void *buf;
+ uint64_t addr = run->BasePage << TARGET_PAGE_BITS;
+ uint64_t size = run->PageCount << TARGET_PAGE_BITS;
+ uint64_t len, l;
+ size_t total = 0;
+
+ while (size) {
+ len = size;
+
+ buf = cpu_physical_memory_map(addr, &len, false);
+ if (!buf) {
+ error_setg(errp, "win-dump: failed to map physical range"
+ " 0x%016" PRIx64 "-0x%016" PRIx64, addr, addr + size - 1);
+ return 0;
+ }
+
+ l = qemu_write_full(fd, buf, len);
+ cpu_physical_memory_unmap(buf, addr, false, len);
+ if (l != len) {
+ error_setg(errp, QERR_IO_ERROR);
+ return 0;
+ }
+
+ addr += l;
+ size -= l;
+ total += l;
+ }
+
+ return total;
+}
+
+static void write_runs(DumpState *s, WinDumpHeader64 *h, Error **errp)
+{
+ WinDumpPhyMemDesc64 *desc = &h->PhysicalMemoryBlock;
+ WinDumpPhyMemRun64 *run = desc->Run;
+ Error *local_err = NULL;
+ int i;
+
+ for (i = 0; i < desc->NumberOfRuns; i++) {
+ s->written_size += write_run(run + i, s->fd, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+ }
+}
+
+static void patch_mm_pfn_database(WinDumpHeader64 *h, Error **errp)
+{
+ if (cpu_memory_rw_debug(first_cpu,
+ h->KdDebuggerDataBlock + KDBG_MM_PFN_DATABASE_OFFSET64,
+ (uint8_t *)&h->PfnDatabase, sizeof(h->PfnDatabase), 0)) {
+ error_setg(errp, "win-dump: failed to read MmPfnDatabase");
+ return;
+ }
+}
+
+static void patch_bugcheck_data(WinDumpHeader64 *h, Error **errp)
+{
+ uint64_t KiBugcheckData;
+
+ if (cpu_memory_rw_debug(first_cpu,
+ h->KdDebuggerDataBlock + KDBG_KI_BUGCHECK_DATA_OFFSET64,
+ (uint8_t *)&KiBugcheckData, sizeof(KiBugcheckData), 0)) {
+ error_setg(errp, "win-dump: failed to read KiBugcheckData");
+ return;
+ }
+
+ if (cpu_memory_rw_debug(first_cpu,
+ KiBugcheckData,
+ h->BugcheckData, sizeof(h->BugcheckData), 0)) {
+ error_setg(errp, "win-dump: failed to read bugcheck data");
+ return;
+ }
+
+ /*
+ * If BugcheckCode wasn't saved, we consider guest OS as alive.
+ */
+
+ if (!h->BugcheckCode) {
+ h->BugcheckCode = LIVE_SYSTEM_DUMP;
+ }
+}
+
+/*
+ * This routine tries to correct mistakes in crashdump header.
+ */
+static void patch_header(WinDumpHeader64 *h)
+{
+ Error *local_err = NULL;
+
+ h->RequiredDumpSpace = sizeof(WinDumpHeader64) +
+ (h->PhysicalMemoryBlock.NumberOfPages << TARGET_PAGE_BITS);
+ h->PhysicalMemoryBlock.unused = 0;
+ h->unused1 = 0;
+
+ patch_mm_pfn_database(h, &local_err);
+ if (local_err) {
+ warn_report_err(local_err);
+ local_err = NULL;
+ }
+ patch_bugcheck_data(h, &local_err);
+ if (local_err) {
+ warn_report_err(local_err);
+ }
+}
+
+static void check_header(WinDumpHeader64 *h, Error **errp)
+{
+ const char Signature[] = "PAGE";
+ const char ValidDump[] = "DU64";
+
+ if (memcmp(h->Signature, Signature, sizeof(h->Signature))) {
+ error_setg(errp, "win-dump: invalid header, expected '%.4s',"
+ " got '%.4s'", Signature, h->Signature);
+ return;
+ }
+
+ if (memcmp(h->ValidDump, ValidDump, sizeof(h->ValidDump))) {
+ error_setg(errp, "win-dump: invalid header, expected '%.4s',"
+ " got '%.4s'", ValidDump, h->ValidDump);
+ return;
+ }
+}
+
+static void check_kdbg(WinDumpHeader64 *h, Error **errp)
+{
+ const char OwnerTag[] = "KDBG";
+ char read_OwnerTag[4];
+ uint64_t KdDebuggerDataBlock = h->KdDebuggerDataBlock;
+ bool try_fallback = true;
+
+try_again:
+ if (cpu_memory_rw_debug(first_cpu,
+ KdDebuggerDataBlock + KDBG_OWNER_TAG_OFFSET64,
+ (uint8_t *)&read_OwnerTag, sizeof(read_OwnerTag), 0)) {
+ error_setg(errp, "win-dump: failed to read OwnerTag");
+ return;
+ }
+
+ if (memcmp(read_OwnerTag, OwnerTag, sizeof(read_OwnerTag))) {
+ if (try_fallback) {
+ /*
+ * If attempt to use original KDBG failed
+ * (most likely because of its encryption),
+ * we try to use KDBG obtained by guest driver.
+ */
+
+ KdDebuggerDataBlock = h->BugcheckParameter1;
+ try_fallback = false;
+ goto try_again;
+ } else {
+ error_setg(errp, "win-dump: invalid KDBG OwnerTag,"
+ " expected '%.4s', got '%.4s'",
+ OwnerTag, read_OwnerTag);
+ return;
+ }
+ }
+
+ h->KdDebuggerDataBlock = KdDebuggerDataBlock;
+}
+
+struct saved_context {
+ WinContext ctx;
+ uint64_t addr;
+};
+
+static void patch_and_save_context(WinDumpHeader64 *h,
+ struct saved_context *saved_ctx,
+ Error **errp)
+{
+ uint64_t KiProcessorBlock;
+ uint16_t OffsetPrcbContext;
+ CPUState *cpu;
+ int i = 0;
+
+ if (cpu_memory_rw_debug(first_cpu,
+ h->KdDebuggerDataBlock + KDBG_KI_PROCESSOR_BLOCK_OFFSET64,
+ (uint8_t *)&KiProcessorBlock, sizeof(KiProcessorBlock), 0)) {
+ error_setg(errp, "win-dump: failed to read KiProcessorBlock");
+ return;
+ }
+
+ if (cpu_memory_rw_debug(first_cpu,
+ h->KdDebuggerDataBlock + KDBG_OFFSET_PRCB_CONTEXT_OFFSET64,
+ (uint8_t *)&OffsetPrcbContext, sizeof(OffsetPrcbContext), 0)) {
+ error_setg(errp, "win-dump: failed to read OffsetPrcbContext");
+ return;
+ }
+
+ CPU_FOREACH(cpu) {
+ X86CPU *x86_cpu = X86_CPU(cpu);
+ CPUX86State *env = &x86_cpu->env;
+ uint64_t Prcb;
+ uint64_t Context;
+ WinContext ctx;
+
+ if (cpu_memory_rw_debug(first_cpu,
+ KiProcessorBlock + i * sizeof(uint64_t),
+ (uint8_t *)&Prcb, sizeof(Prcb), 0)) {
+ error_setg(errp, "win-dump: failed to read"
+ " CPU #%d PRCB location", i);
+ return;
+ }
+
+ if (cpu_memory_rw_debug(first_cpu,
+ Prcb + OffsetPrcbContext,
+ (uint8_t *)&Context, sizeof(Context), 0)) {
+ error_setg(errp, "win-dump: failed to read"
+ " CPU #%d ContextFrame location", i);
+ return;
+ }
+
+ saved_ctx[i].addr = Context;
+
+ ctx = (WinContext){
+ .ContextFlags = WIN_CTX_ALL,
+ .MxCsr = env->mxcsr,
+
+ .SegEs = env->segs[0].selector,
+ .SegCs = env->segs[1].selector,
+ .SegSs = env->segs[2].selector,
+ .SegDs = env->segs[3].selector,
+ .SegFs = env->segs[4].selector,
+ .SegGs = env->segs[5].selector,
+ .EFlags = cpu_compute_eflags(env),
+
+ .Dr0 = env->dr[0],
+ .Dr1 = env->dr[1],
+ .Dr2 = env->dr[2],
+ .Dr3 = env->dr[3],
+ .Dr6 = env->dr[6],
+ .Dr7 = env->dr[7],
+
+ .Rax = env->regs[R_EAX],
+ .Rbx = env->regs[R_EBX],
+ .Rcx = env->regs[R_ECX],
+ .Rdx = env->regs[R_EDX],
+ .Rsp = env->regs[R_ESP],
+ .Rbp = env->regs[R_EBP],
+ .Rsi = env->regs[R_ESI],
+ .Rdi = env->regs[R_EDI],
+ .R8 = env->regs[8],
+ .R9 = env->regs[9],
+ .R10 = env->regs[10],
+ .R11 = env->regs[11],
+ .R12 = env->regs[12],
+ .R13 = env->regs[13],
+ .R14 = env->regs[14],
+ .R15 = env->regs[15],
+
+ .Rip = env->eip,
+ .FltSave = {
+ .MxCsr = env->mxcsr,
+ },
+ };
+
+ if (cpu_memory_rw_debug(first_cpu, Context,
+ (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext), 0)) {
+ error_setg(errp, "win-dump: failed to save CPU #%d context", i);
+ return;
+ }
+
+ if (cpu_memory_rw_debug(first_cpu, Context,
+ (uint8_t *)&ctx, sizeof(WinContext), 1)) {
+ error_setg(errp, "win-dump: failed to write CPU #%d context", i);
+ return;
+ }
+
+ i++;
+ }
+}
+
+static void restore_context(WinDumpHeader64 *h,
+ struct saved_context *saved_ctx)
+{
+ int i;
+ Error *err = NULL;
+
+ for (i = 0; i < h->NumberProcessors; i++) {
+ if (cpu_memory_rw_debug(first_cpu, saved_ctx[i].addr,
+ (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext), 1)) {
+ error_setg(&err, "win-dump: failed to restore CPU #%d context", i);
+ warn_report_err(err);
+ }
+ }
+}
+
+void create_win_dump(DumpState *s, Error **errp)
+{
+ WinDumpHeader64 *h = (WinDumpHeader64 *)(s->guest_note +
+ VMCOREINFO_ELF_NOTE_HDR_SIZE);
+ X86CPU *first_x86_cpu = X86_CPU(first_cpu);
+ uint64_t saved_cr3 = first_x86_cpu->env.cr[3];
+ struct saved_context *saved_ctx = NULL;
+ Error *local_err = NULL;
+
+ if (s->guest_note_size != sizeof(WinDumpHeader64) +
+ VMCOREINFO_ELF_NOTE_HDR_SIZE) {
+ error_setg(errp, "win-dump: invalid vmcoreinfo note size");
+ return;
+ }
+
+ check_header(h, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
+
+ /*
+ * Further access to kernel structures by virtual addresses
+ * should be made from system context.
+ */
+
+ first_x86_cpu->env.cr[3] = h->DirectoryTableBase;
+
+ check_kdbg(h, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ goto out_cr3;
+ }
+
+ patch_header(h);
+
+ saved_ctx = g_new(struct saved_context, h->NumberProcessors);
+
+ /*
+ * Always patch context because there is no way
+ * to determine if the system-saved context is valid
+ */
+
+ patch_and_save_context(h, saved_ctx, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ goto out_free;
+ }
+
+ s->total_size = h->RequiredDumpSpace;
+
+ s->written_size = qemu_write_full(s->fd, h, sizeof(*h));
+ if (s->written_size != sizeof(*h)) {
+ error_setg(errp, QERR_IO_ERROR);
+ goto out_restore;
+ }
+
+ write_runs(s, h, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ goto out_restore;
+ }
+
+out_restore:
+ restore_context(h, saved_ctx);
+out_free:
+ g_free(saved_ctx);
+out_cr3:
+ first_x86_cpu->env.cr[3] = saved_cr3;
+
+ return;
+}
--- /dev/null
+/*
+ * Windows crashdump
+ *
+ * Copyright (c) 2018 Virtuozzo International GmbH
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef WIN_DUMP_H
+#define WIN_DUMP_H
+
+#include "qemu/win_dump_defs.h"
+
+void create_win_dump(DumpState *s, Error **errp);
+
+#endif /* WIN_DUMP_H */
+++ /dev/null
-/*
- * Windows crashdump
- *
- * Copyright (c) 2018 Virtuozzo International GmbH
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- *
- */
-
-#include "qemu/osdep.h"
-#include "qemu-common.h"
-#include "qemu/cutils.h"
-#include "elf.h"
-#include "cpu.h"
-#include "exec/hwaddr.h"
-#include "monitor/monitor.h"
-#include "sysemu/kvm.h"
-#include "sysemu/dump.h"
-#include "sysemu/sysemu.h"
-#include "sysemu/memory_mapping.h"
-#include "sysemu/cpus.h"
-#include "qapi/error.h"
-#include "qapi/qmp/qerror.h"
-#include "qemu/error-report.h"
-#include "hw/misc/vmcoreinfo.h"
-#include "win_dump.h"
-
-static size_t write_run(WinDumpPhyMemRun64 *run, int fd, Error **errp)
-{
- void *buf;
- uint64_t addr = run->BasePage << TARGET_PAGE_BITS;
- uint64_t size = run->PageCount << TARGET_PAGE_BITS;
- uint64_t len, l;
- size_t total = 0;
-
- while (size) {
- len = size;
-
- buf = cpu_physical_memory_map(addr, &len, false);
- if (!buf) {
- error_setg(errp, "win-dump: failed to map physical range"
- " 0x%016" PRIx64 "-0x%016" PRIx64, addr, addr + size - 1);
- return 0;
- }
-
- l = qemu_write_full(fd, buf, len);
- cpu_physical_memory_unmap(buf, addr, false, len);
- if (l != len) {
- error_setg(errp, QERR_IO_ERROR);
- return 0;
- }
-
- addr += l;
- size -= l;
- total += l;
- }
-
- return total;
-}
-
-static void write_runs(DumpState *s, WinDumpHeader64 *h, Error **errp)
-{
- WinDumpPhyMemDesc64 *desc = &h->PhysicalMemoryBlock;
- WinDumpPhyMemRun64 *run = desc->Run;
- Error *local_err = NULL;
- int i;
-
- for (i = 0; i < desc->NumberOfRuns; i++) {
- s->written_size += write_run(run + i, s->fd, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- }
-}
-
-static void patch_mm_pfn_database(WinDumpHeader64 *h, Error **errp)
-{
- if (cpu_memory_rw_debug(first_cpu,
- h->KdDebuggerDataBlock + KDBG_MM_PFN_DATABASE_OFFSET64,
- (uint8_t *)&h->PfnDatabase, sizeof(h->PfnDatabase), 0)) {
- error_setg(errp, "win-dump: failed to read MmPfnDatabase");
- return;
- }
-}
-
-static void patch_bugcheck_data(WinDumpHeader64 *h, Error **errp)
-{
- uint64_t KiBugcheckData;
-
- if (cpu_memory_rw_debug(first_cpu,
- h->KdDebuggerDataBlock + KDBG_KI_BUGCHECK_DATA_OFFSET64,
- (uint8_t *)&KiBugcheckData, sizeof(KiBugcheckData), 0)) {
- error_setg(errp, "win-dump: failed to read KiBugcheckData");
- return;
- }
-
- if (cpu_memory_rw_debug(first_cpu,
- KiBugcheckData,
- h->BugcheckData, sizeof(h->BugcheckData), 0)) {
- error_setg(errp, "win-dump: failed to read bugcheck data");
- return;
- }
-
- /*
- * If BugcheckCode wasn't saved, we consider guest OS as alive.
- */
-
- if (!h->BugcheckCode) {
- h->BugcheckCode = LIVE_SYSTEM_DUMP;
- }
-}
-
-/*
- * This routine tries to correct mistakes in crashdump header.
- */
-static void patch_header(WinDumpHeader64 *h)
-{
- Error *local_err = NULL;
-
- h->RequiredDumpSpace = sizeof(WinDumpHeader64) +
- (h->PhysicalMemoryBlock.NumberOfPages << TARGET_PAGE_BITS);
- h->PhysicalMemoryBlock.unused = 0;
- h->unused1 = 0;
-
- patch_mm_pfn_database(h, &local_err);
- if (local_err) {
- warn_report_err(local_err);
- local_err = NULL;
- }
- patch_bugcheck_data(h, &local_err);
- if (local_err) {
- warn_report_err(local_err);
- }
-}
-
-static void check_header(WinDumpHeader64 *h, Error **errp)
-{
- const char Signature[] = "PAGE";
- const char ValidDump[] = "DU64";
-
- if (memcmp(h->Signature, Signature, sizeof(h->Signature))) {
- error_setg(errp, "win-dump: invalid header, expected '%.4s',"
- " got '%.4s'", Signature, h->Signature);
- return;
- }
-
- if (memcmp(h->ValidDump, ValidDump, sizeof(h->ValidDump))) {
- error_setg(errp, "win-dump: invalid header, expected '%.4s',"
- " got '%.4s'", ValidDump, h->ValidDump);
- return;
- }
-}
-
-static void check_kdbg(WinDumpHeader64 *h, Error **errp)
-{
- const char OwnerTag[] = "KDBG";
- char read_OwnerTag[4];
- uint64_t KdDebuggerDataBlock = h->KdDebuggerDataBlock;
- bool try_fallback = true;
-
-try_again:
- if (cpu_memory_rw_debug(first_cpu,
- KdDebuggerDataBlock + KDBG_OWNER_TAG_OFFSET64,
- (uint8_t *)&read_OwnerTag, sizeof(read_OwnerTag), 0)) {
- error_setg(errp, "win-dump: failed to read OwnerTag");
- return;
- }
-
- if (memcmp(read_OwnerTag, OwnerTag, sizeof(read_OwnerTag))) {
- if (try_fallback) {
- /*
- * If attempt to use original KDBG failed
- * (most likely because of its encryption),
- * we try to use KDBG obtained by guest driver.
- */
-
- KdDebuggerDataBlock = h->BugcheckParameter1;
- try_fallback = false;
- goto try_again;
- } else {
- error_setg(errp, "win-dump: invalid KDBG OwnerTag,"
- " expected '%.4s', got '%.4s'",
- OwnerTag, read_OwnerTag);
- return;
- }
- }
-
- h->KdDebuggerDataBlock = KdDebuggerDataBlock;
-}
-
-struct saved_context {
- WinContext ctx;
- uint64_t addr;
-};
-
-static void patch_and_save_context(WinDumpHeader64 *h,
- struct saved_context *saved_ctx,
- Error **errp)
-{
- uint64_t KiProcessorBlock;
- uint16_t OffsetPrcbContext;
- CPUState *cpu;
- int i = 0;
-
- if (cpu_memory_rw_debug(first_cpu,
- h->KdDebuggerDataBlock + KDBG_KI_PROCESSOR_BLOCK_OFFSET64,
- (uint8_t *)&KiProcessorBlock, sizeof(KiProcessorBlock), 0)) {
- error_setg(errp, "win-dump: failed to read KiProcessorBlock");
- return;
- }
-
- if (cpu_memory_rw_debug(first_cpu,
- h->KdDebuggerDataBlock + KDBG_OFFSET_PRCB_CONTEXT_OFFSET64,
- (uint8_t *)&OffsetPrcbContext, sizeof(OffsetPrcbContext), 0)) {
- error_setg(errp, "win-dump: failed to read OffsetPrcbContext");
- return;
- }
-
- CPU_FOREACH(cpu) {
- X86CPU *x86_cpu = X86_CPU(cpu);
- CPUX86State *env = &x86_cpu->env;
- uint64_t Prcb;
- uint64_t Context;
- WinContext ctx;
-
- if (cpu_memory_rw_debug(first_cpu,
- KiProcessorBlock + i * sizeof(uint64_t),
- (uint8_t *)&Prcb, sizeof(Prcb), 0)) {
- error_setg(errp, "win-dump: failed to read"
- " CPU #%d PRCB location", i);
- return;
- }
-
- if (cpu_memory_rw_debug(first_cpu,
- Prcb + OffsetPrcbContext,
- (uint8_t *)&Context, sizeof(Context), 0)) {
- error_setg(errp, "win-dump: failed to read"
- " CPU #%d ContextFrame location", i);
- return;
- }
-
- saved_ctx[i].addr = Context;
-
- ctx = (WinContext){
- .ContextFlags = WIN_CTX_ALL,
- .MxCsr = env->mxcsr,
-
- .SegEs = env->segs[0].selector,
- .SegCs = env->segs[1].selector,
- .SegSs = env->segs[2].selector,
- .SegDs = env->segs[3].selector,
- .SegFs = env->segs[4].selector,
- .SegGs = env->segs[5].selector,
- .EFlags = cpu_compute_eflags(env),
-
- .Dr0 = env->dr[0],
- .Dr1 = env->dr[1],
- .Dr2 = env->dr[2],
- .Dr3 = env->dr[3],
- .Dr6 = env->dr[6],
- .Dr7 = env->dr[7],
-
- .Rax = env->regs[R_EAX],
- .Rbx = env->regs[R_EBX],
- .Rcx = env->regs[R_ECX],
- .Rdx = env->regs[R_EDX],
- .Rsp = env->regs[R_ESP],
- .Rbp = env->regs[R_EBP],
- .Rsi = env->regs[R_ESI],
- .Rdi = env->regs[R_EDI],
- .R8 = env->regs[8],
- .R9 = env->regs[9],
- .R10 = env->regs[10],
- .R11 = env->regs[11],
- .R12 = env->regs[12],
- .R13 = env->regs[13],
- .R14 = env->regs[14],
- .R15 = env->regs[15],
-
- .Rip = env->eip,
- .FltSave = {
- .MxCsr = env->mxcsr,
- },
- };
-
- if (cpu_memory_rw_debug(first_cpu, Context,
- (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext), 0)) {
- error_setg(errp, "win-dump: failed to save CPU #%d context", i);
- return;
- }
-
- if (cpu_memory_rw_debug(first_cpu, Context,
- (uint8_t *)&ctx, sizeof(WinContext), 1)) {
- error_setg(errp, "win-dump: failed to write CPU #%d context", i);
- return;
- }
-
- i++;
- }
-}
-
-static void restore_context(WinDumpHeader64 *h,
- struct saved_context *saved_ctx)
-{
- int i;
- Error *err = NULL;
-
- for (i = 0; i < h->NumberProcessors; i++) {
- if (cpu_memory_rw_debug(first_cpu, saved_ctx[i].addr,
- (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext), 1)) {
- error_setg(&err, "win-dump: failed to restore CPU #%d context", i);
- warn_report_err(err);
- }
- }
-}
-
-void create_win_dump(DumpState *s, Error **errp)
-{
- WinDumpHeader64 *h = (WinDumpHeader64 *)(s->guest_note +
- VMCOREINFO_ELF_NOTE_HDR_SIZE);
- X86CPU *first_x86_cpu = X86_CPU(first_cpu);
- uint64_t saved_cr3 = first_x86_cpu->env.cr[3];
- struct saved_context *saved_ctx = NULL;
- Error *local_err = NULL;
-
- if (s->guest_note_size != sizeof(WinDumpHeader64) +
- VMCOREINFO_ELF_NOTE_HDR_SIZE) {
- error_setg(errp, "win-dump: invalid vmcoreinfo note size");
- return;
- }
-
- check_header(h, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
-
- /*
- * Further access to kernel structures by virtual addresses
- * should be made from system context.
- */
-
- first_x86_cpu->env.cr[3] = h->DirectoryTableBase;
-
- check_kdbg(h, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- goto out_cr3;
- }
-
- patch_header(h);
-
- saved_ctx = g_new(struct saved_context, h->NumberProcessors);
-
- /*
- * Always patch context because there is no way
- * to determine if the system-saved context is valid
- */
-
- patch_and_save_context(h, saved_ctx, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- goto out_free;
- }
-
- s->total_size = h->RequiredDumpSpace;
-
- s->written_size = qemu_write_full(s->fd, h, sizeof(*h));
- if (s->written_size != sizeof(*h)) {
- error_setg(errp, QERR_IO_ERROR);
- goto out_restore;
- }
-
- write_runs(s, h, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- goto out_restore;
- }
-
-out_restore:
- restore_context(h, saved_ctx);
-out_free:
- g_free(saved_ctx);
-out_cr3:
- first_x86_cpu->env.cr[3] = saved_cr3;
-
- return;
-}
+++ /dev/null
-/*
- * Windows crashdump
- *
- * Copyright (c) 2018 Virtuozzo International GmbH
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- *
- */
-
-#ifndef WIN_DUMP_H
-#define WIN_DUMP_H
-
-#include "qemu/win_dump_defs.h"
-
-void create_win_dump(DumpState *s, Error **errp);
-
-#endif /* WIN_DUMP_H */
projects / qemu.git / commitdiff