You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
174 lines
6.3 KiB
174 lines
6.3 KiB
From deaf4e0f5e90d227b7b9f3e5d1dff7fd0bc0206a Mon Sep 17 00:00:00 2001
|
|
From: =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= <marcandre.lureau@redhat.com>
|
|
Date: Mon, 5 Sep 2022 16:06:21 +0400
|
|
Subject: [PATCH 31/42] dump: fix kdump to work over non-aligned blocks
|
|
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: [31/41] b307bdce4a4791fc30160fa2a1678bd238f2432e
|
|
|
|
Rewrite get_next_page() to work over non-aligned blocks. When it
|
|
encounters non aligned addresses, it will try to fill a page provided by
|
|
the caller.
|
|
|
|
This solves a kdump crash with "tpm-crb-cmd" RAM memory region,
|
|
qemu-kvm: ../dump/dump.c:1162: _Bool get_next_page(GuestPhysBlock **,
|
|
uint64_t *, uint8_t **, DumpState *): Assertion `(block->target_start &
|
|
~target_page_mask) == 0' failed.
|
|
|
|
because:
|
|
guest_phys_block_add_section: target_start=00000000fed40080 target_end=00000000fed41000: added (count: 4)
|
|
|
|
Fixes:
|
|
https://bugzilla.redhat.com/show_bug.cgi?id=2120480
|
|
|
|
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
|
|
Acked-by: David Hildenbrand <david@redhat.com>
|
|
(cherry picked from commit 94d788408d2d5a6474c99b2c9cf06913b9db7c58)
|
|
Signed-off-by: Cédric Le Goater <clg@redhat.com>
|
|
---
|
|
dump/dump.c | 79 +++++++++++++++++++++++++++++++++++++----------------
|
|
1 file changed, 56 insertions(+), 23 deletions(-)
|
|
|
|
diff --git a/dump/dump.c b/dump/dump.c
|
|
index 1c49232390..88177fa886 100644
|
|
--- a/dump/dump.c
|
|
+++ b/dump/dump.c
|
|
@@ -1117,50 +1117,81 @@ static uint64_t dump_pfn_to_paddr(DumpState *s, uint64_t pfn)
|
|
}
|
|
|
|
/*
|
|
- * exam every page and return the page frame number and the address of the page.
|
|
- * bufptr can be NULL. note: the blocks here is supposed to reflect guest-phys
|
|
- * blocks, so block->target_start and block->target_end should be interal
|
|
- * multiples of the target page size.
|
|
+ * Return the page frame number and the page content in *bufptr. bufptr can be
|
|
+ * NULL. If not NULL, *bufptr must contains a target page size of pre-allocated
|
|
+ * memory. This is not necessarily the memory returned.
|
|
*/
|
|
static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr,
|
|
uint8_t **bufptr, DumpState *s)
|
|
{
|
|
GuestPhysBlock *block = *blockptr;
|
|
- hwaddr addr, target_page_mask = ~((hwaddr)s->dump_info.page_size - 1);
|
|
- uint8_t *buf;
|
|
+ uint32_t page_size = s->dump_info.page_size;
|
|
+ uint8_t *buf = NULL, *hbuf;
|
|
+ hwaddr addr;
|
|
|
|
/* block == NULL means the start of the iteration */
|
|
if (!block) {
|
|
block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
|
|
*blockptr = block;
|
|
addr = block->target_start;
|
|
+ *pfnptr = dump_paddr_to_pfn(s, addr);
|
|
} else {
|
|
- addr = dump_pfn_to_paddr(s, *pfnptr + 1);
|
|
+ *pfnptr += 1;
|
|
+ addr = dump_pfn_to_paddr(s, *pfnptr);
|
|
}
|
|
assert(block != NULL);
|
|
|
|
- if ((addr >= block->target_start) &&
|
|
- (addr + s->dump_info.page_size <= block->target_end)) {
|
|
- buf = block->host_addr + (addr - block->target_start);
|
|
- } else {
|
|
- /* the next page is in the next block */
|
|
- block = QTAILQ_NEXT(block, next);
|
|
- *blockptr = block;
|
|
- if (!block) {
|
|
- return false;
|
|
+ while (1) {
|
|
+ if (addr >= block->target_start && addr < block->target_end) {
|
|
+ size_t n = MIN(block->target_end - addr, page_size - addr % page_size);
|
|
+ hbuf = block->host_addr + (addr - block->target_start);
|
|
+ if (!buf) {
|
|
+ if (n == page_size) {
|
|
+ /* this is a whole target page, go for it */
|
|
+ assert(addr % page_size == 0);
|
|
+ buf = hbuf;
|
|
+ break;
|
|
+ } else if (bufptr) {
|
|
+ assert(*bufptr);
|
|
+ buf = *bufptr;
|
|
+ memset(buf, 0, page_size);
|
|
+ } else {
|
|
+ return true;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ memcpy(buf + addr % page_size, hbuf, n);
|
|
+ addr += n;
|
|
+ if (addr % page_size == 0) {
|
|
+ /* we filled up the page */
|
|
+ break;
|
|
+ }
|
|
+ } else {
|
|
+ /* the next page is in the next block */
|
|
+ *blockptr = block = QTAILQ_NEXT(block, next);
|
|
+ if (!block) {
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ addr = block->target_start;
|
|
+ /* are we still in the same page? */
|
|
+ if (dump_paddr_to_pfn(s, addr) != *pfnptr) {
|
|
+ if (buf) {
|
|
+ /* no, but we already filled something earlier, return it */
|
|
+ break;
|
|
+ } else {
|
|
+ /* else continue from there */
|
|
+ *pfnptr = dump_paddr_to_pfn(s, addr);
|
|
+ }
|
|
+ }
|
|
}
|
|
- addr = block->target_start;
|
|
- buf = block->host_addr;
|
|
}
|
|
|
|
- assert((block->target_start & ~target_page_mask) == 0);
|
|
- assert((block->target_end & ~target_page_mask) == 0);
|
|
- *pfnptr = dump_paddr_to_pfn(s, addr);
|
|
if (bufptr) {
|
|
*bufptr = buf;
|
|
}
|
|
|
|
- return true;
|
|
+ return buf != NULL;
|
|
}
|
|
|
|
static void write_dump_bitmap(DumpState *s, Error **errp)
|
|
@@ -1306,6 +1337,7 @@ static void write_dump_pages(DumpState *s, Error **errp)
|
|
uint8_t *buf;
|
|
GuestPhysBlock *block_iter = NULL;
|
|
uint64_t pfn_iter;
|
|
+ g_autofree uint8_t *page = NULL;
|
|
|
|
/* get offset of page_desc and page_data in dump file */
|
|
offset_desc = s->offset_page;
|
|
@@ -1341,12 +1373,13 @@ static void write_dump_pages(DumpState *s, Error **errp)
|
|
}
|
|
|
|
offset_data += s->dump_info.page_size;
|
|
+ page = g_malloc(s->dump_info.page_size);
|
|
|
|
/*
|
|
* dump memory to vmcore page by page. zero page will all be resided in the
|
|
* first page of page section
|
|
*/
|
|
- while (get_next_page(&block_iter, &pfn_iter, &buf, s)) {
|
|
+ for (buf = page; get_next_page(&block_iter, &pfn_iter, &buf, s); buf = page) {
|
|
/* check zero page */
|
|
if (is_zero_page(buf, s->dump_info.page_size)) {
|
|
ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor),
|
|
--
|
|
2.37.3
|
|
|