kdump format description [1] says: [...] zero page has its own offset not equal 0. So when reading page from incomplete core, only the page lost by ENOSPACE errors has 0 in its corresponding page descriptor's member offset. crash has special treatment for page descriptors with zero offset only if DUMP_DH_COMPRESSED_INCOMPLETE is set in dump header. However, makedumpfile places the flag after ENOSPC is hit and only if dump header modification went without errors. In case if crashkernel environment was terminated early (e.g. by BMC) or some other reason, DUMP_DH_COMPRESSED_INCOMPLETE won't be set on the dump header. Then cache_page() would be performed on pages with pd.offset == 0 and due to pd.size == 0 it'll skip read into compressed_page and then non related pre-existing contents of compressed_page will copied into page cache for the non-present page. Ultimately, it'll lead to a cryptic failure, like: crash: invalid kernel virtual address: 72288cacacf427f8 [...] The failure would be a bit cleaner if crash explicitly fails on the page that is an outcome of incomplete dump: crash: page incomplete: kernel virtual address: c000003fff9d17e8 [...] Debugging level 8 would also produce exact offset from data_offset to print descriptor value with ease: read_diskdump/cache_page: descriptor with zero offset found at paddr/pfn/pos: 3fff9d0000/3fff9d/743dd That helps in inspecting broken descriptor with hexdump or similar tools: hexdump -s (data_offset + pos * 0x18) -n 0x18 1. https://github.com/makedumpfile/makedumpfile/blob/master/IMPLEMENTATION Signed-off-by: Roman Bolshakov <r.bolshakov(a)yadro.com&gt; --- defs.h | 1 + diskdump.c | 16 +++++++++++----- memory.c | 7 +++++++ 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/defs.h b/defs.h index 148b03e..fb7de84 100644 --- a/defs.h +++ b/defs.h @@ -361,6 +361,7 @@ struct number_option { #define READ_ERROR (-2) #define WRITE_ERROR (-3) #define PAGE_EXCLUDED (-4) +#define PAGE_INCOMPLETE (-5) #define RESTART() (longjmp(pc->main_loop_env, 1)) #define RESUME_FOREACH() (longjmp(pc->foreach_loop_env, 1)) diff --git a/diskdump.c b/diskdump.c index 6680695..59b79e1 100644 --- a/diskdump.c +++ b/diskdump.c @@ -1146,10 +1146,9 @@ cache_page(physaddr_t paddr) if (FLAT_FORMAT()) { if (!read_flattened_format(dd->dfd, pd.offset, dd->compressed_page, pd.size)) return READ_ERROR; - } else if (is_incomplete_dump() && (0 == pd.offset)) { + } else if (0 == pd.offset) { /* - * If the incomplete flag has been set in the header, - * first check whether zero_excluded has been set. + * First check whether zero_excluded has been set. */ if (*diskdump_flags & ZERO_EXCLUDED) { if (CRASHDEBUG(8)) @@ -1158,8 +1157,15 @@ cache_page(physaddr_t paddr) "paddr/pfn: %llx/%lx\n", (ulonglong)paddr, pfn); memset(dd->compressed_page, 0, dd->block_size); - } else - return READ_ERROR; + } else { + if (CRASHDEBUG(8)) + fprintf(fp, + "read_diskdump/cache_page: " + "descriptor with zero offset found at " + "paddr/pfn/pos: %llx/%lx/%lx\n", + (ulonglong)paddr, pfn, desc_pos); + return PAGE_INCOMPLETE; + } } else { if (lseek(dd->dfd, pd.offset, SEEK_SET) == failed) return SEEK_ERROR; diff --git a/memory.c b/memory.c index cbe90ee..0b19cf8 100644 --- a/memory.c +++ b/memory.c @@ -2212,6 +2212,7 @@ accessible(ulong kva) #define READ_ERRMSG "read error: %s address: %llx type: \"%s\"\n" #define WRITE_ERRMSG "write error: %s address: %llx type: \"%s\"\n" #define PAGE_EXCLUDED_ERRMSG "page excluded: %s address: %llx type: \"%s\"\n" +#define PAGE_INCOMPLETE_ERRMSG "page incomplete: %s address: %llx type: \"%s\"\n" #define RETURN_ON_PARTIAL_READ() \ if ((error_handle & RETURN_PARTIAL) && (size < orig_size)) { \ @@ -2377,6 +2378,12 @@ readmem(ulonglong addr, int memtype, void *buffer, long size, error(INFO, PAGE_EXCLUDED_ERRMSG, memtype_string(memtype, 0), addr, type); goto readmem_error; + case PAGE_INCOMPLETE: + RETURN_ON_PARTIAL_READ(); + if (PRINT_ERROR_MESSAGE) + error(INFO, PAGE_INCOMPLETE_ERRMSG, memtype_string(memtype, 0), addr, type); + goto readmem_error; + default: break; } -- 2.32.0

It's not clear how broken an incomplete dump from the existing debugging prints. Aggregate number of valid pages helps to figure out approximate size of the dump. Size of a complete dump is roughly: EXPECTED_CORE_SIZE = a few pages (kdump headers + bitmaps + descriptors) + (total_valid_pages * block_size) * compression rate An incomplete core would be significantly smaller than: total_valid_pages * block_size Signed-off-by: Roman Bolshakov <r.bolshakov(a)yadro.com&gt; --- diskdump.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/diskdump.c b/diskdump.c index 59b79e1..0f94022 100644 --- a/diskdump.c +++ b/diskdump.c @@ -74,6 +74,7 @@ struct diskdump_data { ulong evictions; /* total evictions done */ ulong cached_reads; ulong *valid_pages; + int max_sect_len; /* highest bucket of valid_pages */ ulong accesses; ulong snapshot_task; }; @@ -877,6 +878,7 @@ restart: } dd->valid_pages = calloc(sizeof(ulong), max_sect_len + 1); + dd->max_sect_len = max_sect_len; for (i = 1; i < max_sect_len + 1; i++) { dd->valid_pages[i] = dd->valid_pages[i - 1]; for (j = 0; j < BITMAP_SECT_LEN; j++, pfn++) @@ -2089,6 +2091,7 @@ __diskdump_memory_dump(FILE *fp) else fprintf(fp, "\n"); fprintf(fp, " valid_pages: %lx\n", (ulong)dd->valid_pages); + fprintf(fp, " total_valid_pages: %ld\n", dd->valid_pages[dd->max_sect_len]); return 0; } -- 2.32.0

crash warns that ELF dump is incomplete like this: WARNING: vmcore: may be truncated or incomplete PT_LOAD p_offset: 218960740 p_filesz: 4194304 bytes required: 223155044 dumpfile size: 219960740 The warning saves a lot of time when figuring out what went wrong, but crash misses explicit dump detection for compressed kdumps. The change adds the warning for compressed kdumps: WARNING: vmcore: may be truncated or incomplete data_offset: 262144 block_size: 65536 total_valid_pages: 2438 first_empty_pd: 100 bytes required: 157467661 dumpfile size: 265982 bytes required is computed as: data_offset (kdump header + bitmaps) + total_valid_pages * page descriptor size (page descriptors) + zero page (that immediately follows page descriptors) + compressed size of every present page in the list of valid pages + block_size for every incomplete page (i.e page descriptor has zero offset) The warning is also printed for incomplete split dumps. Signed-off-by: Roman Bolshakov <r.bolshakov(a)yadro.com&gt; --- diskdump.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 69 insertions(+), 2 deletions(-) diff --git a/diskdump.c b/diskdump.c index de3eeb2..e802d04 100644 --- a/diskdump.c +++ b/diskdump.c @@ -23,6 +23,8 @@ * GNU General Public License for more details. */ +#define _LARGEFILE64_SOURCE 1 /* stat64() */ + #include "defs.h" #include "diskdump.h" #include "xen_dom0.h" @@ -548,6 +550,12 @@ read_dump_header(char *file) ulong pfn; int i, j, max_sect_len; int is_split = 0; + struct stat64 stat; + page_desc_t pd; + ulong page_idx; + ulong first_empty_pd = 0; + int zero_page_counted = 0; + size_t expected_size = 0; if (block_size < 0) return FALSE; @@ -898,13 +906,72 @@ restart: pfn = start; } + expected_size = dd->data_offset; dd->valid_pages = calloc(sizeof(ulong), max_sect_len + 1); dd->max_sect_len = max_sect_len; for (i = 1; i < max_sect_len + 1; i++) { dd->valid_pages[i] = dd->valid_pages[i - 1]; for (j = 0; j < BITMAP_SECT_LEN; j++, pfn++) - if (page_is_dumpable(pfn)) - dd->valid_pages[i]++; + if (page_is_dumpable(pfn)) { + page_idx = dd->valid_pages[i]++; + + offset = dd->data_offset + + page_idx * sizeof(pd); + + if (read_pd(dd->dfd, offset, &pd)) { + /* + * Truncated page descriptor at most + * references full page. + */ + expected_size += block_size; + goto next; + } + + if (pd.offset == 0) { + if (!first_empty_pd) + first_empty_pd = page_idx; + /* + * Incomplete pages at most use the + * whole page. + */ + expected_size += block_size; + } else if (!pd.flags) { + /* + * Zero page has no compression flags. + */ + if (!zero_page_counted) { + expected_size += block_size; + zero_page_counted = 1; + } + } else if (pd.flags) { + /* Regular compressed page */ + expected_size += pd.size; + } + +next: + expected_size += sizeof(pd); + } + } + + if (stat64(dd->filename, &stat) < 0) { + error(INFO, "%s: cannot stat %s\n", + DISKDUMP_VALID() ? "diskdump" : "compressed kdump", + dd->filename); + goto err; + } + + if (expected_size > stat.st_size) { + error(WARNING, + "%s: may be truncated or incomplete\n" + " data_offset: %zu\n" + " block_size: %d\n" + " total_valid_pages: %lu\n" + " first_empty_pd: %lu\n" + " bytes required: %zu\n" + " dumpfile size: %zu\n\n", + dd->filename, dd->data_offset, + dd->block_size, dd->valid_pages[dd->max_sect_len], + first_empty_pd, expected_size, stat.st_size); } return TRUE; -- 2.32.0