From a18ba2fbaf132724e81be92da42b36d8f365e66c Mon Sep 17 00:00:00 2001

From: Janosch Frank <frankja@linux.ibm.com>

Date: Thu, 11 Aug 2022 12:10:56 +0000

Subject: [PATCH 24/42] dump: Refactor dump_iterate and introduce

 dump_filter_memblock_*()

MIME-Version: 1.0

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

Content-Transfer-Encoding: 8bit

RH-Author: Cédric Le Goater <clg@redhat.com>

RH-MergeRequest: 226: s390: Enhanced Interpretation for PCI Functions and Secure Execution guest dump

RH-Bugzilla: 1664378 2043909

RH-Acked-by: Thomas Huth <thuth@redhat.com>

RH-Acked-by: Cornelia Huck <cohuck@redhat.com>

RH-Acked-by: Jon Maloy <jmaloy@redhat.com>

RH-Commit: [24/41] 74ef470f24d9d98093c4d63730a99474587033fd

The iteration over the memblocks in dump_iterate() is hard to

understand so it's about time to clean it up. Instead of manually

grabbing the next memblock we can use QTAILQ_FOREACH to iterate over

all memblocks.

Additionally we move the calculation of the offset and length out by

introducing and using the dump_filter_memblock_*() functions. These

functions will later be used to cleanup other parts of dump.c.

Signed-off-by: Janosch Frank <frankja@linux.ibm.com>

Reviewed-by: Janis Schoetterl-Glausch <scgl@linux.ibm.com>

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

Message-Id: <20220811121111.9878-4-frankja@linux.ibm.com>

(cherry picked from commit 1e8113032f5b1efc5da66382470ce4809c76f8f2)

Signed-off-by: Cédric Le Goater <clg@redhat.com>

---

 dump/dump.c | 74 ++++++++++++++++++++++++++++++-----------------------

 1 file changed, 42 insertions(+), 32 deletions(-)

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

index fa787f379f..d981e843dd 100644

--- a/dump/dump.c

+++ b/dump/dump.c

@@ -592,31 +592,43 @@ static void dump_begin(DumpState *s, Error **errp)

     write_elf_notes(s, errp);

 }

-static int get_next_block(DumpState *s, GuestPhysBlock *block)

+static int64_t dump_filtered_memblock_size(GuestPhysBlock *block,

+                                           int64_t filter_area_start,

+                                           int64_t filter_area_length)

 {

-    while (1) {

-        block = QTAILQ_NEXT(block, next);

-        if (!block) {

-            /* no more block */

-            return 1;

-        }

+    int64_t size, left, right;

-        s->start = 0;

-        s->next_block = block;

-        if (s->has_filter) {

-            if (block->target_start >= s->begin + s->length ||

-                block->target_end <= s->begin) {

-                /* This block is out of the range */

-                continue;

-            }

+    /* No filter, return full size */

+    if (!filter_area_length) {

+        return block->target_end - block->target_start;

+    }

-            if (s->begin > block->target_start) {

-                s->start = s->begin - block->target_start;

-            }

+    /* calculate the overlapped region. */

+    left = MAX(filter_area_start, block->target_start);

+    right = MIN(filter_area_start + filter_area_length, block->target_end);

+    size = right - left;

+    size = size > 0 ? size : 0;

+

+    return size;

+}

+

+static int64_t dump_filtered_memblock_start(GuestPhysBlock *block,

+                                            int64_t filter_area_start,

+                                            int64_t filter_area_length)

+{

+    if (filter_area_length) {

+        /* return -1 if the block is not within filter area */

+        if (block->target_start >= filter_area_start + filter_area_length ||

+            block->target_end <= filter_area_start) {

+            return -1;

         }

-        return 0;

+        if (filter_area_start > block->target_start) {

+            return filter_area_start - block->target_start;

+        }

     }

+

+    return 0;

 }

 /* write all memory to vmcore */

@@ -624,24 +636,22 @@ static void dump_iterate(DumpState *s, Error **errp)

 {

     ERRP_GUARD();

     GuestPhysBlock *block;

-    int64_t size;

-

-    do {

-        block = s->next_block;

+    int64_t memblock_size, memblock_start;

-        size = block->target_end - block->target_start;

-        if (s->has_filter) {

-            size -= s->start;

-            if (s->begin + s->length < block->target_end) {

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

-            }

+    QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {

+        memblock_start = dump_filtered_memblock_start(block, s->begin, s->length);

+        if (memblock_start == -1) {

+            continue;

         }

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

+

+        memblock_size = dump_filtered_memblock_size(block, s->begin, s->length);

+

+        /* Write the memory to file */

+        write_memory(s, block, memblock_start, memblock_size, errp);

         if (*errp) {

             return;

         }

-

-    } while (!get_next_block(s, block));

+    }

 }

 static void create_vmcore(DumpState *s, Error **errp)

-- 

2.37.3