From 36cd1b1bdc56da8e18d69df82731fb79a2ed01dd Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= <marcandre.lureau@redhat.com>

Date: Wed, 13 Dec 2017 13:38:47 +0100

Subject: [PATCH 16/41] dump: Make DumpState and endian conversion routines

 available for arch-specific dump code

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

RH-Author: Marc-André Lureau <marcandre.lureau@redhat.com>

Message-id: <20171213133912.26176-17-marcandre.lureau@redhat.com>

Patchwork-id: 78366

O-Subject: [RHEL-7.5 qemu-kvm PATCH v3 16/41] dump: Make DumpState and endian conversion routines available for arch-specific dump code

Bugzilla: 1411490

RH-Acked-by: Laszlo Ersek <lersek@redhat.com>

RH-Acked-by: Michael S. Tsirkin <mst@redhat.com>

RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>

From: Bharata B Rao <bharata@linux.vnet.ibm.com>

Make DumpState and endian conversion routines available for arch-specific dump

code by moving into dump.h. DumpState will be needed by arch-specific dump

code to access target endian information from DumpState->ArchDumpInfo. Also

break the dependency of dump.h from stubs/dump.c by creating a separate

dump-arch.h.

This patch doesn't change any functionality.

Signed-off-by: Bharata B Rao <bharata@linux.ibm.com>

[ rebased on top of current master branch,

  renamed endian helpers to cpu_to_dump{16,32,64},

  pass a DumpState * argument to endian helpers,

  Greg Kurz <gkurz@linux.vnet.ibm.com> ]

Signed-off-by: Greg Kurz <gkurz@linux.vnet.ibm.com>

[agraf: fix to apply]

Signed-off-by: Alexander Graf <agraf@suse.de>

(cherry picked from commit acb0ef5801fc0caafdcfd34ae62e48d276866a1b)

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 dump.c                     | 231 ++++++++++++++++++---------------------------

 include/sysemu/dump-arch.h |  28 ++++++

 include/sysemu/dump.h      |  45 +++++++--

 stubs/dump.c               |   2 +-

 4 files changed, 154 insertions(+), 152 deletions(-)

 create mode 100644 include/sysemu/dump-arch.h

diff --git a/dump.c b/dump.c

index e9bd237..c902944 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,36 +69,6 @@ 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;

-

-    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 */

-    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;

@@ -137,29 +107,25 @@ static int write_elf64_header(DumpState *s)

 {

     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);

@@ -175,29 +141,25 @@ static int write_elf32_header(DumpState *s)

 {

     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);

@@ -215,15 +177,14 @@ static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,

 {

     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);

@@ -242,15 +203,14 @@ static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,

 {

     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);

@@ -266,16 +226,15 @@ static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,

 static int write_elf64_note(DumpState *s)

 {

     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);

@@ -325,15 +284,14 @@ static int write_elf32_note(DumpState *s)

 {

     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);

@@ -378,7 +336,6 @@ static int write_elf_section(DumpState *s, int type)

 {

     Elf32_Shdr shdr32;

     Elf64_Shdr shdr64;

-    int endian = s->dump_info.d_endian;

     int shdr_size;

     void *shdr;

     int ret;

@@ -386,12 +343,12 @@ 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;

     }

@@ -797,7 +754,6 @@ static int create_header32(DumpState *s)

     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;

@@ -809,18 +765,17 @@ static int create_header32(DumpState *s)

     dh = g_malloc0(size);

     strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE));

-    dh->header_version = cpu_convert_to_target32(6, endian);

+    dh->header_version = cpu_to_dump32(s, 6);

     block_size = TARGET_PAGE_SIZE;

-    dh->block_size = cpu_convert_to_target32(block_size, endian);

+    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) {

@@ -836,7 +791,7 @@ 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");

@@ -849,13 +804,13 @@ 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) {

@@ -904,7 +859,6 @@ static int create_header64(DumpState *s)

     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;

@@ -916,18 +870,17 @@ static int create_header64(DumpState *s)

     dh = g_malloc0(size);

     strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE));

-    dh->header_version = cpu_convert_to_target32(6, endian);

+    dh->header_version = cpu_to_dump32(s, 6);

     block_size = TARGET_PAGE_SIZE;

-    dh->block_size = cpu_convert_to_target32(block_size, endian);

+    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) {

@@ -943,7 +896,7 @@ 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");

@@ -956,13 +909,13 @@ 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) {

@@ -1266,7 +1219,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;

@@ -1291,10 +1243,10 @@ 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(TARGET_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);

+    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);

@@ -1332,12 +1284,11 @@ 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,

-                            TARGET_PAGE_SIZE, Z_BEST_SPEED) == Z_OK) &&

-                 (size_out < TARGET_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) {

@@ -1349,9 +1300,8 @@ static int write_dump_pages(DumpState *s)

                     (lzo1x_1_compress(buf, TARGET_PAGE_SIZE, buf_out,

                     (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) &&

                     (size_out < TARGET_PAGE_SIZE)) {

-                pd.flags = cpu_convert_to_target32(DUMP_DH_COMPRESSED_LZO,

-                                                   endian);

-                pd.size  = cpu_convert_to_target32(size_out, endian);

+                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) {

@@ -1364,9 +1314,8 @@ static int write_dump_pages(DumpState *s)

                     (snappy_compress((char *)buf, TARGET_PAGE_SIZE,

                     (char *)buf_out, &size_out) == SNAPPY_OK) &&

                     (size_out < TARGET_PAGE_SIZE)) {

-                pd.flags = cpu_convert_to_target32(

-                                        DUMP_DH_COMPRESSED_SNAPPY, endian);

-                pd.size  = cpu_convert_to_target32(size_out, endian);

+                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) {

@@ -1379,9 +1328,9 @@ static int write_dump_pages(DumpState *s)

                  * fall back to save in plaintext, size_out should be

                  * assigned TARGET_PAGE_SIZE

                  */

-                pd.flags = cpu_convert_to_target32(0, endian);

+                pd.flags = cpu_to_dump32(s, 0);

                 size_out = TARGET_PAGE_SIZE;

-                pd.size = cpu_convert_to_target32(size_out, endian);

+                pd.size = cpu_to_dump32(s, size_out);

                 ret = write_cache(&page_data, buf, TARGET_PAGE_SIZE, false);

                 if (ret < 0) {

@@ -1391,8 +1340,8 @@ static int write_dump_pages(DumpState *s)

             }

             /* 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);

diff --git a/include/sysemu/dump-arch.h b/include/sysemu/dump-arch.h

new file mode 100644

index 0000000..9c95ced

--- /dev/null

+++ b/include/sysemu/dump-arch.h

@@ -0,0 +1,28 @@

+/*

+ * 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.

+ *

+ */

+

+#ifndef DUMP_ARCH_H

+#define DUMP_ARCH_H

+

+typedef struct ArchDumpInfo {

+    int d_machine;  /* Architecture */

+    int d_endian;   /* ELFDATA2LSB or ELFDATA2MSB */

+    int d_class;    /* ELFCLASS32 or ELFCLASS64 */

+} ArchDumpInfo;

+

+struct GuestPhysBlockList; /* memory_mapping.h */

+int cpu_get_dump_info(ArchDumpInfo *info,

+                      const struct GuestPhysBlockList *guest_phys_blocks);

+ssize_t cpu_get_note_size(int class, int machine, int nr_cpus);

+

+#endif

diff --git a/include/sysemu/dump.h b/include/sysemu/dump.h

index 12af557..7e4ec5c 100644

--- a/include/sysemu/dump.h

+++ b/include/sysemu/dump.h

@@ -43,11 +43,8 @@

 #define PFN_BUFBITMAP               (CHAR_BIT * BUFSIZE_BITMAP)

 #define BUFSIZE_DATA_CACHE          (TARGET_PAGE_SIZE * 4)

-typedef struct ArchDumpInfo {

-    int d_machine;  /* Architecture */

-    int d_endian;   /* ELFDATA2LSB or ELFDATA2MSB */

-    int d_class;    /* ELFCLASS32 or ELFCLASS64 */

-} ArchDumpInfo;

+#include "sysemu/dump-arch.h"

+#include "sysemu/memory_mapping.h"

 typedef struct QEMU_PACKED MakedumpfileHeader {

     char signature[16];     /* = "makedumpfile" */

@@ -158,9 +155,37 @@ typedef struct QEMU_PACKED PageDescriptor {

     uint64_t page_flags;            /* page flags */

 } PageDescriptor;

-struct GuestPhysBlockList; /* memory_mapping.h */

-int cpu_get_dump_info(ArchDumpInfo *info,

-                      const struct GuestPhysBlockList *guest_phys_blocks);

-ssize_t cpu_get_note_size(int class, int machine, int nr_cpus);

-

+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;

+

+    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 */

+    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;

+

+uint16_t cpu_to_dump16(DumpState *s, uint16_t val);

+uint32_t cpu_to_dump32(DumpState *s, uint32_t val);

+uint64_t cpu_to_dump64(DumpState *s, uint64_t val);

 #endif

diff --git a/stubs/dump.c b/stubs/dump.c

index 370cd96..fac7019 100644

--- a/stubs/dump.c

+++ b/stubs/dump.c

@@ -12,7 +12,7 @@

  */

 #include "qemu-common.h"

-#include "sysemu/dump.h"

+#include "sysemu/dump-arch.h"

 #include "qapi/qmp/qerror.h"

 #include "qmp-commands.h"

-- 

1.8.3.1