thebeanogamer / rpms / qemu-kvm

Forked from rpms/qemu-kvm 5 months ago
Clone
9ae3a8
From 4a4865cb64b429fc95d4466be707c812c7f3ee06 Mon Sep 17 00:00:00 2001
9ae3a8
From: =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= <marcandre.lureau@redhat.com>
9ae3a8
Date: Wed, 13 Dec 2017 13:38:50 +0100
9ae3a8
Subject: [PATCH 19/41] dump: Turn some functions to void to make code cleaner
9ae3a8
MIME-Version: 1.0
9ae3a8
Content-Type: text/plain; charset=UTF-8
9ae3a8
Content-Transfer-Encoding: 8bit
9ae3a8
9ae3a8
RH-Author: Marc-André Lureau <marcandre.lureau@redhat.com>
9ae3a8
Message-id: <20171213133912.26176-20-marcandre.lureau@redhat.com>
9ae3a8
Patchwork-id: 78368
9ae3a8
O-Subject: [RHEL-7.5 qemu-kvm PATCH v3 19/41] dump: Turn some functions to void to make code cleaner
9ae3a8
Bugzilla: 1411490
9ae3a8
RH-Acked-by: Laszlo Ersek <lersek@redhat.com>
9ae3a8
RH-Acked-by: Michael S. Tsirkin <mst@redhat.com>
9ae3a8
RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>
9ae3a8
9ae3a8
From: zhanghailiang <zhang.zhanghailiang@huawei.com>
9ae3a8
9ae3a8
Functions shouldn't return an error code and an Error object at the same time.
9ae3a8
Turn all these functions that returning Error object to void.
9ae3a8
We also judge if a function success or fail by reference to the local_err.
9ae3a8
9ae3a8
Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>
9ae3a8
Reviewed-by: Eric Blake <eblake@redhat.com>
9ae3a8
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
9ae3a8
9ae3a8
(cherry picked from commit 4c7e251ae6d9c328850d62d8aeafa14ca600c858)
9ae3a8
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
9ae3a8
Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>
9ae3a8
---
9ae3a8
 dump.c | 312 ++++++++++++++++++++++++++++++-----------------------------------
9ae3a8
 1 file changed, 142 insertions(+), 170 deletions(-)
9ae3a8
9ae3a8
diff --git a/dump.c b/dump.c
9ae3a8
index 3718a79..099346a 100644
9ae3a8
--- a/dump.c
9ae3a8
+++ b/dump.c
9ae3a8
@@ -100,7 +100,7 @@ static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
9ae3a8
     return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf64_header(DumpState *s, Error **errp)
9ae3a8
+static void write_elf64_header(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     Elf64_Ehdr elf_header;
9ae3a8
     int ret;
9ae3a8
@@ -128,13 +128,10 @@ static int write_elf64_header(DumpState *s, Error **errp)
9ae3a8
     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write elf header", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf32_header(DumpState *s, Error **errp)
9ae3a8
+static void write_elf32_header(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     Elf32_Ehdr elf_header;
9ae3a8
     int ret;
9ae3a8
@@ -162,15 +159,12 @@ static int write_elf32_header(DumpState *s, Error **errp)
9ae3a8
     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write elf header", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
-                            int phdr_index, hwaddr offset,
9ae3a8
-                            hwaddr filesz, Error **errp)
9ae3a8
+static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
+                             int phdr_index, hwaddr offset,
9ae3a8
+                             hwaddr filesz, Error **errp)
9ae3a8
 {
9ae3a8
     Elf64_Phdr phdr;
9ae3a8
     int ret;
9ae3a8
@@ -188,15 +182,12 @@ static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write program header table", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
-                            int phdr_index, hwaddr offset,
9ae3a8
-                            hwaddr filesz, Error **errp)
9ae3a8
+static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
+                             int phdr_index, hwaddr offset,
9ae3a8
+                             hwaddr filesz, Error **errp)
9ae3a8
 {
9ae3a8
     Elf32_Phdr phdr;
9ae3a8
     int ret;
9ae3a8
@@ -214,13 +205,10 @@ static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
9ae3a8
     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write program header table", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf64_note(DumpState *s, Error **errp)
9ae3a8
+static void write_elf64_note(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     Elf64_Phdr phdr;
9ae3a8
     hwaddr begin = s->memory_offset - s->note_size;
9ae3a8
@@ -237,10 +225,7 @@ static int write_elf64_note(DumpState *s, Error **errp)
9ae3a8
     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write program header table", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
 static inline int cpu_index(CPUState *cpu)
9ae3a8
@@ -248,8 +233,8 @@ static inline int cpu_index(CPUState *cpu)
9ae3a8
     return cpu->cpu_index + 1;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
-                             Error **errp)
9ae3a8
+static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
+                              Error **errp)
9ae3a8
 {
9ae3a8
     CPUArchState *env;
9ae3a8
     CPUState *cpu;
9ae3a8
@@ -262,7 +247,7 @@ static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
         ret = cpu_write_elf64_note(f, cpu, id, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to write elf notes", errp);
9ae3a8
-            return -1;
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -271,14 +256,12 @@ static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
         ret = cpu_write_elf64_qemunote(f, cpu, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to write CPU status", errp);
9ae3a8
-            return -1;
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf32_note(DumpState *s, Error **errp)
9ae3a8
+static void write_elf32_note(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     hwaddr begin = s->memory_offset - s->note_size;
9ae3a8
     Elf32_Phdr phdr;
9ae3a8
@@ -295,14 +278,11 @@ static int write_elf32_note(DumpState *s, Error **errp)
9ae3a8
     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write program header table", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
-                             Error **errp)
9ae3a8
+static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
+                              Error **errp)
9ae3a8
 {
9ae3a8
     CPUArchState *env;
9ae3a8
     CPUState *cpu;
9ae3a8
@@ -315,7 +295,7 @@ static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
         ret = cpu_write_elf32_note(f, cpu, id, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to write elf notes", errp);
9ae3a8
-            return -1;
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -324,14 +304,12 @@ static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
9ae3a8
         ret = cpu_write_elf32_qemunote(f, cpu, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to write CPU status", errp);
9ae3a8
-            return -1;
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf_section(DumpState *s, int type, Error **errp)
9ae3a8
+static void write_elf_section(DumpState *s, int type, Error **errp)
9ae3a8
 {
9ae3a8
     Elf32_Shdr shdr32;
9ae3a8
     Elf64_Shdr shdr64;
9ae3a8
@@ -354,49 +332,43 @@ static int write_elf_section(DumpState *s, int type, Error **errp)
9ae3a8
     ret = fd_write_vmcore(&shdr, shdr_size, s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write section header table", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_data(DumpState *s, void *buf, int length, Error **errp)
9ae3a8
+static void write_data(DumpState *s, void *buf, int length, Error **errp)
9ae3a8
 {
9ae3a8
     int ret;
9ae3a8
 
9ae3a8
     ret = fd_write_vmcore(buf, length, s);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to save memory", errp);
9ae3a8
-        return -1;
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-/* write the memroy to vmcore. 1 page per I/O. */
9ae3a8
-static int write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,
9ae3a8
-                        int64_t size, Error **errp)
9ae3a8
+/* write the memory to vmcore. 1 page per I/O. */
9ae3a8
+static void write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,
9ae3a8
+                         int64_t size, Error **errp)
9ae3a8
 {
9ae3a8
     int64_t i;
9ae3a8
-    int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     for (i = 0; i < size / TARGET_PAGE_SIZE; i++) {
9ae3a8
-        ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
9ae3a8
-                         TARGET_PAGE_SIZE, errp);
9ae3a8
-        if (ret < 0) {
9ae3a8
-            return ret;
9ae3a8
+        write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
9ae3a8
+                   TARGET_PAGE_SIZE, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
 
9ae3a8
     if ((size % TARGET_PAGE_SIZE) != 0) {
9ae3a8
-        ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
9ae3a8
-                         size % TARGET_PAGE_SIZE, errp);
9ae3a8
-        if (ret < 0) {
9ae3a8
-            return ret;
9ae3a8
+        write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,
9ae3a8
+                   size % TARGET_PAGE_SIZE, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
 /* get the memory's offset and size in the vmcore */
9ae3a8
@@ -461,13 +433,13 @@ static void get_offset_range(hwaddr phys_addr,
9ae3a8
     }
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_elf_loads(DumpState *s, Error **errp)
9ae3a8
+static void write_elf_loads(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     hwaddr offset, filesz;
9ae3a8
     MemoryMapping *memory_mapping;
9ae3a8
     uint32_t phdr_index = 1;
9ae3a8
-    int ret;
9ae3a8
     uint32_t max_index;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     if (s->have_section) {
9ae3a8
         max_index = s->sh_info;
9ae3a8
@@ -480,29 +452,28 @@ static int write_elf_loads(DumpState *s, Error **errp)
9ae3a8
                          memory_mapping->length,
9ae3a8
                          s, &offset, &filesz);
9ae3a8
         if (s->dump_info.d_class == ELFCLASS64) {
9ae3a8
-            ret = write_elf64_load(s, memory_mapping, phdr_index++, offset,
9ae3a8
-                                   filesz, errp);
9ae3a8
+            write_elf64_load(s, memory_mapping, phdr_index++, offset,
9ae3a8
+                             filesz, &local_err);
9ae3a8
         } else {
9ae3a8
-            ret = write_elf32_load(s, memory_mapping, phdr_index++, offset,
9ae3a8
-                                   filesz, errp);
9ae3a8
+            write_elf32_load(s, memory_mapping, phdr_index++, offset,
9ae3a8
+                             filesz, &local_err);
9ae3a8
         }
9ae3a8
 
9ae3a8
-        if (ret < 0) {
9ae3a8
-            return -1;
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         if (phdr_index >= max_index) {
9ae3a8
             break;
9ae3a8
         }
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
 /* write elf header, PT_NOTE and elf note to vmcore. */
9ae3a8
-static int dump_begin(DumpState *s, Error **errp)
9ae3a8
+static void dump_begin(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
-    int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     /*
9ae3a8
      * the vmcore's format is:
9ae3a8
@@ -530,69 +501,81 @@ static int dump_begin(DumpState *s, Error **errp)
9ae3a8
 
9ae3a8
     /* write elf header to vmcore */
9ae3a8
     if (s->dump_info.d_class == ELFCLASS64) {
9ae3a8
-        ret = write_elf64_header(s, errp);
9ae3a8
+        write_elf64_header(s, &local_err);
9ae3a8
     } else {
9ae3a8
-        ret = write_elf32_header(s, errp);
9ae3a8
+        write_elf32_header(s, &local_err);
9ae3a8
     }
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
     if (s->dump_info.d_class == ELFCLASS64) {
9ae3a8
         /* write PT_NOTE to vmcore */
9ae3a8
-        if (write_elf64_note(s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf64_note(s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write all PT_LOAD to vmcore */
9ae3a8
-        if (write_elf_loads(s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf_loads(s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write section to vmcore */
9ae3a8
         if (s->have_section) {
9ae3a8
-            if (write_elf_section(s, 1, errp) < 0) {
9ae3a8
-                return -1;
9ae3a8
+            write_elf_section(s, 1, &local_err);
9ae3a8
+            if (local_err) {
9ae3a8
+                error_propagate(errp, local_err);
9ae3a8
+                return;
9ae3a8
             }
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write notes to vmcore */
9ae3a8
-        if (write_elf64_notes(fd_write_vmcore, s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf64_notes(fd_write_vmcore, s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
-
9ae3a8
     } else {
9ae3a8
         /* write PT_NOTE to vmcore */
9ae3a8
-        if (write_elf32_note(s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf32_note(s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write all PT_LOAD to vmcore */
9ae3a8
-        if (write_elf_loads(s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf_loads(s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write section to vmcore */
9ae3a8
         if (s->have_section) {
9ae3a8
-            if (write_elf_section(s, 0, errp) < 0) {
9ae3a8
-                return -1;
9ae3a8
+            write_elf_section(s, 0, &local_err);
9ae3a8
+            if (local_err) {
9ae3a8
+                error_propagate(errp, local_err);
9ae3a8
+                return;
9ae3a8
             }
9ae3a8
         }
9ae3a8
 
9ae3a8
         /* write notes to vmcore */
9ae3a8
-        if (write_elf32_notes(fd_write_vmcore, s, errp) < 0) {
9ae3a8
-            return -1;
9ae3a8
+        write_elf32_notes(fd_write_vmcore, s, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
     }
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
-/* write PT_LOAD to vmcore */
9ae3a8
-static int dump_completed(DumpState *s)
9ae3a8
+static void dump_completed(DumpState *s)
9ae3a8
 {
9ae3a8
     dump_cleanup(s);
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
 static int get_next_block(DumpState *s, GuestPhysBlock *block)
9ae3a8
@@ -623,11 +606,12 @@ static int get_next_block(DumpState *s, GuestPhysBlock *block)
9ae3a8
 }
9ae3a8
 
9ae3a8
 /* write all memory to vmcore */
9ae3a8
-static int dump_iterate(DumpState *s, Error **errp)
9ae3a8
+static void dump_iterate(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     GuestPhysBlock *block;
9ae3a8
     int64_t size;
9ae3a8
     int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     while (1) {
9ae3a8
         block = s->next_block;
9ae3a8
@@ -639,34 +623,30 @@ static int dump_iterate(DumpState *s, Error **errp)
9ae3a8
                 size -= block->target_end - (s->begin + s->length);
9ae3a8
             }
9ae3a8
         }
9ae3a8
-        ret = write_memory(s, block, s->start, size, errp);
9ae3a8
-        if (ret == -1) {
9ae3a8
-            return ret;
9ae3a8
+        write_memory(s, block, s->start, size, &local_err);
9ae3a8
+        if (local_err) {
9ae3a8
+            error_propagate(errp, local_err);
9ae3a8
+            return;
9ae3a8
         }
9ae3a8
 
9ae3a8
         ret = get_next_block(s, block);
9ae3a8
         if (ret == 1) {
9ae3a8
             dump_completed(s);
9ae3a8
-            return 0;
9ae3a8
         }
9ae3a8
     }
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int create_vmcore(DumpState *s, Error **errp)
9ae3a8
+static void create_vmcore(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
-    int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
-    ret = dump_begin(s, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
-    }
9ae3a8
-
9ae3a8
-    ret = dump_iterate(s, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
+    dump_begin(s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
-    return 0;
9ae3a8
+    dump_iterate(s, errp);
9ae3a8
 }
9ae3a8
 
9ae3a8
 static int write_start_flat_header(int fd)
9ae3a8
@@ -747,9 +727,8 @@ static int buf_write_note(const void *buf, size_t size, void *opaque)
9ae3a8
 }
9ae3a8
 
9ae3a8
 /* write common header, sub header and elf note to vmcore */
9ae3a8
-static int create_header32(DumpState *s, Error **errp)
9ae3a8
+static void create_header32(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
-    int ret = 0;
9ae3a8
     DiskDumpHeader32 *dh = NULL;
9ae3a8
     KdumpSubHeader32 *kh = NULL;
9ae3a8
     size_t size;
9ae3a8
@@ -758,6 +737,7 @@ static int create_header32(DumpState *s, Error **errp)
9ae3a8
     uint32_t bitmap_blocks;
9ae3a8
     uint32_t status = 0;
9ae3a8
     uint64_t offset_note;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     /* write common header, the version of kdump-compressed format is 6th */
9ae3a8
     size = sizeof(DiskDumpHeader32);
9ae3a8
@@ -794,7 +774,6 @@ static int create_header32(DumpState *s, Error **errp)
9ae3a8
 
9ae3a8
     if (write_buffer(s->fd, 0, dh, size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write disk dump header", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -814,7 +793,6 @@ static int create_header32(DumpState *s, Error **errp)
9ae3a8
     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
9ae3a8
                      block_size, kh, size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write kdump sub header", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -823,15 +801,14 @@ static int create_header32(DumpState *s, Error **errp)
9ae3a8
     s->note_buf_offset = 0;
9ae3a8
 
9ae3a8
     /* use s->note_buf to store notes temporarily */
9ae3a8
-    if (write_elf32_notes(buf_write_note, s, errp) < 0) {
9ae3a8
-        ret = -1;
9ae3a8
+    write_elf32_notes(buf_write_note, s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
-
9ae3a8
     if (write_buffer(s->fd, offset_note, s->note_buf,
9ae3a8
                      s->note_size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write notes", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -847,14 +824,11 @@ out:
9ae3a8
     g_free(dh);
9ae3a8
     g_free(kh);
9ae3a8
     g_free(s->note_buf);
9ae3a8
-
9ae3a8
-    return ret;
9ae3a8
 }
9ae3a8
 
9ae3a8
 /* write common header, sub header and elf note to vmcore */
9ae3a8
-static int create_header64(DumpState *s, Error **errp)
9ae3a8
+static void create_header64(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
-    int ret = 0;
9ae3a8
     DiskDumpHeader64 *dh = NULL;
9ae3a8
     KdumpSubHeader64 *kh = NULL;
9ae3a8
     size_t size;
9ae3a8
@@ -863,6 +837,7 @@ static int create_header64(DumpState *s, Error **errp)
9ae3a8
     uint32_t bitmap_blocks;
9ae3a8
     uint32_t status = 0;
9ae3a8
     uint64_t offset_note;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     /* write common header, the version of kdump-compressed format is 6th */
9ae3a8
     size = sizeof(DiskDumpHeader64);
9ae3a8
@@ -899,7 +874,6 @@ static int create_header64(DumpState *s, Error **errp)
9ae3a8
 
9ae3a8
     if (write_buffer(s->fd, 0, dh, size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write disk dump header", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -919,7 +893,6 @@ static int create_header64(DumpState *s, Error **errp)
9ae3a8
     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
9ae3a8
                      block_size, kh, size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write kdump sub header", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -928,15 +901,15 @@ static int create_header64(DumpState *s, Error **errp)
9ae3a8
     s->note_buf_offset = 0;
9ae3a8
 
9ae3a8
     /* use s->note_buf to store notes temporarily */
9ae3a8
-    if (write_elf64_notes(buf_write_note, s, errp) < 0) {
9ae3a8
-        ret = -1;
9ae3a8
+    write_elf64_notes(buf_write_note, s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
     if (write_buffer(s->fd, offset_note, s->note_buf,
9ae3a8
                      s->note_size) < 0) {
9ae3a8
         dump_error(s, "dump: failed to write notes", errp);
9ae3a8
-        ret = -1;
9ae3a8
         goto out;
9ae3a8
     }
9ae3a8
 
9ae3a8
@@ -952,16 +925,19 @@ out:
9ae3a8
     g_free(dh);
9ae3a8
     g_free(kh);
9ae3a8
     g_free(s->note_buf);
9ae3a8
-
9ae3a8
-    return ret;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_dump_header(DumpState *s, Error **errp)
9ae3a8
+static void write_dump_header(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
+     Error *local_err = NULL;
9ae3a8
+
9ae3a8
     if (s->dump_info.d_class == ELFCLASS32) {
9ae3a8
-        return create_header32(s, errp);
9ae3a8
+        create_header32(s, &local_err);
9ae3a8
     } else {
9ae3a8
-        return create_header64(s, errp);
9ae3a8
+        create_header64(s, &local_err);
9ae3a8
+    }
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
     }
9ae3a8
 }
9ae3a8
 
9ae3a8
@@ -1075,7 +1051,7 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr,
9ae3a8
     return true;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_dump_bitmap(DumpState *s, Error **errp)
9ae3a8
+static void write_dump_bitmap(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     int ret = 0;
9ae3a8
     uint64_t last_pfn, pfn;
9ae3a8
@@ -1097,7 +1073,6 @@ static int write_dump_bitmap(DumpState *s, Error **errp)
9ae3a8
         ret = set_dump_bitmap(last_pfn, pfn, true, dump_bitmap_buf, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to set dump_bitmap", errp);
9ae3a8
-            ret = -1;
9ae3a8
             goto out;
9ae3a8
         }
9ae3a8
 
9ae3a8
@@ -1115,7 +1090,6 @@ static int write_dump_bitmap(DumpState *s, Error **errp)
9ae3a8
                               dump_bitmap_buf, s);
9ae3a8
         if (ret < 0) {
9ae3a8
             dump_error(s, "dump: failed to sync dump_bitmap", errp);
9ae3a8
-            ret = -1;
9ae3a8
             goto out;
9ae3a8
         }
9ae3a8
     }
9ae3a8
@@ -1125,8 +1099,6 @@ static int write_dump_bitmap(DumpState *s, Error **errp)
9ae3a8
 
9ae3a8
 out:
9ae3a8
     g_free(dump_bitmap_buf);
9ae3a8
-
9ae3a8
-    return ret;
9ae3a8
 }
9ae3a8
 
9ae3a8
 static void prepare_data_cache(DataCache *data_cache, DumpState *s,
9ae3a8
@@ -1206,7 +1178,7 @@ static inline bool is_zero_page(const uint8_t *buf, size_t page_size)
9ae3a8
     return buffer_is_zero(buf, page_size);
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int write_dump_pages(DumpState *s, Error **errp)
9ae3a8
+static void write_dump_pages(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     int ret = 0;
9ae3a8
     DataCache page_desc, page_data;
9ae3a8
@@ -1371,13 +1343,12 @@ out:
9ae3a8
 #endif
9ae3a8
 
9ae3a8
     g_free(buf_out);
9ae3a8
-
9ae3a8
-    return ret;
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int create_kdump_vmcore(DumpState *s, Error **errp)
9ae3a8
+static void create_kdump_vmcore(DumpState *s, Error **errp)
9ae3a8
 {
9ae3a8
     int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     /*
9ae3a8
      * the kdump-compressed format is:
9ae3a8
@@ -1404,33 +1375,34 @@ static int create_kdump_vmcore(DumpState *s, Error **errp)
9ae3a8
     ret = write_start_flat_header(s->fd);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write start flat header", errp);
9ae3a8
-        return -1;
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
-    ret = write_dump_header(s, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
+    write_dump_header(s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
-    ret = write_dump_bitmap(s, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
+    write_dump_bitmap(s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
-    ret = write_dump_pages(s, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
-        return -1;
9ae3a8
+    write_dump_pages(s, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
     ret = write_end_flat_header(s->fd);
9ae3a8
     if (ret < 0) {
9ae3a8
         dump_error(s, "dump: failed to write end flat header", errp);
9ae3a8
-        return -1;
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
     dump_completed(s);
9ae3a8
-
9ae3a8
-    return 0;
9ae3a8
 }
9ae3a8
 
9ae3a8
 static ram_addr_t get_start_block(DumpState *s)
9ae3a8
@@ -1469,9 +1441,9 @@ static void get_max_mapnr(DumpState *s)
9ae3a8
     s->max_mapnr = paddr_to_pfn(last_block->target_end);
9ae3a8
 }
9ae3a8
 
9ae3a8
-static int dump_init(DumpState *s, int fd, bool has_format,
9ae3a8
-                     DumpGuestMemoryFormat format, bool paging, bool has_filter,
9ae3a8
-                     int64_t begin, int64_t length, Error **errp)
9ae3a8
+static void dump_init(DumpState *s, int fd, bool has_format,
9ae3a8
+                      DumpGuestMemoryFormat format, bool paging, bool has_filter,
9ae3a8
+                      int64_t begin, int64_t length, Error **errp)
9ae3a8
 {
9ae3a8
     CPUArchState *env;
9ae3a8
     int nr_cpus;
9ae3a8
@@ -1576,7 +1548,7 @@ static int dump_init(DumpState *s, int fd, bool has_format,
9ae3a8
             s->flag_compress = 0;
9ae3a8
         }
9ae3a8
 
9ae3a8
-        return 0;
9ae3a8
+        return;
9ae3a8
     }
9ae3a8
 
9ae3a8
     if (s->has_filter) {
9ae3a8
@@ -1625,11 +1597,10 @@ static int dump_init(DumpState *s, int fd, bool has_format,
9ae3a8
         }
9ae3a8
     }
9ae3a8
 
9ae3a8
-    return 0;
9ae3a8
+    return;
9ae3a8
 
9ae3a8
 cleanup:
9ae3a8
     dump_cleanup(s);
9ae3a8
-    return -1;
9ae3a8
 }
9ae3a8
 
9ae3a8
 void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,
9ae3a8
@@ -1640,7 +1611,7 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,
9ae3a8
     const char *p;
9ae3a8
     int fd = -1;
9ae3a8
     DumpState *s;
9ae3a8
-    int ret;
9ae3a8
+    Error *local_err = NULL;
9ae3a8
 
9ae3a8
     /*
9ae3a8
      * kdump-compressed format need the whole memory dumped, so paging or
9ae3a8
@@ -1700,10 +1671,11 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,
9ae3a8
 
9ae3a8
     s = g_malloc0(sizeof(DumpState));
9ae3a8
 
9ae3a8
-    ret = dump_init(s, fd, has_format, format, paging, has_begin,
9ae3a8
-                    begin, length, errp);
9ae3a8
-    if (ret < 0) {
9ae3a8
+    dump_init(s, fd, has_format, format, paging, has_begin,
9ae3a8
+              begin, length, &local_err);
9ae3a8
+    if (local_err) {
9ae3a8
         g_free(s);
9ae3a8
+        error_propagate(errp, local_err);
9ae3a8
         return;
9ae3a8
     }
9ae3a8
 
9ae3a8
-- 
9ae3a8
1.8.3.1
9ae3a8