/* 

 * diskdump.c 

 * 

 * The diskdump module optionally creates either ELF vmcore 

 * dumpfiles, or compressed dumpfiles derived from the LKCD format.

 * In the case of ELF vmcore files, since they are identical to 

 * netdump dumpfiles, the facilities in netdump.c are used.  For

 * compressed dumpfiles, the facilities in this file are used.

 *

 * Copyright (C) 2004-2015 David Anderson

 * Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.

 * Copyright (C) 2005  FUJITSU LIMITED

 * Copyright (C) 2005  NEC Corporation

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#define LZO

#define SNAPPY

#include "defs.h"

#include "diskdump.h"

#include "xen_dom0.h"

#include "vmcore.h"

#define BITMAP_SECT_LEN	4096

struct diskdump_data {

	char *filename;

	ulong flags;       /* DISKDUMP_LOCAL, plus anything else... */

        int dfd;           /* dumpfile file descriptor */

        FILE *ofp;         /* fprintf(dd->ofp, "xxx"); */

	int machine_type;  /* machine type identifier */

	/* header */

	struct disk_dump_header		*header;

	struct disk_dump_sub_header	*sub_header;

	struct kdump_sub_header		*sub_header_kdump;

	unsigned long long	max_mapnr;	/* 64bit max_mapnr */

	size_t	data_offset;

	int	block_size;

	int	block_shift;

	char	*bitmap;

	off_t	bitmap_len;

	char	*dumpable_bitmap;

	int	byte, bit;

	char	*compressed_page;	/* copy of compressed page data */

	char	*curbufptr;		/* ptr to uncompressed page buffer */

	unsigned char *notes_buf;	/* copy of elf notes */

	void	**nt_prstatus_percpu;

	uint	num_prstatus_notes;

	void	**nt_qemu_percpu;

	void	**nt_qemucs_percpu;

	uint	num_qemu_notes;

	void	**nt_vmcoredd_array;

	uint	num_vmcoredd_notes;

	/* page cache */

	struct page_cache_hdr {		/* header for each cached page */

		uint32_t pg_flags;

		uint64_t pg_addr;

		char *pg_bufptr;

		ulong pg_hit_count;

	} page_cache_hdr[DISKDUMP_CACHED_PAGES];

	char	*page_cache_buf;	/* base of cached buffer pages */

	int	evict_index;		/* next page to evict */

	ulong	evictions;		/* total evictions done */

	ulong	cached_reads;

	ulong  *valid_pages;

	ulong   accesses;

	ulong	snapshot_task;

};

static struct diskdump_data diskdump_data = { 0 };

static struct diskdump_data *dd = &diskdump_data;

ulong *diskdump_flags = &diskdump_data.flags;

static int __diskdump_memory_dump(FILE *);

static void dump_vmcoreinfo(FILE *);

static void dump_note_offsets(FILE *);

static char *vmcoreinfo_read_string(const char *);

static void diskdump_get_osrelease(void);

static int valid_note_address(unsigned char *);

/* For split dumpfile */

static struct diskdump_data **dd_list = NULL;

static int num_dd = 0;

static int num_dumpfiles = 0;

int dumpfile_is_split(void)

{

	return KDUMP_SPLIT();

}

void

map_cpus_to_prstatus_kdump_cmprs(void)

{

	void **nt_ptr;

	int online, i, j, nrcpus;

	size_t size;

	if (pc->flags2 & QEMU_MEM_DUMP_COMPRESSED)  /* notes exist for all cpus */

		goto resize_note_pointers;

	if (!(online = get_cpus_online()) || (online == kt->cpus) || 

	    machine_type("ARM64"))

		goto resize_note_pointers;

	if (CRASHDEBUG(1))

		error(INFO,

		    "cpus: %d online: %d NT_PRSTATUS notes: %d (remapping)\n",

			kt->cpus, online, dd->num_prstatus_notes);

	size = NR_CPUS * sizeof(void *);

	nt_ptr = (void **)GETBUF(size);

	BCOPY(dd->nt_prstatus_percpu, nt_ptr, size);

	BZERO(dd->nt_prstatus_percpu, size);

	/*

	 *  Re-populate the array with the notes mapping to online cpus

	 */

	nrcpus = (kt->kernel_NR_CPUS ? kt->kernel_NR_CPUS : NR_CPUS);

	for (i = 0, j = 0; i < nrcpus; i++) {

		if (in_cpu_map(ONLINE_MAP, i)) {

			dd->nt_prstatus_percpu[i] = nt_ptr[j++];

			dd->num_prstatus_notes = 

				MAX(dd->num_prstatus_notes, i+1);

		}

	}

	FREEBUF(nt_ptr);

resize_note_pointers:

	/*

	 *  For architectures that only utilize the note pointers

	 *  within this file, resize the arrays accordingly.

	 */

	if (machine_type("X86_64") || machine_type("X86") || 

	    machine_type("ARM64")) {

		if ((dd->nt_prstatus_percpu = realloc(dd->nt_prstatus_percpu, 

		    dd->num_prstatus_notes * sizeof(void *))) == NULL)

			error(FATAL, 

			    "compressed kdump: cannot realloc NT_PRSTATUS note pointers\n");

		if (dd->num_qemu_notes) {

			if  ((dd->nt_qemu_percpu = realloc(dd->nt_qemu_percpu, 

		    	    dd->num_qemu_notes * sizeof(void *))) == NULL)

				error(FATAL, 

				    "compressed kdump: cannot realloc QEMU note pointers\n");

			if  ((dd->nt_qemucs_percpu = realloc(dd->nt_qemucs_percpu,

			    dd->num_qemu_notes * sizeof(void *))) == NULL)

				error(FATAL,

				    "compressed kdump: cannot realloc QEMU note pointers\n");

		} else {

			free(dd->nt_qemu_percpu);

			free(dd->nt_qemucs_percpu);

		}

	}

}

static void 

add_diskdump_data(char* name)

{

#define DDL_SIZE 16

	int i;

	int sz = sizeof(void *);

	struct diskdump_data *ddp;

	if (dd_list == NULL) {

		dd_list = calloc(DDL_SIZE, sz);

		num_dd = DDL_SIZE;

	} else {

		for (i = 0; i < num_dumpfiles; i++) {

			ddp = dd_list[i];

                	if (same_file(ddp->filename, name))

				error(FATAL, 

				    "split dumpfiles are identical:\n"

				    "  %s\n  %s\n",

					ddp->filename, name);

			if (memcmp(ddp->header, dd->header,

			    sizeof(struct disk_dump_header)))

				error(FATAL, 

				    "split dumpfiles derived from different vmcores:\n"

				    "  %s\n  %s\n",

					ddp->filename, name);

		}

	}

	if (num_dumpfiles == num_dd) {

		/* expand list */

		struct diskdump_data **tmp;

		tmp = calloc(num_dd*2, sz);

		memcpy(tmp, dd_list, sz*num_dd);

		free(dd_list);

		dd_list = tmp;

		num_dd *= 2;

	}

	dd_list[num_dumpfiles] = dd;

	dd->flags |= DUMPFILE_SPLIT;

	dd->filename = name;

	if (CRASHDEBUG(1))

		fprintf(fp, "%s: start_pfn=%llu, end_pfn=%llu\n", name,

			dd->sub_header_kdump->start_pfn_64,

			dd->sub_header_kdump->end_pfn_64);

}

static void 

clean_diskdump_data(void)

{

	int i;

	if (dd_list == NULL)

		return;

	for (i=1; i

		free(dd_list[i]); /* NOTE: dd_list[0] is static dd */

	free(dd_list);

	dd_list = NULL;

	num_dumpfiles = 0;

	dd = &diskdump_data;

}

static inline int 

get_bit(char *map, unsigned long byte, int bit)

{

	return map[byte] & (1<

}

static inline int 

page_is_ram(unsigned long nr)

{

	return get_bit(dd->bitmap, nr >> 3, nr & 7);

}

static inline int 

page_is_dumpable(unsigned long nr)

{

	return dd->dumpable_bitmap[nr>>3] & (1 << (nr & 7));

}

static inline int 

dump_is_partial(const struct disk_dump_header *header)

{

	return header->bitmap_blocks >=

	    divideup(divideup(dd->max_mapnr, 8), dd->block_size) * 2;

}

static int 

open_dump_file(char *file)

{

	int fd;

	fd = open(file, O_RDONLY);

	if (fd < 0) {

		error(INFO, "diskdump / compressed kdump: unable to open dump file %s\n", file);

		return FALSE;

	}

	if (KDUMP_SPLIT())

		dd = calloc(1, sizeof(*dd));

	dd->dfd = fd;

	return TRUE;

}

void

process_elf32_notes(void *note_buf, unsigned long size_note)

{

	Elf32_Nhdr *nt;

	size_t index, len = 0;

	int num = 0;

	int vmcoredd_num = 0;

	int qemu_num = 0;

	for (index = 0; index < size_note; index += len) {

		nt = note_buf + index;

		if (nt->n_type == NT_PRSTATUS) {

			dd->nt_prstatus_percpu[num] = nt;

			num++;

		}

		len = sizeof(Elf32_Nhdr);

		if (STRNEQ((char *)nt + len, "QEMU")) {

			ulong *ptr =

			    (ulong *)((char *)nt + sizeof(Elf32_Nhdr) + nt->n_namesz);

			dd->nt_qemucs_percpu[qemu_num] =

			    (ulong *)roundup((ulong) ptr, 4);

			dd->nt_qemu_percpu[qemu_num] = nt;

			qemu_num++;

		}

		if (nt->n_type == NT_XEN_KDUMP_CR3 ||

		    nt->n_type == XEN_ELFNOTE_CRASH_INFO) {

			void *data = (char*)(nt + 1) +

				roundup(nt->n_namesz, 4);

			process_xen_note(nt->n_type, data, nt->n_descsz);

		}

		if (nt->n_type == NT_VMCOREDD &&

		    vmcoredd_num < NR_DEVICE_DUMPS) {

			dd->nt_vmcoredd_array[vmcoredd_num] = nt;

			vmcoredd_num++;

		}

		len = roundup(len + nt->n_namesz, 4);

		len = roundup(len + nt->n_descsz, 4);

	}

	if (num > 0) {

		pc->flags2 |= ELF_NOTES;

		dd->num_prstatus_notes = num;

	}

	if (qemu_num > 0) {

		pc->flags2 |= QEMU_MEM_DUMP_COMPRESSED;

		dd->num_qemu_notes = qemu_num;

	}

	if (vmcoredd_num > 0)

		dd->num_vmcoredd_notes = vmcoredd_num;

	return;

}

void

process_elf64_notes(void *note_buf, unsigned long size_note)

{

	Elf64_Nhdr *nt;

	size_t index, len = 0;

	int num = 0;

	int vmcoredd_num = 0;

	int qemu_num = 0;

	for (index = 0; index < size_note; index += len) {

		nt = note_buf + index;

		if (nt->n_type == NT_PRSTATUS) {

			dd->nt_prstatus_percpu[num] = nt;

			num++;

		}

		if ((nt->n_type == NT_TASKSTRUCT) && 

		    (STRNEQ((char *)nt + sizeof(Elf64_Nhdr), "SNAP"))) {

			pc->flags2 |= (LIVE_DUMP|SNAP);

			dd->snapshot_task = 

			    *((ulong *)((char *)nt + sizeof(Elf64_Nhdr) + nt->n_namesz));

		}

		len = sizeof(Elf64_Nhdr);

		if (STRNEQ((char *)nt + len, "QEMU")) {

			ulong *ptr =

			    (ulong *)((char *)nt + sizeof(Elf64_Nhdr) + nt->n_namesz);

			dd->nt_qemucs_percpu[qemu_num] =

			    (ulong *)roundup((ulong) ptr, 4);

			dd->nt_qemu_percpu[qemu_num] = nt;

			qemu_num++;

		}

		if (nt->n_type == NT_XEN_KDUMP_CR3 ||

		    nt->n_type == XEN_ELFNOTE_CRASH_INFO) {

			void *data = (char*)(nt + 1) +

				roundup(nt->n_namesz, 4);

			process_xen_note(nt->n_type, data, nt->n_descsz);

		}

		if (nt->n_type == NT_VMCOREDD &&

		    vmcoredd_num < NR_DEVICE_DUMPS) {

			dd->nt_vmcoredd_array[vmcoredd_num] = nt;

			vmcoredd_num++;

		}

		len = roundup(len + nt->n_namesz, 4);

		len = roundup(len + nt->n_descsz, 4);

	}

	if (num > 0) {

		pc->flags2 |= ELF_NOTES;

		dd->num_prstatus_notes = num;

	}

	if (qemu_num > 0) {

		pc->flags2 |= QEMU_MEM_DUMP_COMPRESSED;

		dd->num_qemu_notes = qemu_num;

	}

	if (vmcoredd_num > 0)

		dd->num_vmcoredd_notes = vmcoredd_num;

	return;

}

void 

x86_process_elf_notes(void *note_ptr, unsigned long size_note)

{

	if (machine_type("X86_64"))

		process_elf64_notes(note_ptr, size_note);

	else if (machine_type("X86"))

		process_elf32_notes(note_ptr, size_note);

}

#if defined(__i386__) && (defined(ARM) || defined(MIPS))

/*

 * The kdump_sub_header member offsets are different when the crash 

 * binary is built natively on an ARM host vs. when built with  

 * "make target=ARM" on an x86/x86_64 host.  This is because the

 * off_t structure members will be aligned on an 8-byte boundary when

 * compiled as an ARM binary -- which will be reflected in the 

 * kdump_sub_header in a compressed ARM kdump.  

 *

 * When crash is compiled as an x86 binary, these are the 

 * structure's offsets:

 * 

 * struct kdump_sub_header {

 * [0]     unsigned long   phys_base;

 * [4]     int             dump_level;         /  header_version 1 and later  /

 * [8]     int             split;              /  header_version 2 and later  /

 * [12]    unsigned long   start_pfn;          /  header_version 2 and later  /

 * [16]    unsigned long   end_pfn;            /  header_version 2 and later  /

 * [20]    off_t           offset_vmcoreinfo;  /  header_version 3 and later  /

 * [28]    unsigned long   size_vmcoreinfo;    /  header_version 3 and later  /

 * [32]    off_t           offset_note;        /  header_version 4 and later  /

 * [40]    unsigned long   size_note;          /  header_version 4 and later  /

 * [44]    off_t           offset_eraseinfo;   /  header_version 5 and later  /

 * [52]    unsigned long   size_eraseinfo;     /  header_version 5 and later  /

 * [56]    unsigned long long   start_pfn_64;  /  header_version 6 and later  /

 * [64]    unsigned long long   end_pfn_64;    /  header_version 6 and later  /

 * [72]    unsigned long long   max_mapnr_64;  /  header_version 6 and later  /

 * };

 * 

 * But when compiled on an ARM processor, each 64-bit "off_t" would be pushed

 * up to an 8-byte boundary:

 * 

 * struct kdump_sub_header {

 * [0]     unsigned long   phys_base;

 * [4]     int             dump_level;         /  header_version 1 and later  /

 * [8]     int             split;              /  header_version 2 and later  /

 * [12]    unsigned long   start_pfn;          /  header_version 2 and later  /

 * [16]    unsigned long   end_pfn;            /  header_version 2 and later  /

 * [24]    off_t           offset_vmcoreinfo;  /  header_version 3 and later  /

 * [32]    unsigned long   size_vmcoreinfo;    /  header_version 3 and later  /

 * [40]    off_t           offset_note;        /  header_version 4 and later  /

 * [48]    unsigned long   size_note;          /  header_version 4 and later  /

 * [56]    off_t           offset_eraseinfo;   /  header_version 5 and later  /

 * [64]    unsigned long   size_eraseinfo;     /  header_version 5 and later  /

 * [72]    unsigned long long   start_pfn_64;  /  header_version 6 and later  /

 * [80]    unsigned long long   end_pfn_64;    /  header_version 6 and later  /

 * [88]    unsigned long long   max_mapnr_64;  /  header_version 6 and later  /

 * };

 * 

 */

struct kdump_sub_header_ARM_target {

        unsigned long   phys_base;

        int             dump_level;         /* header_version 1 and later */

        int             split;              /* header_version 2 and later */

        unsigned long   start_pfn;          /* header_version 2 and later */

        unsigned long   end_pfn;            /* header_version 2 and later */

	int		pad1;

        off_t           offset_vmcoreinfo;  /* header_version 3 and later */

        unsigned long   size_vmcoreinfo;    /* header_version 3 and later */

	int 		pad2;	

        off_t           offset_note;        /* header_version 4 and later */

        unsigned long   size_note;          /* header_version 4 and later */

	int 		pad3;	

        off_t           offset_eraseinfo;   /* header_version 5 and later */

        unsigned long   size_eraseinfo;     /* header_version 5 and later */

	int		pad4;

	unsigned long long start_pfn_64;    /* header_version 6 and later */

	unsigned long long end_pfn_64;      /* header_version 6 and later */

	unsigned long long max_mapnr_64;    /* header_version 6 and later */

};

static void

arm_kdump_header_adjust(int header_version)

{

	struct kdump_sub_header *kdsh;

	struct kdump_sub_header_ARM_target *kdsh_ARM_target;

	kdsh = dd->sub_header_kdump;

	kdsh_ARM_target = (struct kdump_sub_header_ARM_target *)kdsh;

	if (header_version >= 3) {

		kdsh->offset_vmcoreinfo = kdsh_ARM_target->offset_vmcoreinfo; 

		kdsh->size_vmcoreinfo = kdsh_ARM_target->size_vmcoreinfo;

	}

	if (header_version >= 4) {

		kdsh->offset_note = kdsh_ARM_target->offset_note;

		kdsh->size_note = kdsh_ARM_target->size_note;

	}

	if (header_version >= 5) {

		kdsh->offset_eraseinfo = kdsh_ARM_target->offset_eraseinfo;

		kdsh->size_eraseinfo = kdsh_ARM_target->size_eraseinfo;

	}

	if (header_version >= 6) {

		kdsh->start_pfn_64 = kdsh_ARM_target->start_pfn_64;

		kdsh->end_pfn_64 = kdsh_ARM_target->end_pfn_64;

		kdsh->max_mapnr_64 = kdsh_ARM_target->max_mapnr_64;

	} else {

		kdsh->start_pfn_64 = kdsh_ARM_target->start_pfn;

		kdsh->end_pfn_64 = kdsh_ARM_target->end_pfn;

		kdsh->max_mapnr_64 = dd->max_mapnr;

	}

}

#endif  /* __i386__ && (ARM || MIPS) */

static int 

read_dump_header(char *file)

{

	struct disk_dump_header *header = NULL;

	struct disk_dump_sub_header *sub_header = NULL;

	struct kdump_sub_header *sub_header_kdump = NULL;

	size_t size;

	off_t bitmap_len;

	char *bufptr;

	size_t len;

	ssize_t bytes_read;

	int block_size = (int)sysconf(_SC_PAGESIZE);

	off_t offset;

	const off_t failed = (off_t)-1;

	ulong pfn;

	int i, j, max_sect_len;

	int is_split = 0;

	if (block_size < 0)

		return FALSE;

restart:

	if ((header = realloc(header, block_size)) == NULL)

		error(FATAL, "diskdump / compressed kdump: cannot malloc block_size buffer\n");

	if (FLAT_FORMAT()) {

		if (!read_flattened_format(dd->dfd, 0, header, block_size)) {

			error(FATAL, "diskdump / compressed kdump: cannot read header\n");

			goto err;

		}

	} else {

		if (lseek(dd->dfd, 0, SEEK_SET) == failed) {

			if (CRASHDEBUG(1))

				error(INFO, "diskdump / compressed kdump: cannot lseek dump header\n");

			goto err;

		}

		if (read(dd->dfd, header, block_size) < block_size) {

			if (CRASHDEBUG(1))

				error(INFO, "diskdump / compressed kdump: cannot read dump header\n");

			goto err;

		}

	}

	/* validate dump header */

	if (!memcmp(header->signature, DISK_DUMP_SIGNATURE,

				sizeof(header->signature))) {

		dd->flags |= DISKDUMP_LOCAL;

	} else if (!memcmp(header->signature, KDUMP_SIGNATURE,

				sizeof(header->signature))) {

		dd->flags |= KDUMP_CMPRS_LOCAL;

		if (header->header_version >= 1)

			dd->flags |= ERROR_EXCLUDED;

	} else {

		if (CRASHDEBUG(1))

			error(INFO, 

			    "diskdump / compressed kdump: dump does not have panic dump header\n");

		goto err;

	}

	if (CRASHDEBUG(1))

		fprintf(fp, "%s: header->utsname.machine: %s\n", 

			DISKDUMP_VALID() ? "diskdump" : "compressed kdump",

			header->utsname.machine);

	if (STRNEQ(header->utsname.machine, "i686") &&

	    machine_type_mismatch(file, "X86", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "x86_64") &&

	    machine_type_mismatch(file, "X86_64", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "ia64") &&

	    machine_type_mismatch(file, "IA64", NULL, 0))

		goto err;

	else if (STREQ(header->utsname.machine, "ppc") &&

	    machine_type_mismatch(file, "PPC", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "ppc64") &&

	    machine_type_mismatch(file, "PPC64", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "arm") &&

	    machine_type_mismatch(file, "ARM", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "mips") &&

	    machine_type_mismatch(file, "MIPS", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "s390x") &&

	    machine_type_mismatch(file, "S390X", NULL, 0))

		goto err;

	else if (STRNEQ(header->utsname.machine, "aarch64") &&

	    machine_type_mismatch(file, "ARM64", NULL, 0))

		goto err;

	if (header->block_size != block_size) {

		block_size = header->block_size;

		if (CRASHDEBUG(1))

			fprintf(fp, 

			    "retrying with different block/page size: %d\n", 

				header->block_size);

		goto restart;

	}

	dd->block_size  = header->block_size;

	dd->block_shift = ffs(header->block_size) - 1;

	if ((DISKDUMP_VALID() &&

             (sizeof(*header) + sizeof(void *) * header->nr_cpus > block_size)) ||

             header->nr_cpus <= 0) {

                error(WARNING, "%s: invalid nr_cpus value: %d\n",

                        DISKDUMP_VALID() ? "diskdump" : "compressed kdump",

                        header->nr_cpus);

		if (!machine_type("S390") && !machine_type("S390X") &&

		    !machine_type("X86") && !machine_type("X86_64")) {

			if (DISKDUMP_VALID())

				goto err;

		}

        }

	/* read sub header */

	offset = (off_t)block_size;

	if (DISKDUMP_VALID()) {

		if ((sub_header = malloc(block_size)) == NULL)

			error(FATAL, "diskdump: cannot malloc sub_header buffer\n");

		if (FLAT_FORMAT()) {

			if (!read_flattened_format(dd->dfd, offset, sub_header, block_size)) {

				error(INFO, "diskdump: cannot read dump sub header\n");

				goto err;

			}

		} else {

			if (lseek(dd->dfd, offset, SEEK_SET) == failed) {

				error(INFO, "diskdump: cannot lseek dump sub header\n");

				goto err;

			}

			if (read(dd->dfd, sub_header, block_size) < block_size) {

				error(INFO, "diskdump: cannot read dump sub header\n");

				goto err;

			}

		}

		dd->sub_header = sub_header;

		/* the 64bit max_mapnr only exists in sub-header of compressed

		 * kdump file, if it's not a compressed kdump file, we have to

		 * use the old 32bit max_mapnr in dumpfile header.

		 * max_mapnr may be truncated here.

		 */

		dd->max_mapnr = header->max_mapnr;

	} else if (KDUMP_CMPRS_VALID()) {

		if ((sub_header_kdump = malloc(block_size)) == NULL)

			error(FATAL, "compressed kdump: cannot malloc sub_header_kdump buffer\n");

		if (FLAT_FORMAT()) {

			if (!read_flattened_format(dd->dfd, offset, sub_header_kdump, block_size)) {

				error(INFO, "compressed kdump: cannot read dump sub header\n");

				goto err;

			}

		} else {

			if (lseek(dd->dfd, offset, SEEK_SET) == failed) {

				error(INFO, "compressed kdump: cannot lseek dump sub header\n");

				goto err;

			}

			if (read(dd->dfd, sub_header_kdump, block_size) < block_size) {

				error(INFO, "compressed kdump: cannot read dump sub header\n");

				goto err;

			}

		}

		dd->sub_header_kdump = sub_header_kdump;

#if defined(__i386__) && (defined(ARM) || defined(MIPS))

		arm_kdump_header_adjust(header->header_version);

#endif

		/* use 64bit max_mapnr in compressed kdump file sub-header */

		if (header->header_version >= 6)

			dd->max_mapnr = dd->sub_header_kdump->max_mapnr_64;

		else {

			dd->sub_header_kdump->start_pfn_64

				= dd->sub_header_kdump->start_pfn;

			dd->sub_header_kdump->end_pfn_64

				= dd->sub_header_kdump->end_pfn;

		}

	}

	if (header->header_version < 6)

		dd->max_mapnr = header->max_mapnr;

	/* read memory bitmap */

	bitmap_len = (off_t)block_size * header->bitmap_blocks;

	dd->bitmap_len = bitmap_len;

	offset = (off_t)block_size * (1 + header->sub_hdr_size);

	if ((dd->bitmap = malloc(bitmap_len)) == NULL)

		error(FATAL, "%s: cannot malloc bitmap buffer\n",

			DISKDUMP_VALID() ? "diskdump" : "compressed kdump");

	dd->dumpable_bitmap = calloc(bitmap_len, 1);

	if (CRASHDEBUG(8))

		fprintf(fp, "%s: memory bitmap offset: %llx\n",

			DISKDUMP_VALID() ? "diskdump" : "compressed kdump",

			(ulonglong)offset);

	if (FLAT_FORMAT()) {

		if (!read_flattened_format(dd->dfd, offset, dd->bitmap, bitmap_len)) {

			error(INFO, "%s: cannot read memory bitmap\n",

				DISKDUMP_VALID() ? "diskdump" : "compressed kdump");

			goto err;

		}

	} else {

		if (lseek(dd->dfd, offset, SEEK_SET) == failed) {

			error(INFO, "%s: cannot lseek memory bitmap\n",

				DISKDUMP_VALID() ? "diskdump" : "compressed kdump");

			goto err;

		}

		bufptr = dd->bitmap;

		len = bitmap_len;

		while (len) {

			bytes_read = read(dd->dfd, bufptr, len);

			if (bytes_read <= 0) {

				error(INFO, "%s: cannot read memory bitmap\n",

					DISKDUMP_VALID() ? "diskdump"

					: "compressed kdump");

				goto err;

			}

			len -= bytes_read;

			bufptr += bytes_read;

		}

	}

	if (dump_is_partial(header))

		memcpy(dd->dumpable_bitmap, dd->bitmap + bitmap_len/2,

		       bitmap_len/2);

	else

		memcpy(dd->dumpable_bitmap, dd->bitmap, bitmap_len);

	dd->data_offset

		= (1UL + header->sub_hdr_size + header->bitmap_blocks)

		* header->block_size;

	dd->header = header;

	if (machine_type("ARM"))

		dd->machine_type = EM_ARM;

	else if (machine_type("MIPS"))

		dd->machine_type = EM_MIPS;

	else if (machine_type("X86"))

		dd->machine_type = EM_386;

	else if (machine_type("X86_64"))

		dd->machine_type = EM_X86_64;

	else if (machine_type("IA64"))

		dd->machine_type = EM_IA_64;

	else if (machine_type("PPC"))

		dd->machine_type = EM_PPC;

	else if (machine_type("PPC64"))

		dd->machine_type = EM_PPC64;

	else if (machine_type("S390X"))

		dd->machine_type = EM_S390;

	else if (machine_type("ARM64"))

		dd->machine_type = EM_AARCH64;

	else if (machine_type("SPARC64"))

		dd->machine_type = EM_SPARCV9;

	else {

		error(INFO, "%s: unsupported machine type: %s\n", 

			DISKDUMP_VALID() ? "diskdump" : "compressed kdump",

			MACHINE_TYPE);

		goto err;

	}

	/* process elf notes data */

	if (KDUMP_CMPRS_VALID() && !(dd->flags & NO_ELF_NOTES) &&

		(dd->header->header_version >= 4) &&

		(sub_header_kdump->offset_note) &&

		(sub_header_kdump->size_note) && (machdep->process_elf_notes)) {

		size = sub_header_kdump->size_note;

		offset = sub_header_kdump->offset_note;

		if ((dd->notes_buf = malloc(size)) == NULL)

			error(FATAL, "compressed kdump: cannot malloc notes"

				" buffer\n");

		if ((dd->nt_prstatus_percpu = malloc(NR_CPUS * sizeof(void *))) == NULL)

			error(FATAL, "compressed kdump: cannot malloc pointer"

				" to NT_PRSTATUS notes\n");

		if ((dd->nt_qemu_percpu = malloc(NR_CPUS * sizeof(void *))) == NULL)

			error(FATAL, "qemu mem dump compressed: cannot malloc pointer"

				" to QEMU notes\n");

		if ((dd->nt_qemucs_percpu = malloc(NR_CPUS * sizeof(void *))) == NULL)

			error(FATAL, "qemu mem dump compressed: cannot malloc pointer"

				" to QEMUCS notes\n");

		if ((dd->nt_vmcoredd_array = malloc(NR_DEVICE_DUMPS * sizeof(void *))) == NULL)

			error(FATAL, "compressed kdump: cannot malloc array for "

				     "vmcore device dump notes\n");

		if (FLAT_FORMAT()) {

			if (!read_flattened_format(dd->dfd, offset, dd->notes_buf, size)) {

				error(INFO, "compressed kdump: cannot read notes data"

					"\n");

				goto err;

			}

		} else {

			if (lseek(dd->dfd, offset, SEEK_SET) == failed) {

				error(INFO, "compressed kdump: cannot lseek notes data\n");

				goto err;

			}

			if (read(dd->dfd, dd->notes_buf, size) < size) {

				error(INFO, "compressed kdump: cannot read notes data"

					"\n");

				goto err;

			}

		}

		machdep->process_elf_notes(dd->notes_buf, size);

	}

	/* Check if dump file contains erasesinfo data */

	if (KDUMP_CMPRS_VALID() && (dd->header->header_version >= 5) &&

		(sub_header_kdump->offset_eraseinfo) &&

		(sub_header_kdump->size_eraseinfo))

		pc->flags2 |= ERASEINFO_DATA;

	if (KDUMP_CMPRS_VALID() && (dd->header->header_version >= 3) &&

		dd->sub_header_kdump->offset_vmcoreinfo &&

		dd->sub_header_kdump->size_vmcoreinfo)

		pc->flags2 |= VMCOREINFO;

	if (KDUMP_CMPRS_VALID() && 

	    (dd->header->status & DUMP_DH_COMPRESSED_INCOMPLETE))

		pc->flags2 |= INCOMPLETE_DUMP;

	if (KDUMP_CMPRS_VALID() && 

	    (dd->header->status & DUMP_DH_EXCLUDED_VMEMMAP))

		pc->flags2 |= EXCLUDED_VMEMMAP;

	/* For split dumpfile */

	if (KDUMP_CMPRS_VALID()) {

		is_split = ((dd->header->header_version >= 2) &&

		            (sub_header_kdump->split));

		if ((is_split && (num_dumpfiles != 0) && (dd_list == NULL))||

		    (!is_split && (num_dumpfiles != 0))) {

			clean_diskdump_data();

			goto err;

		}

		if (is_split)

			add_diskdump_data(file);

		num_dumpfiles++;

	}

	if (!is_split) {

		max_sect_len = divideup(dd->max_mapnr, BITMAP_SECT_LEN);

		pfn = 0;

		dd->filename = file;

	}

	else {

		unsigned long long start = sub_header_kdump->start_pfn_64;

		unsigned long long end = sub_header_kdump->end_pfn_64;

		max_sect_len = divideup(end - start + 1, BITMAP_SECT_LEN);

		pfn = start;

	}

	dd->valid_pages = calloc(sizeof(ulong), max_sect_len + 1);

	for (i = 1; i < max_sect_len + 1; i++) {

		dd->valid_pages[i] = dd->valid_pages[i - 1];