X-Git-Url: https://repo.jachan.dev/qemu.git/blobdiff_plain/e00ef747f08db1c7dd58a5366db4dc3038a7307f..e0883e2de0ef36f254acc274e80ddeac13a2a8f6:/dump.c diff --git a/dump.c b/dump.c index 14b3d1d6ae..9c7dad8f86 100644 --- a/dump.c +++ b/dump.c @@ -36,9 +36,9 @@ #define ELF_MACHINE_UNAME "Unknown" #endif -static uint16_t cpu_convert_to_target16(uint16_t val, int endian) +uint16_t cpu_to_dump16(DumpState *s, uint16_t val) { - if (endian == ELFDATA2LSB) { + if (s->dump_info.d_endian == ELFDATA2LSB) { val = cpu_to_le16(val); } else { val = cpu_to_be16(val); @@ -47,9 +47,9 @@ static uint16_t cpu_convert_to_target16(uint16_t val, int endian) return val; } -static uint32_t cpu_convert_to_target32(uint32_t val, int endian) +uint32_t cpu_to_dump32(DumpState *s, uint32_t val) { - if (endian == ELFDATA2LSB) { + if (s->dump_info.d_endian == ELFDATA2LSB) { val = cpu_to_le32(val); } else { val = cpu_to_be32(val); @@ -58,9 +58,9 @@ static uint32_t cpu_convert_to_target32(uint32_t val, int endian) return val; } -static uint64_t cpu_convert_to_target64(uint64_t val, int endian) +uint64_t cpu_to_dump64(DumpState *s, uint64_t val) { - if (endian == ELFDATA2LSB) { + if (s->dump_info.d_endian == ELFDATA2LSB) { val = cpu_to_le64(val); } else { val = cpu_to_be64(val); @@ -69,58 +69,22 @@ static uint64_t cpu_convert_to_target64(uint64_t val, int endian) return val; } -typedef struct DumpState { - GuestPhysBlockList guest_phys_blocks; - ArchDumpInfo dump_info; - MemoryMappingList list; - uint16_t phdr_num; - uint32_t sh_info; - bool have_section; - bool resume; - ssize_t note_size; - hwaddr memory_offset; - int fd; - - GuestPhysBlock *next_block; - ram_addr_t start; - bool has_filter; - int64_t begin; - int64_t length; - Error **errp; - - uint8_t *note_buf; /* buffer for notes */ - size_t note_buf_offset; /* the writing place in note_buf */ - uint32_t nr_cpus; /* number of guest's cpu */ - size_t page_size; /* guest's page size */ - uint32_t page_shift; /* guest's page shift */ - uint64_t max_mapnr; /* the biggest guest's phys-mem's number */ - size_t len_dump_bitmap; /* the size of the place used to store - dump_bitmap in vmcore */ - off_t offset_dump_bitmap; /* offset of dump_bitmap part in vmcore */ - off_t offset_page; /* offset of page part in vmcore */ - size_t num_dumpable; /* number of page that can be dumped */ - uint32_t flag_compress; /* indicate the compression format */ -} DumpState; - static int dump_cleanup(DumpState *s) { - int ret = 0; - guest_phys_blocks_free(&s->guest_phys_blocks); memory_mapping_list_free(&s->list); - if (s->fd != -1) { - close(s->fd); - } + close(s->fd); if (s->resume) { vm_start(); } - return ret; + return 0; } -static void dump_error(DumpState *s, const char *reason) +static void dump_error(DumpState *s, const char *reason, Error **errp) { dump_cleanup(s); + error_setg(errp, "%s", reason); } static int fd_write_vmcore(const void *buf, size_t size, void *opaque) @@ -136,158 +100,132 @@ static int fd_write_vmcore(const void *buf, size_t size, void *opaque) return 0; } -static int write_elf64_header(DumpState *s) +static void write_elf64_header(DumpState *s, Error **errp) { Elf64_Ehdr elf_header; int ret; - int endian = s->dump_info.d_endian; 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_convert_to_target16(ET_CORE, endian); - elf_header.e_machine = cpu_convert_to_target16(s->dump_info.d_machine, - endian); - elf_header.e_version = cpu_convert_to_target32(EV_CURRENT, endian); - elf_header.e_ehsize = cpu_convert_to_target16(sizeof(elf_header), endian); - elf_header.e_phoff = cpu_convert_to_target64(sizeof(Elf64_Ehdr), endian); - elf_header.e_phentsize = cpu_convert_to_target16(sizeof(Elf64_Phdr), - endian); - elf_header.e_phnum = cpu_convert_to_target16(s->phdr_num, endian); + 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_convert_to_target64(shoff, endian); - elf_header.e_shentsize = cpu_convert_to_target16(sizeof(Elf64_Shdr), - endian); - elf_header.e_shnum = cpu_convert_to_target16(1, endian); + 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) { - dump_error(s, "dump: failed to write elf header.\n"); - return -1; + dump_error(s, "dump: failed to write elf header", errp); } - - return 0; } -static int write_elf32_header(DumpState *s) +static void write_elf32_header(DumpState *s, Error **errp) { Elf32_Ehdr elf_header; int ret; - int endian = s->dump_info.d_endian; 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] = endian; + elf_header.e_ident[EI_DATA] = s->dump_info.d_endian; elf_header.e_ident[EI_VERSION] = EV_CURRENT; - elf_header.e_type = cpu_convert_to_target16(ET_CORE, endian); - elf_header.e_machine = cpu_convert_to_target16(s->dump_info.d_machine, - endian); - elf_header.e_version = cpu_convert_to_target32(EV_CURRENT, endian); - elf_header.e_ehsize = cpu_convert_to_target16(sizeof(elf_header), endian); - elf_header.e_phoff = cpu_convert_to_target32(sizeof(Elf32_Ehdr), endian); - elf_header.e_phentsize = cpu_convert_to_target16(sizeof(Elf32_Phdr), - endian); - elf_header.e_phnum = cpu_convert_to_target16(s->phdr_num, endian); + 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_convert_to_target32(shoff, endian); - elf_header.e_shentsize = cpu_convert_to_target16(sizeof(Elf32_Shdr), - endian); - elf_header.e_shnum = cpu_convert_to_target16(1, endian); + 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) { - dump_error(s, "dump: failed to write elf header.\n"); - return -1; + dump_error(s, "dump: failed to write elf header", errp); } - - return 0; } -static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping, - int phdr_index, hwaddr offset, - hwaddr filesz) +static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping, + int phdr_index, hwaddr offset, + hwaddr filesz, Error **errp) { Elf64_Phdr phdr; int ret; - int endian = s->dump_info.d_endian; memset(&phdr, 0, sizeof(Elf64_Phdr)); - phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian); - phdr.p_offset = cpu_convert_to_target64(offset, endian); - phdr.p_paddr = cpu_convert_to_target64(memory_mapping->phys_addr, endian); - phdr.p_filesz = cpu_convert_to_target64(filesz, endian); - phdr.p_memsz = cpu_convert_to_target64(memory_mapping->length, endian); - phdr.p_vaddr = cpu_convert_to_target64(memory_mapping->virt_addr, endian); + 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); assert(memory_mapping->length >= filesz); ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s); if (ret < 0) { - dump_error(s, "dump: failed to write program header table.\n"); - return -1; + dump_error(s, "dump: failed to write program header table", errp); } - - return 0; } -static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping, - int phdr_index, hwaddr offset, - hwaddr filesz) +static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping, + int phdr_index, hwaddr offset, + hwaddr filesz, Error **errp) { Elf32_Phdr phdr; int ret; - int endian = s->dump_info.d_endian; memset(&phdr, 0, sizeof(Elf32_Phdr)); - phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian); - phdr.p_offset = cpu_convert_to_target32(offset, endian); - phdr.p_paddr = cpu_convert_to_target32(memory_mapping->phys_addr, endian); - phdr.p_filesz = cpu_convert_to_target32(filesz, endian); - phdr.p_memsz = cpu_convert_to_target32(memory_mapping->length, endian); - phdr.p_vaddr = cpu_convert_to_target32(memory_mapping->virt_addr, endian); + 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); assert(memory_mapping->length >= filesz); ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s); if (ret < 0) { - dump_error(s, "dump: failed to write program header table.\n"); - return -1; + dump_error(s, "dump: failed to write program header table", errp); } - - return 0; } -static int write_elf64_note(DumpState *s) +static void write_elf64_note(DumpState *s, Error **errp) { Elf64_Phdr phdr; - int endian = s->dump_info.d_endian; hwaddr begin = s->memory_offset - s->note_size; int ret; memset(&phdr, 0, sizeof(Elf64_Phdr)); - phdr.p_type = cpu_convert_to_target32(PT_NOTE, endian); - phdr.p_offset = cpu_convert_to_target64(begin, endian); + 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_convert_to_target64(s->note_size, endian); - phdr.p_memsz = cpu_convert_to_target64(s->note_size, endian); + 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) { - dump_error(s, "dump: failed to write program header table.\n"); - return -1; + dump_error(s, "dump: failed to write program header table", errp); } - - return 0; } static inline int cpu_index(CPUState *cpu) @@ -295,7 +233,8 @@ static inline int cpu_index(CPUState *cpu) return cpu->cpu_index + 1; } -static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s) +static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s, + Error **errp) { CPUState *cpu; int ret; @@ -305,47 +244,42 @@ static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s) id = cpu_index(cpu); ret = cpu_write_elf64_note(f, cpu, id, s); if (ret < 0) { - dump_error(s, "dump: failed to write elf notes.\n"); - return -1; + dump_error(s, "dump: failed to write elf notes", errp); + return; } } CPU_FOREACH(cpu) { ret = cpu_write_elf64_qemunote(f, cpu, s); if (ret < 0) { - dump_error(s, "dump: failed to write CPU status.\n"); - return -1; + dump_error(s, "dump: failed to write CPU status", errp); + return; } } - - return 0; } -static int write_elf32_note(DumpState *s) +static void write_elf32_note(DumpState *s, Error **errp) { hwaddr begin = s->memory_offset - s->note_size; Elf32_Phdr phdr; - int endian = s->dump_info.d_endian; int ret; memset(&phdr, 0, sizeof(Elf32_Phdr)); - phdr.p_type = cpu_convert_to_target32(PT_NOTE, endian); - phdr.p_offset = cpu_convert_to_target32(begin, endian); + 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_convert_to_target32(s->note_size, endian); - phdr.p_memsz = cpu_convert_to_target32(s->note_size, endian); + 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) { - dump_error(s, "dump: failed to write program header table.\n"); - return -1; + dump_error(s, "dump: failed to write program header table", errp); } - - return 0; } -static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s) +static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s, + Error **errp) { CPUState *cpu; int ret; @@ -355,27 +289,24 @@ static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s) id = cpu_index(cpu); ret = cpu_write_elf32_note(f, cpu, id, s); if (ret < 0) { - dump_error(s, "dump: failed to write elf notes.\n"); - return -1; + dump_error(s, "dump: failed to write elf notes", errp); + return; } } CPU_FOREACH(cpu) { ret = cpu_write_elf32_qemunote(f, cpu, s); if (ret < 0) { - dump_error(s, "dump: failed to write CPU status.\n"); - return -1; + dump_error(s, "dump: failed to write CPU status", errp); + return; } } - - return 0; } -static int write_elf_section(DumpState *s, int type) +static void write_elf_section(DumpState *s, int type, Error **errp) { Elf32_Shdr shdr32; Elf64_Shdr shdr64; - int endian = s->dump_info.d_endian; int shdr_size; void *shdr; int ret; @@ -383,61 +314,55 @@ static int write_elf_section(DumpState *s, int type) if (type == 0) { shdr_size = sizeof(Elf32_Shdr); memset(&shdr32, 0, shdr_size); - shdr32.sh_info = cpu_convert_to_target32(s->sh_info, endian); + 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_convert_to_target32(s->sh_info, endian); + shdr64.sh_info = cpu_to_dump32(s, s->sh_info); shdr = &shdr64; } ret = fd_write_vmcore(&shdr, shdr_size, s); if (ret < 0) { - dump_error(s, "dump: failed to write section header table.\n"); - return -1; + dump_error(s, "dump: failed to write section header table", errp); } - - return 0; } -static int write_data(DumpState *s, void *buf, int length) +static void write_data(DumpState *s, void *buf, int length, Error **errp) { int ret; ret = fd_write_vmcore(buf, length, s); if (ret < 0) { - dump_error(s, "dump: failed to save memory.\n"); - return -1; + dump_error(s, "dump: failed to save memory", errp); } - - return 0; } -/* write the memroy to vmcore. 1 page per I/O. */ -static int write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start, - int64_t size) +/* 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; - int ret; + Error *local_err = NULL; for (i = 0; i < size / TARGET_PAGE_SIZE; i++) { - ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE, - TARGET_PAGE_SIZE); - if (ret < 0) { - return ret; + write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE, + TARGET_PAGE_SIZE, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } } if ((size % TARGET_PAGE_SIZE) != 0) { - ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE, - size % TARGET_PAGE_SIZE); - if (ret < 0) { - return ret; + write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE, + size % TARGET_PAGE_SIZE, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } } - - return 0; } /* get the memory's offset and size in the vmcore */ @@ -502,13 +427,13 @@ static void get_offset_range(hwaddr phys_addr, } } -static int write_elf_loads(DumpState *s) +static void write_elf_loads(DumpState *s, Error **errp) { hwaddr offset, filesz; MemoryMapping *memory_mapping; uint32_t phdr_index = 1; - int ret; uint32_t max_index; + Error *local_err = NULL; if (s->have_section) { max_index = s->sh_info; @@ -521,29 +446,28 @@ static int write_elf_loads(DumpState *s) memory_mapping->length, s, &offset, &filesz); if (s->dump_info.d_class == ELFCLASS64) { - ret = write_elf64_load(s, memory_mapping, phdr_index++, offset, - filesz); + write_elf64_load(s, memory_mapping, phdr_index++, offset, + filesz, &local_err); } else { - ret = write_elf32_load(s, memory_mapping, phdr_index++, offset, - filesz); + write_elf32_load(s, memory_mapping, phdr_index++, offset, + filesz, &local_err); } - if (ret < 0) { - return -1; + if (local_err) { + error_propagate(errp, local_err); + return; } if (phdr_index >= max_index) { break; } } - - return 0; } /* write elf header, PT_NOTE and elf note to vmcore. */ -static int dump_begin(DumpState *s) +static void dump_begin(DumpState *s, Error **errp) { - int ret; + Error *local_err = NULL; /* * the vmcore's format is: @@ -571,69 +495,81 @@ static int dump_begin(DumpState *s) /* write elf header to vmcore */ if (s->dump_info.d_class == ELFCLASS64) { - ret = write_elf64_header(s); + write_elf64_header(s, &local_err); } else { - ret = write_elf32_header(s); + write_elf32_header(s, &local_err); } - if (ret < 0) { - return -1; + if (local_err) { + error_propagate(errp, local_err); + return; } if (s->dump_info.d_class == ELFCLASS64) { /* write PT_NOTE to vmcore */ - if (write_elf64_note(s) < 0) { - return -1; + write_elf64_note(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } /* write all PT_LOAD to vmcore */ - if (write_elf_loads(s) < 0) { - return -1; + write_elf_loads(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } /* write section to vmcore */ if (s->have_section) { - if (write_elf_section(s, 1) < 0) { - return -1; + write_elf_section(s, 1, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } } /* write notes to vmcore */ - if (write_elf64_notes(fd_write_vmcore, s) < 0) { - return -1; + write_elf64_notes(fd_write_vmcore, s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } - } else { /* write PT_NOTE to vmcore */ - if (write_elf32_note(s) < 0) { - return -1; + write_elf32_note(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } /* write all PT_LOAD to vmcore */ - if (write_elf_loads(s) < 0) { - return -1; + write_elf_loads(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } /* write section to vmcore */ if (s->have_section) { - if (write_elf_section(s, 0) < 0) { - return -1; + write_elf_section(s, 0, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } } /* write notes to vmcore */ - if (write_elf32_notes(fd_write_vmcore, s) < 0) { - return -1; + write_elf32_notes(fd_write_vmcore, s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } } - - return 0; } -/* write PT_LOAD to vmcore */ -static int dump_completed(DumpState *s) +static void dump_completed(DumpState *s) { dump_cleanup(s); - return 0; } static int get_next_block(DumpState *s, GuestPhysBlock *block) @@ -664,13 +600,13 @@ static int get_next_block(DumpState *s, GuestPhysBlock *block) } /* write all memory to vmcore */ -static int dump_iterate(DumpState *s) +static void dump_iterate(DumpState *s, Error **errp) { GuestPhysBlock *block; int64_t size; - int ret; + Error *local_err = NULL; - while (1) { + do { block = s->next_block; size = block->target_end - block->target_start; @@ -680,59 +616,51 @@ static int dump_iterate(DumpState *s) size -= block->target_end - (s->begin + s->length); } } - ret = write_memory(s, block, s->start, size); - if (ret == -1) { - return ret; + write_memory(s, block, s->start, size, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } - ret = get_next_block(s, block); - if (ret == 1) { - dump_completed(s); - return 0; - } - } + } while (!get_next_block(s, block)); + + dump_completed(s); } -static int create_vmcore(DumpState *s) +static void create_vmcore(DumpState *s, Error **errp) { - int ret; + Error *local_err = NULL; - ret = dump_begin(s); - if (ret < 0) { - return -1; - } - - ret = dump_iterate(s); - if (ret < 0) { - return -1; + dump_begin(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } - return 0; + dump_iterate(s, errp); } static int write_start_flat_header(int fd) { - uint8_t *buf; - MakedumpfileHeader mh; + MakedumpfileHeader *mh; int ret = 0; - memset(&mh, 0, sizeof(mh)); - strncpy(mh.signature, MAKEDUMPFILE_SIGNATURE, - strlen(MAKEDUMPFILE_SIGNATURE)); + QEMU_BUILD_BUG_ON(sizeof *mh > MAX_SIZE_MDF_HEADER); + mh = g_malloc0(MAX_SIZE_MDF_HEADER); - mh.type = cpu_to_be64(TYPE_FLAT_HEADER); - mh.version = cpu_to_be64(VERSION_FLAT_HEADER); + memcpy(mh->signature, MAKEDUMPFILE_SIGNATURE, + MIN(sizeof mh->signature, sizeof MAKEDUMPFILE_SIGNATURE)); - buf = g_malloc0(MAX_SIZE_MDF_HEADER); - memcpy(buf, &mh, sizeof(mh)); + 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, buf, MAX_SIZE_MDF_HEADER); + written_size = qemu_write_full(fd, mh, MAX_SIZE_MDF_HEADER); if (written_size != MAX_SIZE_MDF_HEADER) { ret = -1; } - g_free(buf); + g_free(mh); return ret; } @@ -790,36 +718,34 @@ static int buf_write_note(const void *buf, size_t size, void *opaque) } /* write common header, sub header and elf note to vmcore */ -static int create_header32(DumpState *s) +static void create_header32(DumpState *s, Error **errp) { - int ret = 0; DiskDumpHeader32 *dh = NULL; KdumpSubHeader32 *kh = NULL; size_t size; - int endian = s->dump_info.d_endian; 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); strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE)); - dh->header_version = cpu_convert_to_target32(6, endian); - block_size = s->page_size; - dh->block_size = cpu_convert_to_target32(block_size, endian); + dh->header_version = cpu_to_dump32(s, 6); + block_size = TARGET_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_convert_to_target32(sub_hdr_size, endian); + 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_convert_to_target32(MIN(s->max_mapnr, UINT_MAX), - endian); - dh->nr_cpus = cpu_convert_to_target32(s->nr_cpus, endian); + 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_convert_to_target32(bitmap_blocks, endian); + 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) { @@ -835,11 +761,10 @@ static int create_header32(DumpState *s) status |= DUMP_DH_COMPRESSED_SNAPPY; } #endif - dh->status = cpu_convert_to_target32(status, endian); + dh->status = cpu_to_dump32(s, status); if (write_buffer(s->fd, 0, dh, size) < 0) { - dump_error(s, "dump: failed to write disk dump header.\n"); - ret = -1; + dump_error(s, "dump: failed to write disk dump header", errp); goto out; } @@ -848,18 +773,17 @@ static int create_header32(DumpState *s) kh = g_malloc0(size); /* 64bit max_mapnr_64 */ - kh->max_mapnr_64 = cpu_convert_to_target64(s->max_mapnr, endian); - kh->phys_base = cpu_convert_to_target32(PHYS_BASE, endian); - kh->dump_level = cpu_convert_to_target32(DUMP_LEVEL, endian); + kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr); + kh->phys_base = cpu_to_dump32(s, PHYS_BASE); + kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL); offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size; - kh->offset_note = cpu_convert_to_target64(offset_note, endian); - kh->note_size = cpu_convert_to_target32(s->note_size, endian); + 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) { - dump_error(s, "dump: failed to write kdump sub header.\n"); - ret = -1; + dump_error(s, "dump: failed to write kdump sub header", errp); goto out; } @@ -868,15 +792,14 @@ static int create_header32(DumpState *s) s->note_buf_offset = 0; /* use s->note_buf to store notes temporarily */ - if (write_elf32_notes(buf_write_note, s) < 0) { - ret = -1; + 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) { - dump_error(s, "dump: failed to write notes"); - ret = -1; + dump_error(s, "dump: failed to write notes", errp); goto out; } @@ -892,41 +815,37 @@ out: g_free(dh); g_free(kh); g_free(s->note_buf); - - return ret; } /* write common header, sub header and elf note to vmcore */ -static int create_header64(DumpState *s) +static void create_header64(DumpState *s, Error **errp) { - int ret = 0; DiskDumpHeader64 *dh = NULL; KdumpSubHeader64 *kh = NULL; size_t size; - int endian = s->dump_info.d_endian; 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); strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE)); - dh->header_version = cpu_convert_to_target32(6, endian); - block_size = s->page_size; - dh->block_size = cpu_convert_to_target32(block_size, endian); + dh->header_version = cpu_to_dump32(s, 6); + block_size = TARGET_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_convert_to_target32(sub_hdr_size, endian); + 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_convert_to_target32(MIN(s->max_mapnr, UINT_MAX), - endian); - dh->nr_cpus = cpu_convert_to_target32(s->nr_cpus, endian); + 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_convert_to_target32(bitmap_blocks, endian); + 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) { @@ -942,11 +861,10 @@ static int create_header64(DumpState *s) status |= DUMP_DH_COMPRESSED_SNAPPY; } #endif - dh->status = cpu_convert_to_target32(status, endian); + dh->status = cpu_to_dump32(s, status); if (write_buffer(s->fd, 0, dh, size) < 0) { - dump_error(s, "dump: failed to write disk dump header.\n"); - ret = -1; + dump_error(s, "dump: failed to write disk dump header", errp); goto out; } @@ -955,18 +873,17 @@ static int create_header64(DumpState *s) kh = g_malloc0(size); /* 64bit max_mapnr_64 */ - kh->max_mapnr_64 = cpu_convert_to_target64(s->max_mapnr, endian); - kh->phys_base = cpu_convert_to_target64(PHYS_BASE, endian); - kh->dump_level = cpu_convert_to_target32(DUMP_LEVEL, endian); + kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr); + kh->phys_base = cpu_to_dump64(s, PHYS_BASE); + kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL); offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size; - kh->offset_note = cpu_convert_to_target64(offset_note, endian); - kh->note_size = cpu_convert_to_target64(s->note_size, endian); + 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) { - dump_error(s, "dump: failed to write kdump sub header.\n"); - ret = -1; + dump_error(s, "dump: failed to write kdump sub header", errp); goto out; } @@ -975,15 +892,15 @@ static int create_header64(DumpState *s) s->note_buf_offset = 0; /* use s->note_buf to store notes temporarily */ - if (write_elf64_notes(buf_write_note, s) < 0) { - ret = -1; + 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) { - dump_error(s, "dump: failed to write notes"); - ret = -1; + dump_error(s, "dump: failed to write notes", errp); goto out; } @@ -999,16 +916,19 @@ out: g_free(dh); g_free(kh); g_free(s->note_buf); - - return ret; } -static int write_dump_header(DumpState *s) +static void write_dump_header(DumpState *s, Error **errp) { - if (s->dump_info.d_machine == EM_386) { - return create_header32(s); + Error *local_err = NULL; + + if (s->dump_info.d_class == ELFCLASS32) { + create_header32(s, &local_err); } else { - return create_header64(s); + create_header64(s, &local_err); + } + if (local_err) { + error_propagate(errp, local_err); } } @@ -1087,9 +1007,9 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr, if (!block) { block = QTAILQ_FIRST(&s->guest_phys_blocks.head); *blockptr = block; - assert(block->target_start % s->page_size == 0); - assert(block->target_end % s->page_size == 0); - *pfnptr = paddr_to_pfn(block->target_start, s->page_shift); + assert((block->target_start & ~TARGET_PAGE_MASK) == 0); + assert((block->target_end & ~TARGET_PAGE_MASK) == 0); + *pfnptr = paddr_to_pfn(block->target_start); if (bufptr) { *bufptr = block->host_addr; } @@ -1097,10 +1017,10 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr, } *pfnptr = *pfnptr + 1; - addr = pfn_to_paddr(*pfnptr, s->page_shift); + addr = pfn_to_paddr(*pfnptr); if ((addr >= block->target_start) && - (addr + s->page_size <= block->target_end)) { + (addr + TARGET_PAGE_SIZE <= block->target_end)) { buf = block->host_addr + (addr - block->target_start); } else { /* the next page is in the next block */ @@ -1109,9 +1029,9 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr, if (!block) { return false; } - assert(block->target_start % s->page_size == 0); - assert(block->target_end % s->page_size == 0); - *pfnptr = paddr_to_pfn(block->target_start, s->page_shift); + assert((block->target_start & ~TARGET_PAGE_MASK) == 0); + assert((block->target_end & ~TARGET_PAGE_MASK) == 0); + *pfnptr = paddr_to_pfn(block->target_start); buf = block->host_addr; } @@ -1122,7 +1042,7 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr, return true; } -static int write_dump_bitmap(DumpState *s) +static void write_dump_bitmap(DumpState *s, Error **errp) { int ret = 0; uint64_t last_pfn, pfn; @@ -1143,8 +1063,7 @@ static int write_dump_bitmap(DumpState *s) while (get_next_page(&block_iter, &pfn, NULL, s)) { ret = set_dump_bitmap(last_pfn, pfn, true, dump_bitmap_buf, s); if (ret < 0) { - dump_error(s, "dump: failed to set dump_bitmap.\n"); - ret = -1; + dump_error(s, "dump: failed to set dump_bitmap", errp); goto out; } @@ -1161,8 +1080,7 @@ static int write_dump_bitmap(DumpState *s) ret = set_dump_bitmap(last_pfn, last_pfn + PFN_BUFBITMAP, false, dump_bitmap_buf, s); if (ret < 0) { - dump_error(s, "dump: failed to sync dump_bitmap.\n"); - ret = -1; + dump_error(s, "dump: failed to sync dump_bitmap", errp); goto out; } } @@ -1172,8 +1090,6 @@ static int write_dump_bitmap(DumpState *s) out: g_free(dump_bitmap_buf); - - return ret; } static void prepare_data_cache(DataCache *data_cache, DumpState *s, @@ -1225,42 +1141,24 @@ static void free_data_cache(DataCache *data_cache) static size_t get_len_buf_out(size_t page_size, uint32_t flag_compress) { - size_t len_buf_out_zlib, len_buf_out_lzo, len_buf_out_snappy; - size_t len_buf_out; - - /* init buf_out */ - len_buf_out_zlib = len_buf_out_lzo = len_buf_out_snappy = 0; - - /* buf size for zlib */ - len_buf_out_zlib = compressBound(page_size); - - /* buf size for lzo */ -#ifdef CONFIG_LZO - if (flag_compress & DUMP_DH_COMPRESSED_LZO) { - if (lzo_init() != LZO_E_OK) { - /* return 0 to indicate lzo is unavailable */ - return 0; - } - } - - /* - * 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 - */ - len_buf_out_lzo = page_size + page_size / 16 + 64 + 3; -#endif + 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 - /* buf size for snappy */ - len_buf_out_snappy = snappy_max_compressed_length(page_size); + case DUMP_DH_COMPRESSED_SNAPPY: + return snappy_max_compressed_length(page_size); #endif - - /* get the biggest that can store all kinds of compressed page */ - len_buf_out = MAX(len_buf_out_zlib, - MAX(len_buf_out_lzo, len_buf_out_snappy)); - - return len_buf_out; + } + return 0; } /* @@ -1271,7 +1169,7 @@ static inline bool is_zero_page(const uint8_t *buf, size_t page_size) return buffer_is_zero(buf, page_size); } -static int write_dump_pages(DumpState *s) +static void write_dump_pages(DumpState *s, Error **errp) { int ret = 0; DataCache page_desc, page_data; @@ -1283,7 +1181,6 @@ static int write_dump_pages(DumpState *s) off_t offset_desc, offset_data; PageDescriptor pd, pd_zero; uint8_t *buf; - int endian = s->dump_info.d_endian; GuestPhysBlock *block_iter = NULL; uint64_t pfn_iter; @@ -1295,11 +1192,8 @@ static int write_dump_pages(DumpState *s) prepare_data_cache(&page_data, s, offset_data); /* prepare buffer to store compressed data */ - len_buf_out = get_len_buf_out(s->page_size, s->flag_compress); - if (len_buf_out == 0) { - dump_error(s, "dump: failed to get length of output buffer.\n"); - goto out; - } + len_buf_out = get_len_buf_out(TARGET_PAGE_SIZE, s->flag_compress); + assert(len_buf_out != 0); #ifdef CONFIG_LZO wrkmem = g_malloc(LZO1X_1_MEM_COMPRESS); @@ -1311,19 +1205,19 @@ static int write_dump_pages(DumpState *s) * init zero page's page_desc and page_data, because every zero page * uses the same page_data */ - pd_zero.size = cpu_convert_to_target32(s->page_size, endian); - pd_zero.flags = cpu_convert_to_target32(0, endian); - pd_zero.offset = cpu_convert_to_target64(offset_data, endian); - pd_zero.page_flags = cpu_convert_to_target64(0, endian); - buf = g_malloc0(s->page_size); - ret = write_cache(&page_data, buf, s->page_size, false); + pd_zero.size = cpu_to_dump32(s, TARGET_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(TARGET_PAGE_SIZE); + ret = write_cache(&page_data, buf, TARGET_PAGE_SIZE, false); g_free(buf); if (ret < 0) { - dump_error(s, "dump: failed to write page data(zero page).\n"); + dump_error(s, "dump: failed to write page data (zero page)", errp); goto out; } - offset_data += s->page_size; + offset_data += TARGET_PAGE_SIZE; /* * dump memory to vmcore page by page. zero page will all be resided in the @@ -1331,11 +1225,11 @@ static int write_dump_pages(DumpState *s) */ while (get_next_page(&block_iter, &pfn_iter, &buf, s)) { /* check zero page */ - if (is_zero_page(buf, s->page_size)) { + if (is_zero_page(buf, TARGET_PAGE_SIZE)) { ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor), false); if (ret < 0) { - dump_error(s, "dump: failed to write page desc.\n"); + dump_error(s, "dump: failed to write page desc", errp); goto out; } } else { @@ -1352,71 +1246,69 @@ static int write_dump_pages(DumpState *s) */ size_out = len_buf_out; if ((s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) && - (compress2(buf_out, (uLongf *)&size_out, buf, s->page_size, - Z_BEST_SPEED) == Z_OK) && (size_out < s->page_size)) { - pd.flags = cpu_convert_to_target32(DUMP_DH_COMPRESSED_ZLIB, - endian); - pd.size = cpu_convert_to_target32(size_out, endian); + (compress2(buf_out, (uLongf *)&size_out, buf, + TARGET_PAGE_SIZE, Z_BEST_SPEED) == Z_OK) && + (size_out < TARGET_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) { - dump_error(s, "dump: failed to write page data.\n"); + dump_error(s, "dump: failed to write page data", errp); goto out; } #ifdef CONFIG_LZO } else if ((s->flag_compress & DUMP_DH_COMPRESSED_LZO) && - (lzo1x_1_compress(buf, s->page_size, buf_out, + (lzo1x_1_compress(buf, TARGET_PAGE_SIZE, buf_out, (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) && - (size_out < s->page_size)) { - pd.flags = cpu_convert_to_target32(DUMP_DH_COMPRESSED_LZO, - endian); - pd.size = cpu_convert_to_target32(size_out, endian); + (size_out < TARGET_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) { - dump_error(s, "dump: failed to write page data.\n"); + dump_error(s, "dump: failed to write page data", errp); goto out; } #endif #ifdef CONFIG_SNAPPY } else if ((s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) && - (snappy_compress((char *)buf, s->page_size, + (snappy_compress((char *)buf, TARGET_PAGE_SIZE, (char *)buf_out, &size_out) == SNAPPY_OK) && - (size_out < s->page_size)) { - pd.flags = cpu_convert_to_target32( - DUMP_DH_COMPRESSED_SNAPPY, endian); - pd.size = cpu_convert_to_target32(size_out, endian); + (size_out < TARGET_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) { - dump_error(s, "dump: failed to write page data.\n"); + dump_error(s, "dump: failed to write page data", errp); goto out; } #endif } else { /* * fall back to save in plaintext, size_out should be - * assigned to s->page_size + * assigned TARGET_PAGE_SIZE */ - pd.flags = cpu_convert_to_target32(0, endian); - size_out = s->page_size; - pd.size = cpu_convert_to_target32(size_out, endian); + pd.flags = cpu_to_dump32(s, 0); + size_out = TARGET_PAGE_SIZE; + pd.size = cpu_to_dump32(s, size_out); - ret = write_cache(&page_data, buf, s->page_size, false); + ret = write_cache(&page_data, buf, TARGET_PAGE_SIZE, false); if (ret < 0) { - dump_error(s, "dump: failed to write page data.\n"); + dump_error(s, "dump: failed to write page data", errp); goto out; } } /* get and write page desc here */ - pd.page_flags = cpu_convert_to_target64(0, endian); - pd.offset = cpu_convert_to_target64(offset_data, endian); + 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) { - dump_error(s, "dump: failed to write page desc.\n"); + dump_error(s, "dump: failed to write page desc", errp); goto out; } } @@ -1424,12 +1316,12 @@ static int write_dump_pages(DumpState *s) ret = write_cache(&page_desc, NULL, 0, true); if (ret < 0) { - dump_error(s, "dump: failed to sync cache for page_desc.\n"); + dump_error(s, "dump: failed to sync cache for page_desc", errp); goto out; } ret = write_cache(&page_data, NULL, 0, true); if (ret < 0) { - dump_error(s, "dump: failed to sync cache for page_data.\n"); + dump_error(s, "dump: failed to sync cache for page_data", errp); goto out; } @@ -1442,13 +1334,12 @@ out: #endif g_free(buf_out); - - return ret; } -static int create_kdump_vmcore(DumpState *s) +static void create_kdump_vmcore(DumpState *s, Error **errp) { int ret; + Error *local_err = NULL; /* * the kdump-compressed format is: @@ -1474,34 +1365,35 @@ static int create_kdump_vmcore(DumpState *s) ret = write_start_flat_header(s->fd); if (ret < 0) { - dump_error(s, "dump: failed to write start flat header.\n"); - return -1; + dump_error(s, "dump: failed to write start flat header", errp); + return; } - ret = write_dump_header(s); - if (ret < 0) { - return -1; + write_dump_header(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } - ret = write_dump_bitmap(s); - if (ret < 0) { - return -1; + write_dump_bitmap(s, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; } - ret = write_dump_pages(s); - if (ret < 0) { - return -1; + 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) { - dump_error(s, "dump: failed to write end flat header.\n"); - return -1; + dump_error(s, "dump: failed to write end flat header", errp); + return; } dump_completed(s); - - return 0; } static ram_addr_t get_start_block(DumpState *s) @@ -1537,12 +1429,12 @@ static void get_max_mapnr(DumpState *s) GuestPhysBlock *last_block; last_block = QTAILQ_LAST(&s->guest_phys_blocks.head, GuestPhysBlockHead); - s->max_mapnr = paddr_to_pfn(last_block->target_end, s->page_shift); + s->max_mapnr = paddr_to_pfn(last_block->target_end); } -static int dump_init(DumpState *s, int fd, bool has_format, - DumpGuestMemoryFormat format, bool paging, bool has_filter, - int64_t begin, int64_t length, Error **errp) +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) { CPUState *cpu; int nr_cpus; @@ -1570,12 +1462,13 @@ static int dump_init(DumpState *s, int fd, bool has_format, nr_cpus++; } - s->errp = errp; 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); @@ -1603,7 +1496,6 @@ static int dump_init(DumpState *s, int fd, bool has_format, } /* get memory mapping */ - memory_mapping_list_init(&s->list); if (paging) { qemu_get_guest_memory_mapping(&s->list, &s->guest_phys_blocks, &err); if (err != NULL) { @@ -1615,14 +1507,12 @@ static int dump_init(DumpState *s, int fd, bool has_format, } s->nr_cpus = nr_cpus; - s->page_size = TARGET_PAGE_SIZE; - s->page_shift = ffs(s->page_size) - 1; get_max_mapnr(s); uint64_t tmp; - tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT), s->page_size); - s->len_dump_bitmap = tmp * s->page_size; + tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT), TARGET_PAGE_SIZE); + s->len_dump_bitmap = tmp * TARGET_PAGE_SIZE; /* init for kdump-compressed format */ if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) { @@ -1632,6 +1522,12 @@ static int dump_init(DumpState *s, int fd, bool has_format, 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; @@ -1643,7 +1539,7 @@ static int dump_init(DumpState *s, int fd, bool has_format, s->flag_compress = 0; } - return 0; + return; } if (s->has_filter) { @@ -1692,16 +1588,10 @@ static int dump_init(DumpState *s, int fd, bool has_format, } } - return 0; + return; cleanup: - guest_phys_blocks_free(&s->guest_phys_blocks); - - if (s->resume) { - vm_start(); - } - - return -1; + dump_cleanup(s); } void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin, @@ -1712,7 +1602,7 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin, const char *p; int fd = -1; DumpState *s; - int ret; + Error *local_err = NULL; /* * kdump-compressed format need the whole memory dumped, so paging or @@ -1772,21 +1662,18 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin, s = g_malloc0(sizeof(DumpState)); - ret = dump_init(s, fd, has_format, format, paging, has_begin, - begin, length, errp); - if (ret < 0) { + dump_init(s, fd, has_format, format, paging, has_begin, + begin, length, &local_err); + if (local_err) { g_free(s); + error_propagate(errp, local_err); return; } if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) { - if (create_kdump_vmcore(s) < 0 && !error_is_set(s->errp)) { - error_set(errp, QERR_IO_ERROR); - } + create_kdump_vmcore(s, errp); } else { - if (create_vmcore(s) < 0 && !error_is_set(s->errp)) { - error_set(errp, QERR_IO_ERROR); - } + create_vmcore(s, errp); } g_free(s);