From 888eb5bb28377bc392629e34133bf5bc50b0554f 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:49 +0100

Subject: [PATCH 18/41] dump: Propagate errors into qmp_dump_guest_memory()

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-19-marcandre.lureau@redhat.com>

Patchwork-id: 78367

O-Subject: [RHEL-7.5 qemu-kvm PATCH v3 18/41] dump: Propagate errors into qmp_dump_guest_memory()

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: zhanghailiang <zhang.zhanghailiang@huawei.com>

The code calls dump_error() on error, and even passes it a suitable

message.  However, the message is thrown away, and its callers pass

up only success/failure.  All qmp_dump_guest_memory() can do is set

a generic error.

Propagate the errors properly, so qmp_dump_guest_memory() can return

a more useful error.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>

(cherry picked from commit 37917da2d071ab5273703f5169b0b2fefd40cbb5)

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

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

---

 dump.c | 165 ++++++++++++++++++++++++++++++++---------------------------------

 1 file changed, 82 insertions(+), 83 deletions(-)

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

index c709fc2..3718a79 100644

--- a/dump.c

+++ b/dump.c

@@ -81,9 +81,10 @@ static int dump_cleanup(DumpState *s)

     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)

@@ -99,7 +100,7 @@ static int fd_write_vmcore(const void *buf, size_t size, void *opaque)

     return 0;

 }

-static int write_elf64_header(DumpState *s)

+static int write_elf64_header(DumpState *s, Error **errp)

 {

     Elf64_Ehdr elf_header;

     int ret;

@@ -126,14 +127,14 @@ static int write_elf64_header(DumpState *s)

     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write elf header.\n");

+        dump_error(s, "dump: failed to write elf header", errp);

         return -1;

     }

     return 0;

 }

-static int write_elf32_header(DumpState *s)

+static int write_elf32_header(DumpState *s, Error **errp)

 {

     Elf32_Ehdr elf_header;

     int ret;

@@ -160,7 +161,7 @@ static int write_elf32_header(DumpState *s)

     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write elf header.\n");

+        dump_error(s, "dump: failed to write elf header", errp);

         return -1;

     }

@@ -169,7 +170,7 @@ static int write_elf32_header(DumpState *s)

 static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,

                             int phdr_index, hwaddr offset,

-                            hwaddr filesz)

+                            hwaddr filesz, Error **errp)

 {

     Elf64_Phdr phdr;

     int ret;

@@ -186,7 +187,7 @@ static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,

     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write program header table.\n");

+        dump_error(s, "dump: failed to write program header table", errp);

         return -1;

     }

@@ -195,7 +196,7 @@ static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,

 static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,

                             int phdr_index, hwaddr offset,

-                            hwaddr filesz)

+                            hwaddr filesz, Error **errp)

 {

     Elf32_Phdr phdr;

     int ret;

@@ -212,14 +213,14 @@ static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,

     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write program header table.\n");

+        dump_error(s, "dump: failed to write program header table", errp);

         return -1;

     }

     return 0;

 }

-static int write_elf64_note(DumpState *s)

+static int write_elf64_note(DumpState *s, Error **errp)

 {

     Elf64_Phdr phdr;

     hwaddr begin = s->memory_offset - s->note_size;

@@ -235,7 +236,7 @@ static int write_elf64_note(DumpState *s)

     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write program header table.\n");

+        dump_error(s, "dump: failed to write program header table", errp);

         return -1;

     }

@@ -247,7 +248,8 @@ static inline int cpu_index(CPUState *cpu)

     return cpu->cpu_index + 1;

 }

-static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s)

+static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,

+                             Error **errp)

 {

     CPUArchState *env;

     CPUState *cpu;

@@ -259,7 +261,7 @@ 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");

+            dump_error(s, "dump: failed to write elf notes", errp);

             return -1;

         }

     }

@@ -268,7 +270,7 @@ static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s)

         cpu = ENV_GET_CPU(env);

         ret = cpu_write_elf64_qemunote(f, cpu, s);

         if (ret < 0) {

-            dump_error(s, "dump: failed to write CPU status.\n");

+            dump_error(s, "dump: failed to write CPU status", errp);

             return -1;

         }

     }

@@ -276,7 +278,7 @@ static int write_elf64_notes(WriteCoreDumpFunction f, DumpState *s)

     return 0;

 }

-static int write_elf32_note(DumpState *s)

+static int write_elf32_note(DumpState *s, Error **errp)

 {

     hwaddr begin = s->memory_offset - s->note_size;

     Elf32_Phdr phdr;

@@ -292,14 +294,15 @@ static int write_elf32_note(DumpState *s)

     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write program header table.\n");

+        dump_error(s, "dump: failed to write program header table", errp);

         return -1;

     }

     return 0;

 }

-static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s)

+static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,

+                             Error **errp)

 {

     CPUArchState *env;

     CPUState *cpu;

@@ -311,7 +314,7 @@ 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");

+            dump_error(s, "dump: failed to write elf notes", errp);

             return -1;

         }

     }

@@ -320,7 +323,7 @@ static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s)

         cpu = ENV_GET_CPU(env);

         ret = cpu_write_elf32_qemunote(f, cpu, s);

         if (ret < 0) {

-            dump_error(s, "dump: failed to write CPU status.\n");

+            dump_error(s, "dump: failed to write CPU status", errp);

             return -1;

         }

     }

@@ -328,7 +331,7 @@ static int write_elf32_notes(WriteCoreDumpFunction f, DumpState *s)

     return 0;

 }

-static int write_elf_section(DumpState *s, int type)

+static int write_elf_section(DumpState *s, int type, Error **errp)

 {

     Elf32_Shdr shdr32;

     Elf64_Shdr shdr64;

@@ -350,20 +353,20 @@ static int write_elf_section(DumpState *s, int type)

     ret = fd_write_vmcore(&shdr, shdr_size, s);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write section header table.\n");

+        dump_error(s, "dump: failed to write section header table", errp);

         return -1;

     }

     return 0;

 }

-static int write_data(DumpState *s, void *buf, int length)

+static int 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");

+        dump_error(s, "dump: failed to save memory", errp);

         return -1;

     }

@@ -372,14 +375,14 @@ static int write_data(DumpState *s, void *buf, int length)

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

+                        int64_t size, Error **errp)

 {

     int64_t i;

     int ret;

     for (i = 0; i < size / TARGET_PAGE_SIZE; i++) {

         ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,

-                         TARGET_PAGE_SIZE);

+                         TARGET_PAGE_SIZE, errp);

         if (ret < 0) {

             return ret;

         }

@@ -387,7 +390,7 @@ static int write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,

     if ((size % TARGET_PAGE_SIZE) != 0) {

         ret = write_data(s, block->host_addr + start + i * TARGET_PAGE_SIZE,

-                         size % TARGET_PAGE_SIZE);

+                         size % TARGET_PAGE_SIZE, errp);

         if (ret < 0) {

             return ret;

         }

@@ -458,7 +461,7 @@ static void get_offset_range(hwaddr phys_addr,

     }

 }

-static int write_elf_loads(DumpState *s)

+static int write_elf_loads(DumpState *s, Error **errp)

 {

     hwaddr offset, filesz;

     MemoryMapping *memory_mapping;

@@ -478,10 +481,10 @@ static int write_elf_loads(DumpState *s)

                          s, &offset, &filesz);

         if (s->dump_info.d_class == ELFCLASS64) {

             ret = write_elf64_load(s, memory_mapping, phdr_index++, offset,

-                                   filesz);

+                                   filesz, errp);

         } else {

             ret = write_elf32_load(s, memory_mapping, phdr_index++, offset,

-                                   filesz);

+                                   filesz, errp);

         }

         if (ret < 0) {

@@ -497,7 +500,7 @@ static int write_elf_loads(DumpState *s)

 }

 /* write elf header, PT_NOTE and elf note to vmcore. */

-static int dump_begin(DumpState *s)

+static int dump_begin(DumpState *s, Error **errp)

 {

     int ret;

@@ -527,9 +530,9 @@ static int dump_begin(DumpState *s)

     /* write elf header to vmcore */

     if (s->dump_info.d_class == ELFCLASS64) {

-        ret = write_elf64_header(s);

+        ret = write_elf64_header(s, errp);

     } else {

-        ret = write_elf32_header(s);

+        ret = write_elf32_header(s, errp);

     }

     if (ret < 0) {

         return -1;

@@ -537,47 +540,47 @@ static int dump_begin(DumpState *s)

     if (s->dump_info.d_class == ELFCLASS64) {

         /* write PT_NOTE to vmcore */

-        if (write_elf64_note(s) < 0) {

+        if (write_elf64_note(s, errp) < 0) {

             return -1;

         }

         /* write all PT_LOAD to vmcore */

-        if (write_elf_loads(s) < 0) {

+        if (write_elf_loads(s, errp) < 0) {

             return -1;

         }

         /* write section to vmcore */

         if (s->have_section) {

-            if (write_elf_section(s, 1) < 0) {

+            if (write_elf_section(s, 1, errp) < 0) {

                 return -1;

             }

         }

         /* write notes to vmcore */

-        if (write_elf64_notes(fd_write_vmcore, s) < 0) {

+        if (write_elf64_notes(fd_write_vmcore, s, errp) < 0) {

             return -1;

         }

     } else {

         /* write PT_NOTE to vmcore */

-        if (write_elf32_note(s) < 0) {

+        if (write_elf32_note(s, errp) < 0) {

             return -1;

         }

         /* write all PT_LOAD to vmcore */

-        if (write_elf_loads(s) < 0) {

+        if (write_elf_loads(s, errp) < 0) {

             return -1;

         }

         /* write section to vmcore */

         if (s->have_section) {

-            if (write_elf_section(s, 0) < 0) {

+            if (write_elf_section(s, 0, errp) < 0) {

                 return -1;

             }

         }

         /* write notes to vmcore */

-        if (write_elf32_notes(fd_write_vmcore, s) < 0) {

+        if (write_elf32_notes(fd_write_vmcore, s, errp) < 0) {

             return -1;

         }

     }

@@ -620,7 +623,7 @@ static int get_next_block(DumpState *s, GuestPhysBlock *block)

 }

 /* write all memory to vmcore */

-static int dump_iterate(DumpState *s)

+static int dump_iterate(DumpState *s, Error **errp)

 {

     GuestPhysBlock *block;

     int64_t size;

@@ -636,7 +639,7 @@ static int dump_iterate(DumpState *s)

                 size -= block->target_end - (s->begin + s->length);

             }

         }

-        ret = write_memory(s, block, s->start, size);

+        ret = write_memory(s, block, s->start, size, errp);

         if (ret == -1) {

             return ret;

         }

@@ -649,16 +652,16 @@ static int dump_iterate(DumpState *s)

     }

 }

-static int create_vmcore(DumpState *s)

+static int create_vmcore(DumpState *s, Error **errp)

 {

     int ret;

-    ret = dump_begin(s);

+    ret = dump_begin(s, errp);

     if (ret < 0) {

         return -1;

     }

-    ret = dump_iterate(s);

+    ret = dump_iterate(s, errp);

     if (ret < 0) {

         return -1;

     }

@@ -744,7 +747,7 @@ 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 int create_header32(DumpState *s, Error **errp)

 {

     int ret = 0;

     DiskDumpHeader32 *dh = NULL;

@@ -790,7 +793,7 @@ static int create_header32(DumpState *s)

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

+        dump_error(s, "dump: failed to write disk dump header", errp);

         ret = -1;

         goto out;

     }

@@ -810,7 +813,7 @@ static int create_header32(DumpState *s)

     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *

                      block_size, kh, size) < 0) {

-        dump_error(s, "dump: failed to write kdump sub header.\n");

+        dump_error(s, "dump: failed to write kdump sub header", errp);

         ret = -1;

         goto out;

     }

@@ -820,14 +823,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) {

+    if (write_elf32_notes(buf_write_note, s, errp) < 0) {

         ret = -1;

         goto out;

     }

     if (write_buffer(s->fd, offset_note, s->note_buf,

                      s->note_size) < 0) {

-        dump_error(s, "dump: failed to write notes");

+        dump_error(s, "dump: failed to write notes", errp);

         ret = -1;

         goto out;

     }

@@ -849,7 +852,7 @@ out:

 }

 /* write common header, sub header and elf note to vmcore */

-static int create_header64(DumpState *s)

+static int create_header64(DumpState *s, Error **errp)

 {

     int ret = 0;

     DiskDumpHeader64 *dh = NULL;

@@ -895,7 +898,7 @@ static int create_header64(DumpState *s)

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

+        dump_error(s, "dump: failed to write disk dump header", errp);

         ret = -1;

         goto out;

     }

@@ -915,7 +918,7 @@ static int create_header64(DumpState *s)

     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *

                      block_size, kh, size) < 0) {

-        dump_error(s, "dump: failed to write kdump sub header.\n");

+        dump_error(s, "dump: failed to write kdump sub header", errp);

         ret = -1;

         goto out;

     }

@@ -925,14 +928,14 @@ 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) {

+    if (write_elf64_notes(buf_write_note, s, errp) < 0) {

         ret = -1;

         goto out;

     }

     if (write_buffer(s->fd, offset_note, s->note_buf,

                      s->note_size) < 0) {

-        dump_error(s, "dump: failed to write notes");

+        dump_error(s, "dump: failed to write notes", errp);

         ret = -1;

         goto out;

     }

@@ -953,12 +956,12 @@ out:

     return ret;

 }

-static int write_dump_header(DumpState *s)

+static int write_dump_header(DumpState *s, Error **errp)

 {

     if (s->dump_info.d_class == ELFCLASS32) {

-        return create_header32(s);

+        return create_header32(s, errp);

     } else {

-        return create_header64(s);

+        return create_header64(s, errp);

     }

 }

@@ -1072,7 +1075,7 @@ static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr,

     return true;

 }

-static int write_dump_bitmap(DumpState *s)

+static int write_dump_bitmap(DumpState *s, Error **errp)

 {

     int ret = 0;

     uint64_t last_pfn, pfn;

@@ -1093,7 +1096,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");

+            dump_error(s, "dump: failed to set dump_bitmap", errp);

             ret = -1;

             goto out;

         }

@@ -1111,7 +1114,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");

+            dump_error(s, "dump: failed to sync dump_bitmap", errp);

             ret = -1;

             goto out;

         }

@@ -1203,7 +1206,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 int write_dump_pages(DumpState *s, Error **errp)

 {

     int ret = 0;

     DataCache page_desc, page_data;

@@ -1247,7 +1250,7 @@ static int write_dump_pages(DumpState *s)

     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;

     }

@@ -1263,7 +1266,7 @@ static int write_dump_pages(DumpState *s)

             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 {

@@ -1288,7 +1291,7 @@ static int write_dump_pages(DumpState *s)

                 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

@@ -1301,7 +1304,7 @@ static int write_dump_pages(DumpState *s)

                 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

@@ -1315,7 +1318,7 @@ static int write_dump_pages(DumpState *s)

                 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

@@ -1330,7 +1333,7 @@ static int write_dump_pages(DumpState *s)

                 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;

                 }

             }

@@ -1342,7 +1345,7 @@ static int write_dump_pages(DumpState *s)

             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;

             }

         }

@@ -1350,12 +1353,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;

     }

@@ -1372,7 +1375,7 @@ out:

     return ret;

 }

-static int create_kdump_vmcore(DumpState *s)

+static int create_kdump_vmcore(DumpState *s, Error **errp)

 {

     int ret;

@@ -1400,28 +1403,28 @@ 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");

+        dump_error(s, "dump: failed to write start flat header", errp);

         return -1;

     }

-    ret = write_dump_header(s);

+    ret = write_dump_header(s, errp);

     if (ret < 0) {

         return -1;

     }

-    ret = write_dump_bitmap(s);

+    ret = write_dump_bitmap(s, errp);

     if (ret < 0) {

         return -1;

     }

-    ret = write_dump_pages(s);

+    ret = write_dump_pages(s, errp);

     if (ret < 0) {

         return -1;

     }

     ret = write_end_flat_header(s->fd);

     if (ret < 0) {

-        dump_error(s, "dump: failed to write end flat header.\n");

+        dump_error(s, "dump: failed to write end flat header", errp);

         return -1;

     }

@@ -1705,13 +1708,9 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,

     }

     if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {

-        if (create_kdump_vmcore(s) < 0) {

-            error_set(errp, QERR_IO_ERROR);

-        }

+        create_kdump_vmcore(s, errp);

     } else {

-        if (create_vmcore(s) < 0) {

-            error_set(errp, QERR_IO_ERROR);

-        }

+        create_vmcore(s, errp);

     }

     g_free(s);

-- 

1.8.3.1