/*
 * sadump.h - core analysis suite
 *
 * Copyright (c) 2011 FUJITSU LIMITED
 *
 * 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.
 *
 * Author: HATAYAMA Daisuke <d.hatayama@jp.fujitsu.com>
 */

#include "defs.h"
#include "sadump.h"
#include <arpa/inet.h> /* htonl, htons */
#include <elf.h>
#include <inttypes.h>

enum {
	failed = -1
};

static struct sadump_data sadump_data = { 0 };
static struct sadump_data *sd = &sadump_data;

static int read_device(void *buf, size_t bytes, ulong *offset);
static int read_dump_header(char *file);
static int add_disk(char *file);
static int open_dump_file(char *file);
static int open_disk(char *file);
static uint64_t paddr_to_pfn(physaddr_t paddr);
static inline int is_set_bit(char *bitmap, uint64_t pfn);
static inline int page_is_ram(uint64_t nr);
static inline int page_is_dumpable(uint64_t nr);
static int lookup_diskset(uint64_t whole_offset, int *diskid, uint64_t *disk_offset);
static struct tm *efi_time_t_to_tm(const efi_time_t *e);
static char * guid_to_str(efi_guid_t *guid, char *buf, size_t buflen);
static int verify_magic_number(uint32_t magicnum[DUMP_PART_HEADER_MAGICNUM_SIZE]);
static ulong per_cpu_ptr(ulong ptr, int cpu);
static ulong early_per_cpu_ptr(char *symbol, struct syment *sym, int cpu);
static ulong legacy_per_cpu_ptr(ulong ptr, int cpu);
static int get_prstatus_from_crash_notes(int cpu, char *prstatus);
static void display_smram_cpu_state(int apicid, struct sadump_smram_cpu_state *s);
static int cpu_to_apicid(int cpu, int *apicid);
static int get_sadump_smram_cpu_state(int cpu, struct sadump_smram_cpu_state *smram);
static int block_table_init(void);
static uint64_t pfn_to_block(uint64_t pfn);

struct sadump_data *
sadump_get_sadump_data(void)
{
	if (!SADUMP_VALID() || !SADUMP_DUMPFILE())
		return NULL;

	return &sadump_data;
}

int
sadump_cleanup_sadump_data(void)
{
	int i;

	if (!SADUMP_VALID() || !SADUMP_DUMPFILE())
		return FALSE;

	if (sd->flags & SADUMP_DISKSET) {
		for (i = 1; i < sd->sd_list_len; ++i) {
			if (sd->sd_list[i]->dfd)
				close(sd->sd_list[i]->dfd);
			free(sd->sd_list[i]->header);
			free(sd->sd_list[i]);
		}
	}

	close(sd->dfd);
	free(sd->header);
	free(sd->dump_header);
	free(sd->diskset_header);
	free(sd->bitmap);
	free(sd->dumpable_bitmap);
	free(sd->page_buf);
	free(sd->block_table);
	if (sd->sd_list[0])
		free(sd->sd_list[0]);
	free(sd->sd_list);

	memset(&sadump_data, 0, sizeof(sadump_data));

	pc->flags &= ~SADUMP;
	pc->dumpfile = NULL;
	pc->readmem = NULL;
	pc->writemem = NULL;

	return TRUE;
}

static int
read_device(void *buf, size_t bytes, ulong *offset)
{
	if (lseek(sd->dfd, *offset, SEEK_SET) == failed) {
		error(INFO, "sadump: cannot lseek dump device\n");
		return FALSE;
	}
	if (read(sd->dfd, buf, bytes) < bytes) {
		error(INFO, "sadump: cannot read dump device\n");
		return FALSE;
	}
	*offset += bytes;
	return TRUE;
}

static int
read_dump_header(char *file)
{
	struct sadump_part_header *sph = NULL;
	struct sadump_header *sh = NULL;
	struct sadump_disk_set_header *new, *sdh = NULL;
	struct sadump_media_header *smh = NULL;
	struct sadump_diskset_data *sd_list_len_0 = NULL;
	size_t block_size = SADUMP_DEFAULT_BLOCK_SIZE;
	ulong flags = 0;
	ulong offset = 0, sub_hdr_offset, data_offset;
	uint32_t smram_cpu_state_size = 0;
	ulong bitmap_len, dumpable_bitmap_len;
	char *bitmap = NULL, *dumpable_bitmap = NULL, *page_buf = NULL;
	char guid1[SADUMP_EFI_GUID_TEXT_REPR_LEN+1];
	char guid2[SADUMP_EFI_GUID_TEXT_REPR_LEN+1];

	sph = malloc(block_size);
	if (!sph) {
		error(INFO, "sadump: cannot allocate partition header buffer\n");
		goto err;
	}

	sdh = malloc(block_size);
	if (!sdh) {
		error(INFO, "sadump: cannot allocate disk set header buffer\n");
		goto err;
	}

	sh = malloc(block_size);
	if (!sh) {
		error(INFO, "sadump: cannot allocate dump header buffer\n");
		goto err;
	}

	smh = malloc(block_size);
	if (!smh) {
		error(INFO, "sadump: cannot allocate media header buffer\n");
		goto err;
	}

restart:
	if (!read_device(sph, block_size, &offset)) {
		error(INFO, "sadump: cannot read partition header\n");
		goto err;
	}

	if (sph->signature1 != SADUMP_SIGNATURE1 ||
	    sph->signature2 != SADUMP_SIGNATURE2) {

		flags |= SADUMP_MEDIA;

		if (CRASHDEBUG(1))
			error(INFO, "sadump: read dump device as media "
			      "format\n");

		offset = 0;

		if (!read_device(smh, block_size, &offset)) {
			error(INFO, "sadump: cannot read media header\n");
			goto err;
		}

		if (!read_device(sph, block_size, &offset)) {
			error(INFO, "sadump: cannot read partition header\n");
			goto err;
		}

		if (sph->signature1 != SADUMP_SIGNATURE1 ||
		    sph->signature2 != SADUMP_SIGNATURE2) {
			if (CRASHDEBUG(1))
				error(INFO, "sadump: does not have partition "
				      "header\n");
			goto err;
		}

	}

	if (!verify_magic_number(sph->magicnum)) {
		error(INFO, "sadump: invalid magic number\n");
		goto err;
	}

	if (!(flags & SADUMP_MEDIA) && sph->set_disk_set) {
		uint32_t header_blocks;
		size_t header_size;

		flags |= SADUMP_DISKSET;

		if (CRASHDEBUG(1))
			error(INFO, "sadump: read dump device as diskset\n");

		if (sph->set_disk_set != 1 ||
		    sph->set_disk_set > SADUMP_MAX_DISK_SET_NUM) {
			if (CRASHDEBUG(1))
				error(INFO, "sadump: invalid disk set number: "
				      "%d\n",
				      sph->set_disk_set);
			goto err;
		}

		if (!read_device(&header_blocks, sizeof(uint32_t), &offset)) {
			error(INFO, "sadump: cannot read disk set header "
			      "size\n");
			goto err;
		}

		offset -= sizeof(uint32_t);
		header_size = header_blocks * block_size;

		if (header_size > block_size) {
			new = realloc(sdh, header_size);
			if (!new) {
				error(INFO, "sadump: cannot re-allocate disk "
				      "set buffer\n");
				goto err;
			}
			sdh = new;
		}

		if (!read_device(sdh, header_size, &offset)) {
			error(INFO, "sadump: cannot read disk set header\n");
			goto err;
		}

	}

	if (!read_device(sh, block_size, &offset)) {
		error(INFO, "sadump: cannot read dump header\n");
		goto err;
	}

	sub_hdr_offset = offset;

	if (strncmp(sh->signature, SADUMP_SIGNATURE, 8) != 0) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: does not have dump header\n");
		goto err;
	}

	if (flags & SADUMP_MEDIA) {

		if (memcmp(&sph->sadump_id, &smh->sadump_id,
			   sizeof(efi_guid_t)) != 0) {
			if (CRASHDEBUG(1))
				error(INFO, "sadump: system ID mismatch\n"
				      "  partition header: %s\n"
				      "  media header: %s\n",
				      guid_to_str(&sph->sadump_id, guid1, sizeof(guid1)),
				      guid_to_str(&smh->sadump_id, guid2, sizeof(guid2)));
			goto err;
		}

		if (memcmp(&sph->disk_set_id, &smh->disk_set_id,
			   sizeof(efi_guid_t)) != 0) {
			if (CRASHDEBUG(1))
				error(INFO, "sadump: disk set ID mismatch\n"
				      "  partition header: %s\n"
				      "  media header: %s\n",
				      guid_to_str(&sph->disk_set_id, guid1, sizeof(guid1)),
				      guid_to_str(&smh->disk_set_id, guid2, sizeof(guid2)));
			goto err;
		}

		if (memcmp(&sph->time_stamp, &smh->time_stamp,
			   sizeof(efi_time_t)) != 0) {
			if (CRASHDEBUG(1)) {
				error(INFO, "sadump: time stamp mismatch\n");
				error(INFO, "sadump:   partition header: %s\n",
				      strip_linefeeds(asctime
						      (efi_time_t_to_tm
						       (&sph->time_stamp))));
				error(INFO, "sadump:   media header: %s\n",
				      strip_linefeeds(asctime
						      (efi_time_t_to_tm
						       (&smh->time_stamp))));
			}
		}

		if (smh->sequential_num != 1) {
			error(INFO, "sadump: first media file has sequential "
			      "number %d\n", smh->sequential_num);
			goto err;
		}

	}

	if (sh->block_size != block_size) {
		block_size = sh->block_size;
		offset = 0;
		goto restart;
	}

	if (CRASHDEBUG(1)) {
		if (flags & SADUMP_MEDIA)
			error(INFO, "sadump: media backup file\n");

		else if (flags & SADUMP_DISKSET)
			error(INFO, "sadump: diskset configuration with %d "
			      "disks\n", sdh->disk_num);

		else
			error(INFO, "sadump: single partition "
			      "configuration\n");
	}

	flags |= SADUMP_LOCAL;

	switch (sh->header_version) {
	case 0:
		sd->max_mapnr = (uint64_t)sh->max_mapnr;
		break;
	default:
		error(WARNING,
		      "sadump: unsupported header version: %u\n"
		      "sadump: assuming header version: 1\n",
		      sh->header_version);
	case 1:
		sd->max_mapnr = sh->max_mapnr_64;
		break;
	}

	if (sh->sub_hdr_size > 0) {
		if (!read_device(&smram_cpu_state_size, sizeof(uint32_t),
				 &offset)) {
			error(INFO,
			      "sadump: cannot read SMRAM CPU STATE size\n");
			goto err;
		}
		smram_cpu_state_size /= sh->nr_cpus;

		offset -= sizeof(uint32_t);
		offset += sh->sub_hdr_size * block_size;
	}

	if (!sh->bitmap_blocks) {
		error(INFO, "sadump: bitmap_blocks is zero\n");
		goto err;
	}
	bitmap_len = block_size * sh->bitmap_blocks;
	bitmap = calloc(bitmap_len, 1);
	if (!bitmap) {
		error(INFO, "sadump: cannot allocate memory for bitmap "
		      "buffer\n");
		goto err;
	}
	if (!read_device(bitmap, bitmap_len, &offset)) {
		error(INFO, "sadump: cannot read bitmap\n");
		goto err;
	}

	if (!sh->dumpable_bitmap_blocks) {
		error(INFO, "sadump: dumpable_bitmap_blocks is zero\n");
		goto err;
	}
	dumpable_bitmap_len = block_size * sh->dumpable_bitmap_blocks;
	dumpable_bitmap = calloc(dumpable_bitmap_len, 1);
	if (!dumpable_bitmap) {
		error(INFO, "sadump: cannot allocate memory for "
		      "dumpable_bitmap buffer\n");
		goto err;
	}
	if (!read_device(dumpable_bitmap, dumpable_bitmap_len, &offset)) {
		error(INFO, "sadump: cannot read dumpable bitmap\n");
		goto err;
	}

	data_offset = offset;

	page_buf = malloc(block_size);
	if (!page_buf) {
		error(INFO, "sadump: cannot allocate page buffer\n");
		goto err;
	}

	sd->filename = file;

	/*
	 * Switch to zero excluded mode by default on sadump-related
	 * formats because some Fujitsu troubleshooting software
	 * assumes the behavior.
	 */
	sd->flags = flags | SADUMP_ZERO_EXCLUDED;

	if (machine_type("X86"))
		sd->machine_type = EM_386;
	else if (machine_type("X86_64"))
		sd->machine_type = EM_X86_64;
	else {
		error(INFO, "sadump: unsupported machine type: %s\n",
		      MACHINE_TYPE);
		goto err;
	}

	sd->data_offset = data_offset;
	sd->block_size = block_size;
	sd->block_shift = ffs(sd->block_size) - 1;

	sd->bitmap = bitmap;
	sd->dumpable_bitmap = dumpable_bitmap;

	sd->sub_hdr_offset = sub_hdr_offset;
	sd->smram_cpu_state_size = smram_cpu_state_size;

	sd->header = sph;
	sd->dump_header = sh;
	if (flags & SADUMP_DISKSET)
		sd->diskset_header = sdh;
	if (flags & SADUMP_MEDIA)
		sd->media_header = smh;

	sd->page_buf = page_buf;

	if (flags & SADUMP_DISKSET) {

		sd_list_len_0 = malloc(sizeof(struct sadump_diskset_data));
		if (!sd_list_len_0) {
			error(INFO,
			      "sadump: cannot allocate diskset data buffer\n");
			goto err;
		}

		sd_list_len_0->filename = sd->filename;
		sd_list_len_0->dfd = sd->dfd;
		sd_list_len_0->header = sd->header;
		sd_list_len_0->data_offset = sd->data_offset;

		sd->sd_list = malloc(sizeof(struct sadump_diskset_data *));
		if (!sd->sd_list) {
			error(INFO,
			      "sadump: cannot allocate diskset list buffer\n");
			goto err;
		}

		sd->sd_list_len = 1;
		sd->sd_list[0] = sd_list_len_0;
	}

	if (!block_table_init()) {
		error(INFO, "sadump: cannot initialize block hash table\n");
		goto err;
	}

	if (!(flags & SADUMP_DISKSET))
		free(sdh);

	if (!(flags & SADUMP_MEDIA))
		free(smh);

	return TRUE;

err:
	close(sd->dfd);

	free(sph);
	free(sdh);
	free(sh);
	free(smh);
	free(bitmap);
	free(dumpable_bitmap);
	free(page_buf);
	free(sd_list_len_0);

	free(sd->sd_list);

	return FALSE;
}

static int
add_disk(char *file)
{
	struct sadump_part_header *ph;
	struct sadump_diskset_data *this_disk;
	int diskid;
	char guid1[SADUMP_EFI_GUID_TEXT_REPR_LEN+1];
	char guid2[SADUMP_EFI_GUID_TEXT_REPR_LEN+1];

	diskid = sd->sd_list_len - 1;
	this_disk = sd->sd_list[diskid];

	if (CRASHDEBUG(1))
		error(INFO, "sadump: add disk #%d\n", diskid+1);

	ph = malloc(sd->block_size);
	if (!ph) {
		error(INFO, "sadump: cannot malloc block_size buffer\n");
		return FALSE;
	}

	if (lseek(this_disk->dfd, 0, SEEK_SET) == failed) {
		error(INFO, "sadump: cannot lseek dump partition header\n");
		free(ph);
		return FALSE;
	}
	if (read(this_disk->dfd, ph, sd->block_size) < sd->block_size) {
		error(INFO, "sadump: cannot read dump partition header\n");
		free(ph);
		return FALSE;
	}

	if (ph->signature1 != SADUMP_SIGNATURE1 ||
	    ph->signature2 != SADUMP_SIGNATURE2) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: does not have partition header\n");
		free(ph);
		return FALSE;
	}

	if (memcmp(&sd->header->sadump_id, &ph->sadump_id,
		   sizeof(efi_guid_t)) != 0) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: system ID mismatch\n"
			      "  partition header on disk #1: %s\n"
			      "  partition header on disk #%d: %s\n",
			      guid_to_str(&sd->header->sadump_id, guid1,
					  sizeof(guid1)),
			      diskid+1,
			      guid_to_str(&ph->sadump_id, guid2,
					  sizeof(guid2)));
		free(ph);
		return FALSE;
	}

	if (memcmp(&sd->header->disk_set_id, &ph->disk_set_id, sizeof(efi_guid_t)) != 0) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: disk set ID mismatch\n"
			      "  partition header on disk #1: %s\n"
			      "  partition header on disk #%d: %s\n",
			      guid_to_str(&sd->header->disk_set_id, guid1,
					  sizeof(guid1)),
			      diskid+1,
			      guid_to_str(&ph->disk_set_id, guid2,
					  sizeof(guid2)));
		free(ph);
		return FALSE;
	}

	if (memcmp(&sd->diskset_header->vol_info[diskid - 1].id, &ph->vol_id,
		   sizeof(efi_guid_t)) != 0) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: volume ID mismatch\n"
			      "  disk set header on disk #1: %s\n"
			      "  partition header on disk #%d: %s\n",
			      guid_to_str(&sd->diskset_header->vol_info[diskid-1].id,
					  guid1, sizeof(guid1)),
			      diskid+1,
			      guid_to_str(&ph->vol_id, guid2, sizeof(guid2)));
		free(ph);
		return FALSE;
	}

	if (memcmp(&sd->header->time_stamp, &ph->time_stamp,
		   sizeof(efi_time_t)) != 0) {
		if (CRASHDEBUG(1)) {
			error(INFO, "sadump: time stamp mismatch\n");
			error(INFO,
			      "sadump:   partition header on disk #1: %s\n",
			      strip_linefeeds(asctime
					      (efi_time_t_to_tm
					       (&sd->header->time_stamp))));
			error(INFO,
			      "sadump:   partition header on disk #%d: %s\n",
			      diskid+1,
			      strip_linefeeds(asctime
					      (efi_time_t_to_tm
					       (&ph->time_stamp))));
		}
	}

	if (diskid != ph->set_disk_set - 1) {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: wrong disk order; "
			      "#%d expected but #%d given\n",
			      diskid+1, ph->set_disk_set);
		free(ph);
		return FALSE;
	}

	this_disk->header = ph;
	this_disk->data_offset = sd->block_size;
	this_disk->filename = file;

	return TRUE;
}

static int
open_dump_file(char *file)
{
	int fd;

	fd = open(file, O_RDONLY);
	if (fd < 0) {
		error(INFO, "sadump: unable to open dump file %s", file);
		return FALSE;
	}

	sd->dfd = fd;

	return TRUE;
}

static int
open_disk(char *file)
{
	struct sadump_diskset_data *this_disk;

	sd->sd_list_len++;

	if (CRASHDEBUG(1))
		error(INFO, "sadump: open disk #%d\n", sd->sd_list_len);

	if (sd->sd_list_len > sd->diskset_header->disk_num) {
		error(INFO, "sadump: too many diskset arguments; "
		      "this diskset consists of %d disks\n",
		      sd->diskset_header->disk_num);
		return FALSE;
	}

	sd->sd_list = realloc(sd->sd_list,
			      sd->sd_list_len *
			      sizeof(struct sadump_diskset_data *));
	if (!sd->sd_list) {
		if (CRASHDEBUG(1)) {
			error(INFO, "sadump: cannot malloc diskset list buffer\n");
		}
		return FALSE;
	}

	this_disk = malloc(sizeof(struct sadump_diskset_data));
	if (!this_disk) {
		if (CRASHDEBUG(1)) {
			error(INFO, "sadump: cannot malloc diskset data buffer\n");
		}
		return FALSE;
	}
	memset(this_disk, 0, sizeof(*this_disk));
	sd->sd_list[sd->sd_list_len - 1] = this_disk;

	this_disk->dfd = open(file, O_RDONLY);
	if (!this_disk->dfd) {
		free(this_disk);
		error(INFO, "sadump: unable to open dump file %s", file);
		return FALSE;
	}

	return TRUE;
}

int is_sadump(char *file)
{
	if (SADUMP_VALID()) {

		if (!(sd->flags & SADUMP_DISKSET)) {
			if (CRASHDEBUG(1))
				error(INFO, "sadump: does not support multiple"
				      " file formats\n");
			(void) sadump_cleanup_sadump_data();
			return FALSE;
		}

		if (!open_disk(file) || !add_disk(file)) {
			(void) sadump_cleanup_sadump_data();
			return FALSE;
		}

		return TRUE;
	}

	if (!open_dump_file(file) || !read_dump_header(file))
		return FALSE;

	return TRUE;
}

int sadump_is_diskset(void)
{
	if (!SADUMP_VALID())
		return FALSE;

	return !!(sd->flags & SADUMP_DISKSET);
}

uint sadump_page_size(void)
{
	return sd->dump_header->block_size;
}

/*
 * Translate physical address in paddr to PFN number. This means normally that
 * we just shift paddr by some constant.
 */
static uint64_t
paddr_to_pfn(physaddr_t paddr)
{
	return paddr >> sd->block_shift;
}

static inline int
is_set_bit(char *bitmap, uint64_t pfn)
{
	ulong index, bit;

	index = pfn >> 3;
	bit = 7 - (pfn & 7);

	return !!(bitmap[index] & (1UL << bit));
}

static inline int
page_is_ram(uint64_t nr)
{
	return is_set_bit(sd->bitmap, nr);
}

static inline int
page_is_dumpable(uint64_t nr)
{
	return is_set_bit(sd->dumpable_bitmap, nr);
}

static int
lookup_diskset(uint64_t whole_offset, int *diskid, uint64_t *disk_offset)
{
	uint64_t offset = whole_offset;
	int i;

	for (i = 0; i < sd->sd_list_len; ++i) {
		uint64_t used_device_i, ram_size;
		ulong data_offset_i;

		used_device_i = sd->sd_list[i]->header->used_device;
		data_offset_i = sd->sd_list[i]->data_offset;

		ram_size = used_device_i - data_offset_i;

		if (offset < ram_size)
			break;
		offset -= ram_size;
	}

	if (i == sd->sd_list_len)
		return FALSE;

	*diskid = i;
	*disk_offset = offset;

	return TRUE;
}

int read_sadump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
	physaddr_t curpaddr ATTRIBUTE_UNUSED;
	uint64_t pfn, whole_offset, perdisk_offset, block;
	ulong page_offset;
	int dfd;

	if (sd->flags & SADUMP_KDUMP_BACKUP &&
	    paddr >= sd->backup_src_start &&
	    paddr < sd->backup_src_start + sd->backup_src_size) {
		ulong orig_paddr;

		orig_paddr = paddr;
		paddr += sd->backup_offset - sd->backup_src_start;

		if (CRASHDEBUG(1))
			error(INFO, "sadump: kdump backup region: %#llx => %#llx\n",
			      orig_paddr, paddr);

	}

	pfn = paddr_to_pfn(paddr);

	curpaddr = paddr & ~((physaddr_t)(sd->block_size-1));
	page_offset = paddr & ((physaddr_t)(sd->block_size-1));

	if ((pfn >= sd->max_mapnr) || !page_is_ram(pfn))
		return SEEK_ERROR;
	if (!page_is_dumpable(pfn)) {
		if (!(sd->flags & SADUMP_ZERO_EXCLUDED))
			return PAGE_EXCLUDED;
		memset(bufptr, 0, cnt);
		return cnt;
	}

	block = pfn_to_block(pfn);

	whole_offset = block * sd->block_size;

	if (sd->flags & SADUMP_DISKSET) {
		int diskid;

		if (!lookup_diskset(whole_offset, &diskid, &perdisk_offset))
			return SEEK_ERROR;

		dfd = sd->sd_list[diskid]->dfd;
		perdisk_offset += sd->sd_list[diskid]->data_offset;

	} else {
		dfd = sd->dfd;
		perdisk_offset = whole_offset + sd->data_offset;

	}

	if (lseek(dfd, perdisk_offset, SEEK_SET) == failed)
		return SEEK_ERROR;

	if (read(dfd, sd->page_buf, sd->block_size) != sd->block_size)
		return READ_ERROR;

	memcpy(bufptr, sd->page_buf + page_offset, cnt);

	return cnt;
}

int write_sadump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
	return 0;
}

int sadump_init(char *unused, FILE *fptr)
{
	if (!SADUMP_VALID())
		return FALSE;

	return TRUE;
}

ulong get_sadump_panic_task(void)
{
	return NO_TASK;
}

ulong get_sadump_switch_stack(ulong task)
{
	return 0;
}

static struct tm *
efi_time_t_to_tm(const efi_time_t *e)
{
	static struct tm t;
	time_t ti;

	memset(&t, 0, sizeof(t));

	t.tm_sec  = e->second;
	t.tm_min  = e->minute;
	t.tm_hour = e->hour;
	t.tm_mday = e->day;
	t.tm_mon  = e->month - 1;
	t.tm_year = e->year - 1900;

	if (e->timezone != EFI_UNSPECIFIED_TIMEZONE)
		t.tm_hour += e->timezone;

	else if (CRASHDEBUG(1))
		error(INFO, "sadump: timezone information is missing\n");

	ti = mktime(&t);
	if (ti == (time_t)-1)
		return &t;

	return localtime_r(&ti, &t);
}

static char *
guid_to_str(efi_guid_t *guid, char *buf, size_t buflen)
{
	snprintf(buf, buflen,
		 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
		 htonl(guid->data1), htons(guid->data2), htons(guid->data3),
		 guid->data4[0], guid->data4[1], guid->data4[2],
		 guid->data4[3], guid->data4[4], guid->data4[5],
		 guid->data4[6], guid->data4[7]);

	return buf;
}

static int
verify_magic_number(uint32_t magicnum[DUMP_PART_HEADER_MAGICNUM_SIZE])
{
	int i;

	for (i = 1; i < DUMP_PART_HEADER_MAGICNUM_SIZE; ++i)
		if (magicnum[i] != (magicnum[i - 1] + 7) * 11)
			return FALSE;

	return TRUE;
}

int sadump_memory_used(void)
{
	return 0;
}

int sadump_free_memory(void)
{
	return 0;
}

/*
 *  This function is dump-type independent, and could be used to dump
 *  the diskdump_data structure contents and perhaps the sadump header
 *  data.
 */
int sadump_memory_dump(FILE *fp)
{
	struct sadump_part_header *sph;
	struct sadump_disk_set_header *sdh;
	struct sadump_header *sh;
	struct sadump_media_header *smh;
	int i, others;
	char guid[SADUMP_EFI_GUID_TEXT_REPR_LEN+1];

	fprintf(fp, "sadump_data: \n");
	fprintf(fp, "          filename: %s\n", sd->filename);
	fprintf(fp, "             flags: %lx (", sd->flags);
	others = 0;
	if (sd->flags & SADUMP_LOCAL)
		fprintf(fp, "%sSADUMP_LOCAL", others++ ? "|" : "");
	if (sd->flags & SADUMP_DISKSET)
		fprintf(fp, "%sSADUMP_DISKSET", others++ ? "|" : "");
	if (sd->flags & SADUMP_MEDIA)
		fprintf(fp, "%sSADUMP_MEDIA", others++ ? "|" : "");
	if (sd->flags & SADUMP_ZERO_EXCLUDED)
		fprintf(fp, "%sSADUMP_ZERO_EXCLUDED", others++ ? "|" : "");
	if (sd->flags & SADUMP_KDUMP_BACKUP)
		fprintf(fp, "%sSADUMP_KDUMP_BACKUP", others++ ? "|" : "");
	fprintf(fp, ") \n");
        fprintf(fp, "               dfd: %d\n", sd->dfd);
        fprintf(fp, "      machine_type: %d ", sd->machine_type);
	switch (sd->machine_type)
	{
	case EM_386:
		fprintf(fp, "(EM_386)\n"); break;
	case EM_X86_64:
		fprintf(fp, "(EM_X86_64)\n"); break;
	default:
		fprintf(fp, "(unknown)\n"); break;
	}

        fprintf(fp, "\n            header: %lx\n", (ulong)sd->header);
	sph = sd->header;
	fprintf(fp, "          signature1: %x\n", sph->signature1);
	fprintf(fp, "          signature2: %x\n", sph->signature2);
	fprintf(fp, "              enable: %u\n", sph->enable);
	fprintf(fp, "              reboot: %u\n", sph->reboot);
	fprintf(fp, "            compress: %u\n", sph->compress);
	fprintf(fp, "             recycle: %u\n", sph->recycle);
	fprintf(fp, "               label: (unused)\n");
	fprintf(fp, "           sadump_id: %s\n", guid_to_str(&sph->sadump_id, guid, sizeof(guid)));
	fprintf(fp, "         disk_set_id: %s\n", guid_to_str(&sph->disk_set_id, guid, sizeof(guid)));
	fprintf(fp, "              vol_id: %s\n", guid_to_str(&sph->vol_id, guid, sizeof(guid)));
	fprintf(fp, "          time_stamp: %s\n",
		strip_linefeeds(asctime(efi_time_t_to_tm(&sph->time_stamp))));
	fprintf(fp, "        set_disk_set: %u\n", sph->set_disk_set);
	fprintf(fp, "             reserve: %u\n", sph->reserve);
	fprintf(fp, "         used_device: %llu\n", (ulonglong)sph->used_device);
	fprintf(fp, "            magicnum: %s\n",
		verify_magic_number(sph->magicnum)
		? "(valid)" : "(invalid)");

        fprintf(fp, "\n       dump header: %lx\n", (ulong)sd->dump_header);
	sh = sd->dump_header;
	fprintf(fp, "           signature: %s\n", sh->signature);
	fprintf(fp, "      header_version: %u\n", sh->header_version);
	fprintf(fp, "             reserve: %u\n", sh->reserve);
	fprintf(fp, "           timestamp: %s\n",
		strip_linefeeds(asctime(efi_time_t_to_tm(&sh->timestamp))));
	fprintf(fp, "              status: %u\n", sh->status);
	fprintf(fp, "            compress: %u\n", sh->compress);
	fprintf(fp, "          block_size: %u\n", sh->block_size);
	fprintf(fp, "      extra_hdr_size: %u\n", sh->extra_hdr_size);
	fprintf(fp, "        sub_hdr_size: %u\n", sh->sub_hdr_size);
	fprintf(fp, "       bitmap_blocks: %u\n", sh->bitmap_blocks);
	fprintf(fp, "dumpable_bitmap_blocks: %u\n", sh->dumpable_bitmap_blocks);
	fprintf(fp, "           max_mapnr: %u\n", sh->max_mapnr);
	fprintf(fp, "    total_ram_blocks: %u\n", sh->total_ram_blocks);
	fprintf(fp, "       device_blocks: %u\n", sh->device_blocks);
	fprintf(fp, "      written_blocks: %u\n", sh->written_blocks);
	fprintf(fp, "         current_cpu: %u\n", sh->current_cpu);
	fprintf(fp, "             nr_cpus: %u\n", sh->nr_cpus);
	if (sh->header_version >= 1) {
		fprintf(fp,
			"        max_mapnr_64: %" PRIu64 "\n"
			" total_ram_blocks_64: %" PRIu64 "\n"
			"    device_blocks_64: %" PRIu64 "\n"
			"   written_blocks_64: %" PRIu64 "\n",
			sh->max_mapnr_64,
			sh->total_ram_blocks_64,
			sh->device_blocks_64,
			sh->written_blocks_64);
	}

	fprintf(fp, "\n    dump sub heaer: ");
	if (sh->sub_hdr_size > 0) {
		ulong offset = sd->sub_hdr_offset;
		struct sadump_apic_state as;
		struct sadump_smram_cpu_state scs, zero;
		uint32_t size;
		uint aid;

		memset(&zero, 0, sizeof(zero));

		if (!read_device(&size, sizeof(uint32_t), &offset)) {
			error(INFO, "sadump: cannot read sub header size\n");
			return FALSE;
		}
		fprintf(fp, "\n                size: %u\n", size);
		for (aid = 0; aid < sh->nr_cpus; ++aid) {
			if (!read_device(&as, sizeof(as), &offset)) {
				error(INFO, "sadump: cannot read sub header "
				      "apic_id\n");
				return FALSE;
			}
			fprintf(fp, "          "
				"apic_id[%u]: ApicId %llu: Ldr: %llu\n",
				aid, (ulonglong)as.ApicId, (ulonglong)as.Ldr);
		}
		for (aid = 0; aid < sh->nr_cpus; ++aid) {
			if (!read_device(&scs, sizeof(scs), &offset)) {
				error(INFO, "sadump: cannot read sub header "
				      "cpu_state\n");
				return FALSE;
			}
			if (memcmp(&scs, &zero, sizeof(scs)) != 0) {
				fprintf(fp, "\n");
				display_smram_cpu_state(aid, &scs);
			}
		}
	} else
		fprintf(fp, "(n/a)\n");

        fprintf(fp, "\n   disk set header: %lx ", (ulong)sd->diskset_header);
	if ((sdh = sd->diskset_header)) {
		fprintf(fp, "\ndisk_set_header_size: %u\n", sdh->disk_set_header_size);
		fprintf(fp, "            disk_num: %u\n", sdh->disk_num);
		fprintf(fp, "       disk_set_size: %llu\n", (ulonglong)sdh->disk_set_size);
		for (i = 0; i < sdh->disk_num - 1; ++i) {
			struct sadump_volume_info *vol = &sdh->vol_info[i];

			fprintf(fp, "         vol_info[%d]: \n", i);
			fprintf(fp, "                     id: %s\n", guid_to_str(&vol->id, guid, sizeof(guid)));
			fprintf(fp, "               vol_size: %llu\n", (ulonglong)vol->vol_size);
			fprintf(fp, "                 status: %u\n", vol->status);
			fprintf(fp, "             cache_size: %u\n", vol->cache_size);
		}
	} else
		fprintf(fp, "(n/a)\n");

        fprintf(fp, "\n      media header: %lx ", (ulong)sd->media_header);
	if ((smh = sd->media_header)) {
		fprintf(fp, "\n           sadump_id: %s\n", guid_to_str(&smh->sadump_id, guid, sizeof(guid)));
		fprintf(fp, "         disk_set_id: %s\n", guid_to_str(&smh->disk_set_id, guid, sizeof(guid)));
		fprintf(fp, "          time_stamp: %s\n",
			strip_linefeeds(asctime(efi_time_t_to_tm(&smh->time_stamp))));
		fprintf(fp, "      sequential_num: %d\n", smh->sequential_num);
		fprintf(fp, "           term_cord: %d\n", smh->term_cord);
		fprintf(fp, "disk_set_header_size: %d\n", smh->disk_set_header_size);
		fprintf(fp, "        disks_in_use: %d\n", smh->disks_in_use);
		fprintf(fp, "             reserve: (not displayed) \n");
	} else
		fprintf(fp, "(n/a)\n");

        fprintf(fp, "\n            bitmap: %lx\n", (ulong)sd->bitmap);
        fprintf(fp, "   dumpable_bitmap: %lx\n", (ulong)sd->dumpable_bitmap);
        fprintf(fp, "    sub_hdr_offset: %lx\n", (ulong)sd->sub_hdr_offset);
        fprintf(fp, "smram_cpu_state_size: %lx\n", (ulong)sd->smram_cpu_state_size);
        fprintf(fp, "       data_offset: %lx\n", sd->data_offset);
        fprintf(fp, "        block_size: %d\n", sd->block_size);
        fprintf(fp, "       block_shift: %d\n", sd->block_shift);
	fprintf(fp, "          page_buf: %lx\n", (ulong)sd->page_buf);
	fprintf(fp, "       block_table: %lx\n", (ulong)sd->block_table);
	fprintf(fp, "       sd_list_len: %d\n", sd->sd_list_len);
	fprintf(fp, "           sd_list: %lx\n", (ulong)sd->sd_list);
	fprintf(fp, "  backup_src_start: %llx\n", sd->backup_src_start);
	fprintf(fp, "   backup_src_size: %lx\n", sd->backup_src_size);
	fprintf(fp, "     backup_offset: %llx\n", (ulonglong)sd->backup_src_size);

	for (i = 0; i < sd->sd_list_len; ++i) {
		struct sadump_diskset_data *sdd = sd->sd_list[i];

		fprintf(fp, "\n        sd_list[%d]: \n", i);
		fprintf(fp, "            filename: %s\n", sdd->filename);
		fprintf(fp, "                 dfd: %d\n", sdd->dfd);

		fprintf(fp, "              header: %lx\n", (ulong)sdd->header);
		sph = sdd->header;
		fprintf(fp, "            signature1: %x\n", sph->signature1);
		fprintf(fp, "            signature2: %x\n", sph->signature2);
		fprintf(fp, "                enable: %u\n", sph->enable);
		fprintf(fp, "                reboot: %u\n", sph->reboot);
		fprintf(fp, "              compress: %u\n", sph->compress);
		fprintf(fp, "               recycle: %u\n", sph->recycle);
		fprintf(fp, "                 label: (unused)\n");
		fprintf(fp, "             sadump_id: %s\n", guid_to_str(&sph->sadump_id, guid, sizeof(guid)));
		fprintf(fp, "           disk_set_id: %s\n", guid_to_str(&sph->disk_set_id, guid, sizeof(guid)));
		fprintf(fp, "                vol_id: %s\n", guid_to_str(&sph->vol_id, guid, sizeof(guid)));
		fprintf(fp, "            time_stamp: %s\n",
			strip_linefeeds(asctime(efi_time_t_to_tm(&sph->time_stamp))));
		fprintf(fp, "          set_disk_set: %u\n", sph->set_disk_set);
		fprintf(fp, "               reserve: %u\n", sph->reserve);
		fprintf(fp, "           used_device: %llu\n", (ulonglong)sph->used_device);
		fprintf(fp, "              magicnum: %s\n",
			verify_magic_number(sph->magicnum)
			? "(valid)" : "(invalid)");

		fprintf(fp, "         data_offset: %lx\n", sdd->data_offset);
	}

	return TRUE;
}

static ulong
per_cpu_ptr(ulong ptr, int cpu)
{
	if (cpu < 0 || cpu >= kt->cpus)
		return 0UL;

	if (kt->cpus == 1)
		return ptr;

	if (!(kt->flags & PER_CPU_OFF))
		return 0UL;

	if (machine_type("X86_64")) {
		ulong __per_cpu_load;

		readmem(symbol_value("__per_cpu_load"), KVADDR,
			&__per_cpu_load, sizeof(__per_cpu_load),
			"__per_cpu_load", FAULT_ON_ERROR);

		if (kt->__per_cpu_offset[cpu] == __per_cpu_load)
			return 0UL;

	} else if (machine_type("X86")) {
		if (kt->__per_cpu_offset[cpu] == 0)
			return 0UL;

	}

	return ptr + kt->__per_cpu_offset[cpu];
}

static ulong
early_per_cpu_ptr(char *symbol, struct syment *sym, int cpu)
{
	char sym_early_ptr[BUFSIZE], sym_early_map[BUFSIZE];
	ulong early_ptr;

	if (cpu < 0 || cpu >= kt->cpus)
		return 0UL;

	if (!sym && !(sym = per_cpu_symbol_search(symbol)))
		return 0UL;

	if (!(kt->flags & SMP))
		return per_cpu_ptr(sym->value, cpu);

	snprintf(sym_early_ptr, BUFSIZE, "%s_early_ptr", symbol);
	snprintf(sym_early_map, BUFSIZE, "%s_early_map", symbol);

	if (!symbol_exists(sym_early_ptr) || !symbol_exists(sym_early_map))
		return 0UL;

	readmem(symbol_value(sym_early_ptr), KVADDR, &early_ptr,
		sizeof(early_ptr), sym_early_ptr, FAULT_ON_ERROR);

	return early_ptr
		? symbol_value(sym_early_map)+cpu*sizeof(uint16_t)
		: per_cpu_ptr(sym->value, cpu);
}

static ulong
legacy_per_cpu_ptr(ulong ptr, int cpu)
{
	ulong addr;

	if (!(kt->flags & SMP))
		return ptr;

	if (cpu < 0 || cpu >= kt->cpus)
		return 0UL;

	if (!readmem(~ptr + cpu * sizeof(ulong), KVADDR, &addr, sizeof(ulong),
		     "search percpu_data", FAULT_ON_ERROR))
		return 0UL;

	return addr;
}

/**
 * Retrieve eip and esp register values from crash_notes saved by
 * kdump at crash. If register values has not been saved yet, set 0 to
 * eip and esp instead.
 */
static int
get_prstatus_from_crash_notes(int cpu, char *prstatus)
{
	ulong crash_notes, crash_notes_ptr, percpu_addr;
	char *prstatus_ptr, *note_buf, *zero_buf, *name;
	uint32_t *buf;

	if (cpu < 0 || kt->cpus <= cpu) {
		error(INFO, "sadump: given cpu is invalid: %d\n", cpu);
		return FALSE;
	}

	if (!symbol_exists("crash_notes")) {
		error(INFO, "sadump: symbol crash_notes doesn't exist\n");
		return FALSE;
	}

	crash_notes = symbol_value("crash_notes");

	readmem(crash_notes, KVADDR, &crash_notes_ptr, sizeof(ulong),
		"dereference crash_notes", FAULT_ON_ERROR);

	if (!crash_notes_ptr) {
		if (CRASHDEBUG(1))
			error(INFO,
			      "sadump: buffer for crash_notes is NULL\n");
		return FALSE;
	}

	percpu_addr = VALID_STRUCT(percpu_data)
		? legacy_per_cpu_ptr(crash_notes_ptr, cpu)
		: per_cpu_ptr(crash_notes_ptr, cpu);

	zero_buf = GETBUF(SIZE(note_buf));
	BZERO(zero_buf, SIZE(note_buf));

	note_buf = GETBUF(SIZE(note_buf));

	readmem(percpu_addr, KVADDR, note_buf, SIZE(note_buf),
		"read crash_notes", FAULT_ON_ERROR);

	if (memcmp(note_buf, zero_buf, SIZE(note_buf)) == 0)
		return FALSE;

	if (BITS64()) {
		Elf64_Nhdr *note64;

		note64 = (Elf64_Nhdr *)note_buf;
		buf = (uint32_t *)note_buf;
		name = (char *)(note64 + 1);

		if (note64->n_type != NT_PRSTATUS ||
		    note64->n_namesz != strlen("CORE") + 1 ||
		    strncmp(name, "CORE", note64->n_namesz) ||
		    note64->n_descsz != SIZE(elf_prstatus))
			return FALSE;

		prstatus_ptr = (char *)(buf + (sizeof(*note64) + 3) / 4 +
					(note64->n_namesz + 3) / 4);

	} else {
		Elf32_Nhdr *note32;

		note32 = (Elf32_Nhdr *)note_buf;
		buf = (uint32_t *)note_buf;
		name = (char *)(note32 + 1);

		if ((note32->n_type != NT_PRSTATUS) &&
		    (note32->n_namesz != strlen("CORE") + 1 ||
		     strncmp(name, "CORE", note32->n_namesz) ||
		     note32->n_descsz != SIZE(elf_prstatus)))
			return FALSE;

		prstatus_ptr = (char *)(buf + (sizeof(*note32) + 3) / 4 +
					(note32->n_namesz + 3) / 4);

	}

	memcpy(prstatus, prstatus_ptr, SIZE(elf_prstatus));

	return TRUE;
}

int
sadump_get_smram_cpu_state(int apicid,
			   struct sadump_smram_cpu_state *smram)
{
	ulong offset;

	if (!sd->sub_hdr_offset || !sd->smram_cpu_state_size ||
	    apicid >= sd->dump_header->nr_cpus)
		return FALSE;

	offset = sd->sub_hdr_offset + sizeof(uint32_t) +
		sd->dump_header->nr_cpus * sizeof(struct sadump_apic_state);

	if (lseek(sd->dfd, offset + apicid * sd->smram_cpu_state_size,
		  SEEK_SET) == failed)
		error(FATAL,
		      "sadump: cannot lseek smram cpu state in dump sub header\n");

	if (read(sd->dfd, smram, sd->smram_cpu_state_size) != sd->smram_cpu_state_size)
		error(FATAL, "sadump: cannot read smram cpu state in dump sub "
		      "header\n");

	return TRUE;
}

static void
display_smram_cpu_state(int apicid, struct sadump_smram_cpu_state *s)
{
	fprintf(fp,
		"APIC ID: %d\n"
		"    RIP: %016llx RSP: %08x%08x RBP: %08x%08x\n"
		"    RAX: %08x%08x RBX: %08x%08x RCX: %08x%08x\n"
		"    RDX: %08x%08x RSI: %08x%08x RDI: %08x%08x\n"
		"    R08: %08x%08x R09: %08x%08x R10: %08x%08x\n"
		"    R11: %08x%08x R12: %08x%08x R13: %08x%08x\n"
		"    R14: %08x%08x R15: %08x%08x\n"
		"    SMM REV: %08x SMM BASE %08x\n"
		"    CS : %08x DS: %08x SS: %08x ES: %08x FS: %08x\n"
		"    GS : %08x\n"
		"    CR0: %016llx CR3: %016llx CR4: %08x\n"
		"    GDT: %08x%08x LDT: %08x%08x IDT: %08x%08x\n"
		"    GDTlim: %08x LDTlim: %08x IDTlim: %08x\n"
		"    LDTR: %08x TR: %08x RFLAGS: %016llx\n"
		"    EPTP: %016llx EPTP_SETTING: %08x\n"
		"    DR6: %016llx DR7: %016llx\n"
		"    Ia32Efer: %016llx\n"
		"    IoMemAddr: %08x%08x IoEip: %016llx\n"
		"    IoMisc: %08x LdtInfo: %08x\n"
		"    IoInstructionRestart: %04x AutoHaltRestart: %04x\n",
		apicid,
		(ulonglong)s->Rip, s->RspUpper, s->RspLower, s->RbpUpper, s->RbpLower,
		s->RaxUpper, s->RaxLower, s->RbxUpper, s->RbxLower, s->RcxUpper, s->RcxLower,
		s->RdxUpper, s->RdxLower, s->RsiUpper, s->RsiLower, s->RdiUpper, s->RdiLower,
		s->R8Upper, s->R8Lower,	s->R9Upper, s->R9Lower,	s->R10Upper, s->R10Lower,
		s->R11Upper, s->R11Lower, s->R12Upper, s->R12Lower, s->R13Upper, s->R13Lower,
		s->R14Upper, s->R14Lower, s->R15Upper, s->R15Lower,
		s->SmmRevisionId, s->Smbase,
		s->Cs, s->Ds, s->Ss, s->Es, s->Fs, s->Gs,
		(ulonglong)s->Cr0, (ulonglong)s->Cr3, s->Cr4,
		s->GdtUpper, s->GdtLower, s->LdtUpper, s->LdtLower, s->IdtUpper, s->IdtLower,
		s->GdtLimit, s->LdtLimit, s->IdtLimit,
		s->Ldtr, s->Tr, (ulonglong)s->Rflags,
		(ulonglong)s->Eptp, s->EptpSetting,
		(ulonglong)s->Dr6, (ulonglong)s->Dr7,
		(ulonglong)s->Ia32Efer,
		s->IoMemAddrUpper, s->IoMemAddrLower, (ulonglong)s->IoEip,
		s->IoMisc, s->LdtInfo,
		s->IoInstructionRestart,
		s->AutoHaltRestart);
}

static int cpu_to_apicid(int cpu, int *apicid)
{
	struct syment *sym;

	if (symbol_exists("bios_cpu_apicid")) {
		uint8_t apicid_u8;

		readmem(symbol_value("bios_cpu_apicid") + cpu*sizeof(uint8_t),
			KVADDR, &apicid_u8, sizeof(uint8_t), "bios_cpu_apicid",
			FAULT_ON_ERROR);

		*apicid = (int)apicid_u8;

		if (CRASHDEBUG(1))
			error(INFO, "sadump: apicid %u for cpu %d from "
			      "bios_cpu_apicid\n", apicid_u8, cpu);

	} else if ((sym = per_cpu_symbol_search("x86_bios_cpu_apicid"))) {
		uint16_t apicid_u16;

		readmem(early_per_cpu_ptr("x86_bios_cpu_apicid", sym, cpu),
			KVADDR, &apicid_u16, sizeof(uint16_t),
			"x86_bios_cpu_apicid", FAULT_ON_ERROR);

		*apicid = (int)apicid_u16;

		if (CRASHDEBUG(1))
			error(INFO, "sadump: apicid %u for cpu %d from "
			      "x86_bios_cpu_apicid\n", apicid_u16, cpu);

	} else {
		if (CRASHDEBUG(1))
			error(INFO, "sadump: no symbols for access to apicid\n");

		return FALSE;
	}

	return TRUE;
}

static int
get_sadump_smram_cpu_state(int cpu, struct sadump_smram_cpu_state *smram)
{
	int apicid = 0;

	if (cpu < 0 || kt->cpus <= cpu) {
		error(INFO, "sadump: given cpu is invalid: %d\n", cpu);
		return FALSE;
	}

	if (!cpu_to_apicid(cpu, &apicid))
		return FALSE;

	sadump_get_smram_cpu_state(apicid, smram);

	return TRUE;
}

void get_sadump_regs(struct bt_info *bt, ulong *ipp, ulong *spp)
{
	ulong ip, sp;
	struct sadump_smram_cpu_state smram;
	char *prstatus;
	int cpu = bt->tc->processor;

	if (!is_task_active(bt->task)) {
		machdep->get_stack_frame(bt, ipp, spp);
		return;
	}

	bt->flags |= BT_DUMPFILE_SEARCH;
	if (machine_type("X86_64"))
		machdep->get_stack_frame(bt, ipp, spp);
	else if (machine_type("X86"))
		get_netdump_regs_x86(bt, ipp, spp);
	if (bt->flags & BT_DUMPFILE_SEARCH)
		return;

	prstatus = GETBUF(SIZE(elf_prstatus));

	if (get_prstatus_from_crash_notes(cpu, prstatus)) {
		ip = ULONG(prstatus +
			   OFFSET(elf_prstatus_pr_reg) +
			   (BITS64()
			    ? OFFSET(user_regs_struct_rip)
			    : OFFSET(user_regs_struct_eip)));
		sp = ULONG(prstatus +
			   OFFSET(elf_prstatus_pr_reg) +
			   (BITS64()
			    ? OFFSET(user_regs_struct_rsp)
			    : OFFSET(user_regs_struct_eip)));
		if (ip || sp) {
			*ipp = ip;
			*spp = sp;
			return;
		}
	}

	get_sadump_smram_cpu_state(cpu, &smram);
	ip = smram.Rip;
	sp = ((uint64_t)smram.RspUpper << 32) + smram.RspLower;

	if (is_kernel_text(ip) &&
	    (((sp >= GET_STACKBASE(bt->task)) &&
	      (sp < GET_STACKTOP(bt->task))) ||
	     in_alternate_stack(bt->tc->processor, sp))) {
		*ipp = ip;
		*spp = sp;
		bt->flags |= BT_KERNEL_SPACE;
		return;
	}

	if (!is_kernel_text(ip) &&
	    in_user_stack(bt->tc->task, sp))
		bt->flags |= BT_USER_SPACE;

}

void
sadump_display_regs(int cpu, FILE *ofp)
{
	struct sadump_smram_cpu_state smram;

	if (cpu < 0 || cpu >= kt->cpus) {
		error(INFO, "sadump: given cpu is invalid: %d\n", cpu);
		return;
	}

	get_sadump_smram_cpu_state(cpu, &smram);

	if (machine_type("X86_64")) {
		fprintf(ofp,
			"    RIP: %016llx  RSP: %016llx  RFLAGS: %08llx\n"
			"    RAX: %016llx  RBX: %016llx  RCX: %016llx\n"
			"    RDX: %016llx  RSI: %016llx  RDI: %016llx\n"
			"    RBP: %016llx   R8: %016llx   R9: %016llx\n"
			"    R10: %016llx  R11: %016llx  R12: %016llx\n"
			"    R13: %016llx  R14: %016llx  R15: %016llx\n"
			"    CS: %04x  SS: %04x\n",
			(ulonglong)(smram.Rip),
			(ulonglong)(((uint64_t)smram.RspUpper<<32)+smram.RspLower),
			(ulonglong)(smram.Rflags),
			(ulonglong)(((uint64_t)smram.RaxUpper<<32)+smram.RaxLower),
			(ulonglong)(((uint64_t)smram.RbxUpper<<32)+smram.RbxLower),
			(ulonglong)(((uint64_t)smram.RcxUpper<<32)+smram.RcxLower),
			(ulonglong)(((uint64_t)smram.RdxUpper<<32)+smram.RdxLower),
			(ulonglong)(((uint64_t)smram.RsiUpper<<32)+smram.RsiLower),
			(ulonglong)(((uint64_t)smram.RdiUpper<<32)+smram.RdiLower),
			(ulonglong)(((uint64_t)smram.RbpUpper<<32)+smram.RbpLower),
			(ulonglong)(((uint64_t)smram.R8Upper<<32)+smram.R8Lower),
			(ulonglong)(((uint64_t)smram.R9Upper<<32)+smram.R9Lower),
			(ulonglong)(((uint64_t)smram.R10Upper<<32)+smram.R10Lower),
			(ulonglong)(((uint64_t)smram.R11Upper<<32)+smram.R11Lower),
			(ulonglong)(((uint64_t)smram.R12Upper<<32)+smram.R12Lower),
			(ulonglong)(((uint64_t)smram.R13Upper<<32)+smram.R13Lower),
			(ulonglong)(((uint64_t)smram.R14Upper<<32)+smram.R14Lower),
			(ulonglong)(((uint64_t)smram.R15Upper<<32)+smram.R15Lower),
			smram.Cs,
			smram.Ss);
	}

	if (machine_type("X86")) {
		fprintf(ofp,
			"    EAX: %08llx  EBX: %08llx  ECX: %08llx  EDX: %08llx\n"
			"    DS:  %04x      ESI: %08llx  ES:  %04x      EDI: %08llx\n"
			"    SS:  %04x      ESP: %08llx  EBP: %08llx  GS:  %04x\n"
			"    CS:  %04x      EIP: %08llx  EFLAGS: %08llx\n",
			(ulonglong)smram.RaxLower,
			(ulonglong)smram.RbxLower,
			(ulonglong)smram.RcxLower,
			(ulonglong)smram.RdxLower,
			smram.Ds & 0xffff,
			(ulonglong)smram.RsiLower,
			smram.Es & 0xffff,
			(ulonglong)smram.RdiLower,
			smram.Ss,
			(ulonglong)smram.RspLower,
			(ulonglong)smram.RbpLower,
			smram.Gs,
			smram.Cs,
			(ulonglong)smram.Rip,
			(ulonglong)smram.Rflags);
	}
}

/*
 * sadump does not save phys_base; it must resort to another way.
 */
int sadump_phys_base(ulong *phys_base)
{
	if (SADUMP_VALID() && !sd->phys_base) {
		if (CRASHDEBUG(1))
			error(NOTE, "sadump: does not save phys_base.\n");
		return FALSE;
	}

	if (sd->phys_base) {
		*phys_base = sd->phys_base;
		return TRUE;
	}

	return FALSE;
}

/*
 *  Used by "sys" command to show diskset disk names.
 */
void sadump_show_diskset(void)
{
	int i;

	for (i = 0; i < sd->sd_list_len; ++i) {
		char *filename = sd->sd_list[i]->filename;

		fprintf(fp, "%s%s", i ? "              " : "",
			filename);
		if ((i+1) < sd->sd_list_len)
			fprintf(fp, "\n");
	}
}

static int block_table_init(void)
{
	uint64_t pfn, section, max_section, *block_table;

	max_section = divideup(sd->max_mapnr, SADUMP_PF_SECTION_NUM);

	block_table = calloc(sizeof(uint64_t), max_section);
	if (!block_table) {
		error(INFO, "sadump: cannot allocate memory for block_table\n");
		return FALSE;
	}

	for (section = 0; section < max_section; ++section) {
		if (section > 0)
			block_table[section] = block_table[section-1];
		for (pfn = section * SADUMP_PF_SECTION_NUM;
		     pfn < (section + 1) * SADUMP_PF_SECTION_NUM;
		     ++pfn)
			if (page_is_dumpable(pfn))
				block_table[section]++;
	}

	sd->block_table = block_table;

	return TRUE;
}

static uint64_t pfn_to_block(uint64_t pfn)
{
	uint64_t block, section, p;

	section = pfn / SADUMP_PF_SECTION_NUM;

	if (section)
		block = sd->block_table[section - 1];
	else
		block = 0;

	for (p = section * SADUMP_PF_SECTION_NUM; p < pfn; ++p)
		if (page_is_dumpable(p))
			block++;

	return block;
}

int sadump_is_zero_excluded(void)
{
	return (sd->flags & SADUMP_ZERO_EXCLUDED) ? TRUE : FALSE;
}

void sadump_set_zero_excluded(void)
{
	sd->flags |= SADUMP_ZERO_EXCLUDED;
}

void sadump_unset_zero_excluded(void)
{
	sd->flags &= ~SADUMP_ZERO_EXCLUDED;
}

struct sadump_data *
get_sadump_data(void)
{
	return sd;
}

#ifdef X86_64
static int
get_sadump_smram_cpu_state_any(struct sadump_smram_cpu_state *smram)
{
	ulong offset;
	struct sadump_header *sh = sd->dump_header;
	int apicid;
	struct sadump_smram_cpu_state scs, zero;

	offset = sd->sub_hdr_offset + sizeof(uint32_t) +
		 sd->dump_header->nr_cpus * sizeof(struct sadump_apic_state);

	memset(&zero, 0, sizeof(zero));

	for (apicid = 0; apicid < sh->nr_cpus; ++apicid) {
		if (!read_device(&scs, sizeof(scs), &offset)) {
			error(INFO, "sadump: cannot read sub header "
			      "cpu_state\n");
			return FALSE;
		}
		if (memcmp(&scs, &zero, sizeof(scs)) != 0) {
			*smram = scs;
			return TRUE;
		}
	}

	return FALSE;
}

/*
 * Get address of vector0 interrupt handler (Devide Error) from Interrupt
 * Descriptor Table.
 */
static ulong
get_vec0_addr(ulong idtr)
{
	struct gate_struct64 {
		uint16_t offset_low;
		uint16_t segment;
		uint32_t ist : 3, zero0 : 5, type : 5, dpl : 2, p : 1;
		uint16_t offset_middle;
		uint32_t offset_high;
		uint32_t zero1;
	} __attribute__((packed)) gate;

	readmem(idtr, PHYSADDR, &gate, sizeof(gate), "idt_table", FAULT_ON_ERROR);

	return ((ulong)gate.offset_high << 32)
		+ ((ulong)gate.offset_middle << 16)
		+ gate.offset_low;
}

/*
 * Parse a string of [size[KMG] ]offset[KMG]
 * Import from Linux kernel(lib/cmdline.c)
 */
static ulong memparse(char *ptr, char **retptr)
{
	char *endptr;

	unsigned long long ret = strtoull(ptr, &endptr, 0);

	switch (*endptr) {
	case 'E':
	case 'e':
		ret <<= 10;
	case 'P':
	case 'p':
		ret <<= 10;
	case 'T':
	case 't':
		ret <<= 10;
	case 'G':
	case 'g':
		ret <<= 10;
	case 'M':
	case 'm':
		ret <<= 10;
	case 'K':
	case 'k':
		ret <<= 10;
		endptr++;
	default:
		break;
	}

	if (retptr)
		*retptr = endptr;

	return ret;
}

/*
 * Find "elfcorehdr=" in the boot parameter of kernel and return the address
 * of elfcorehdr.
 */
static ulong
get_elfcorehdr(ulong kaslr_offset)
{
	char cmdline[BUFSIZE], *ptr;
	ulong cmdline_vaddr;
	ulong cmdline_paddr;
	ulong buf_vaddr, buf_paddr;
	char *end;
	ulong elfcorehdr_addr = 0, elfcorehdr_size = 0;
	int verbose = CRASHDEBUG(1)? 1: 0;

	cmdline_vaddr = st->saved_command_line_vmlinux + kaslr_offset;
	if (!kvtop(NULL, cmdline_vaddr, &cmdline_paddr, verbose))
		return 0;

	if (CRASHDEBUG(1)) {
		fprintf(fp, "cmdline vaddr=%lx\n", cmdline_vaddr);
		fprintf(fp, "cmdline paddr=%lx\n", cmdline_paddr);
	}

	if (!readmem(cmdline_paddr, PHYSADDR, &buf_vaddr, sizeof(ulong),
		     "saved_command_line", RETURN_ON_ERROR))
		return 0;

	if (!kvtop(NULL, buf_vaddr, &buf_paddr, verbose))
		return 0;

	if (CRASHDEBUG(1)) {
		fprintf(fp, "cmdline buffer vaddr=%lx\n", buf_vaddr);
		fprintf(fp, "cmdline buffer paddr=%lx\n", buf_paddr);
	}

	memset(cmdline, 0, BUFSIZE);
	if (!readmem(buf_paddr, PHYSADDR, cmdline, BUFSIZE,
		     "saved_command_line", RETURN_ON_ERROR))
		return 0;

	ptr = strstr(cmdline, "elfcorehdr=");
	if (!ptr)
		return 0;

	if (CRASHDEBUG(1))
		fprintf(fp, "2nd kernel detected\n");

	ptr += strlen("elfcorehdr=");
	elfcorehdr_addr = memparse(ptr, &end);
	if (*end == '@') {
		elfcorehdr_size = elfcorehdr_addr;
		elfcorehdr_addr = memparse(end + 1, &end);
	}

	if (CRASHDEBUG(1)) {
		fprintf(fp, "elfcorehdr_addr=%lx\n", elfcorehdr_addr);
		fprintf(fp, "elfcorehdr_size=%lx\n", elfcorehdr_size);
	}

	return elfcorehdr_addr;
}

 /*
  * Get vmcoreinfo from elfcorehdr.
  * Some codes are imported from Linux kernel(fs/proc/vmcore.c)
  */
static int
get_vmcoreinfo(ulong elfcorehdr, ulong *addr, int *len)
{
	unsigned char e_ident[EI_NIDENT];
	Elf64_Ehdr ehdr;
	Elf64_Phdr phdr;
	Elf64_Nhdr nhdr;
	ulong ptr;
	ulong nhdr_offset = 0;
	int i;

	if (!readmem(elfcorehdr, PHYSADDR, e_ident, EI_NIDENT,
		     "EI_NIDENT", RETURN_ON_ERROR))
		return FALSE;

	if (e_ident[EI_CLASS] != ELFCLASS64) {
		error(INFO, "Only ELFCLASS64 is supportd\n");
		return FALSE;
	}

	if (!readmem(elfcorehdr, PHYSADDR, &ehdr, sizeof(ehdr),
			"Elf64_Ehdr", RETURN_ON_ERROR))
		return FALSE;

	/* Sanity Check */
	if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 ||
		(ehdr.e_type != ET_CORE) ||
		ehdr.e_ident[EI_CLASS] != ELFCLASS64 ||
		ehdr.e_ident[EI_VERSION] != EV_CURRENT ||
		ehdr.e_version != EV_CURRENT ||
		ehdr.e_ehsize != sizeof(Elf64_Ehdr) ||
		ehdr.e_phentsize != sizeof(Elf64_Phdr) ||
		ehdr.e_phnum == 0) {
		error(INFO, "Invalid elf header\n");
		return FALSE;
	}

	ptr = elfcorehdr + ehdr.e_phoff;
	for (i = 0; i < ehdr.e_phnum; i++) {
		ulong offset;
		char name[16];

		if (!readmem(ptr, PHYSADDR, &phdr, sizeof(phdr),
				"Elf64_Phdr", RETURN_ON_ERROR))
			return FALSE;

		ptr += sizeof(phdr);
		if (phdr.p_type != PT_NOTE)
			continue;

		offset = phdr.p_offset;
		if (!readmem(offset, PHYSADDR, &nhdr, sizeof(nhdr),
				"Elf64_Nhdr", RETURN_ON_ERROR))
			return FALSE;

		offset += DIV_ROUND_UP(sizeof(Elf64_Nhdr), sizeof(Elf64_Word))*
			  sizeof(Elf64_Word);
		memset(name, 0, sizeof(name));
		if (!readmem(offset, PHYSADDR, name, sizeof(name),
				"Elf64_Nhdr name", RETURN_ON_ERROR))
			return FALSE;

		if(!strcmp(name, "VMCOREINFO")) {
			nhdr_offset = offset;
			break;
		}
	}

	if (!nhdr_offset)
		return FALSE;

	*addr = nhdr_offset +
		DIV_ROUND_UP(nhdr.n_namesz, sizeof(Elf64_Word))*
		sizeof(Elf64_Word);
	*len = nhdr.n_descsz;

	if (CRASHDEBUG(1)) {
		fprintf(fp, "vmcoreinfo addr=%lx\n", *addr);
		fprintf(fp, "vmcoreinfo len=%d\n", *len);
	}

	return TRUE;
}

/*
 * Check if current kaslr_offset/phys_base is for 1st kernel or 2nd kernel.
 * If we are in 2nd kernel, get kaslr_offset/phys_base from vmcoreinfo.
 *
 * 1. Get command line and try to retrieve "elfcorehdr=" boot parameter
 * 2. If "elfcorehdr=" is not found in command line, we are in 1st kernel.
 *    There is nothing to do.
 * 3. If "elfcorehdr=" is found, we are in 2nd kernel. Find vmcoreinfo
 *    using "elfcorehdr=" and retrieve kaslr_offset/phys_base from vmcoreinfo.
 */
static int
get_kaslr_offset_from_vmcoreinfo(ulong orig_kaslr_offset,
		                 ulong *kaslr_offset, ulong *phys_base)
{
	ulong elfcorehdr_addr = 0;
	ulong vmcoreinfo_addr;
	int vmcoreinfo_len;
	char *buf, *pos;
	int ret = FALSE;

	/* Find "elfcorehdr=" in the kernel boot parameter */
	elfcorehdr_addr = get_elfcorehdr(orig_kaslr_offset);
	if (!elfcorehdr_addr)
		return FALSE;

	/* Get vmcoreinfo from the address of "elfcorehdr=" */
	if (!get_vmcoreinfo(elfcorehdr_addr, &vmcoreinfo_addr, &vmcoreinfo_len))
		return FALSE;

	if (!vmcoreinfo_len)
		return FALSE;

	if (CRASHDEBUG(1))
		fprintf(fp, "Find vmcoreinfo in kdump memory\n");

	buf = GETBUF(vmcoreinfo_len);
	if (!readmem(vmcoreinfo_addr, PHYSADDR, buf, vmcoreinfo_len,
			"vmcoreinfo", RETURN_ON_ERROR))
		goto quit;

	/* Get phys_base form vmcoreinfo */
	pos = strstr(buf, "NUMBER(phys_base)=");
	if (!pos)
		goto quit;
	*phys_base  = strtoull(pos + strlen("NUMBER(phys_base)="), NULL, 0);

	/* Get kaslr_offset form vmcoreinfo */
	pos = strstr(buf, "KERNELOFFSET=");
	if (!pos)
		goto quit;
	*kaslr_offset = strtoull(pos + strlen("KERNELOFFSET="), NULL, 16);

	ret = TRUE;

quit:
	FREEBUF(buf);
	return ret;
}

/*
 * Calculate kaslr_offset and phys_base
 *
 * kaslr_offset:
 *   The difference between original address in System.map or vmlinux and
 *   actual address placed randomly by kaslr feature. To be more accurate,
 *   kaslr_offset = actual address  - original address
 *
 * phys_base:
 *   Physical address where the kerenel is placed. In other words, it's a
 *   physical address of __START_KERNEL_map. This is also decided randomly by
 *   kaslr.
 *
 * kaslr offset and phys_base are calculated as follows:
 *
 * kaslr_offset:
 * 1) Get IDTR and CR3 value from the dump header.
 * 2) Get a virtual address of IDT from IDTR value
 *    --- (A)
 * 3) Translate (A) to physical address using CR3, the upper 52 bits
 *    of which points a top of page table.
 *    --- (B)
 * 4) Get an address of vector0 (Devide Error) interrupt handler from
 *    IDT, which are pointed by (B).
 *    --- (C)
 * 5) Get an address of symbol "divide_error" form vmlinux
 *    --- (D)
 *
 * Now we have two addresses:
 * (C)-> Actual address of "divide_error"
 * (D)-> Original address of "divide_error" in the vmlinux
 *
 * kaslr_offset can be calculated by the difference between these two
 * value.
 *
 * phys_base;
 * 1) Get IDT virtual address from vmlinux
 *    --- (E)
 *
 * So phys_base can be calculated using relationship of directly mapped
 * address.
 *
 * phys_base =
 *   Physical address(B) -
 *   (Virtual address(E) + kaslr_offset - __START_KERNEL_map)
 *
 * Note that the address (A) cannot be used instead of (E) because (A) is
 * not direct map address, it's a fixed map address.
 *
 * This solution works in most every case, but does not work in the
 * following case.
 *
 * 1) If the dump is captured on early stage of kernel boot, IDTR points
 *    early IDT table(early_idts) instead of normal IDT(idt_table).
 * 2) If the dump is captured whle kdump is working, IDTR points
 *    IDT table of 2nd kernel, not 1st kernel.
 *
 * Current implementation does not support the case 1), need
 * enhancement in the future. For the case 2), get kaslr_offset and
 * phys_base as follows.
 *
 * 1) Get kaslr_offset and phys_base using the above solution.
 * 2) Get kernel boot parameter from "saved_command_line"
 * 3) If "elfcorehdr=" is not included in boot parameter, we are in the
 *    first kernel, nothing to do any more.
 * 4) If "elfcorehdr=" is included in boot parameter, we are in the 2nd
 *    kernel. Retrieve vmcoreinfo from address of "elfcorehdr=" and
 *    get kaslr_offset and phys_base from vmcoreinfo.
 */
#define PTI_USER_PGTABLE_BIT	PAGE_SHIFT
#define PTI_USER_PGTABLE_MASK	(1 << PTI_USER_PGTABLE_BIT)
#define CR3_PCID_MASK		0xFFFull
int
sadump_calc_kaslr_offset(ulong *kaslr_offset)
{
	ulong phys_base = 0;
	struct sadump_smram_cpu_state scs;
	uint64_t idtr = 0, pgd = 0, idtr_paddr;
	ulong divide_error_vmcore;
	ulong kaslr_offset_kdump, phys_base_kdump;
	int ret = FALSE;
	int verbose = CRASHDEBUG(1)? 1: 0;

	if (!machine_type("X86_64"))
		return FALSE;

	memset(&scs, 0, sizeof(scs));
	get_sadump_smram_cpu_state_any(&scs);
	if (st->pti_init_vmlinux || st->kaiser_init_vmlinux)
		pgd = scs.Cr3 & ~(CR3_PCID_MASK|PTI_USER_PGTABLE_MASK);
	else
		pgd = scs.Cr3 & ~CR3_PCID_MASK;
	idtr = ((uint64_t)scs.IdtUpper)<<32 | (uint64_t)scs.IdtLower;

	/*
	 * Set up for kvtop.
	 *
	 * calc_kaslr_offset() is called before machdep_init(PRE_GDB), so some
	 * variables are not initialized yet. Set up them here to call kvtop().
	 *
	 * TODO: XEN and 5-level is not supported
	 */
	vt->kernel_pgd[0] = pgd;
	machdep->last_pgd_read = vt->kernel_pgd[0];
	machdep->machspec->physical_mask_shift = __PHYSICAL_MASK_SHIFT_2_6;
	machdep->machspec->pgdir_shift = PGDIR_SHIFT;
	machdep->machspec->ptrs_per_pgd = PTRS_PER_PGD;
	if (!readmem(pgd, PHYSADDR, machdep->pgd, PAGESIZE(),
			"pgd", RETURN_ON_ERROR))
		goto quit;

	/* Convert virtual address of IDT table to physical address */
	if (!kvtop(NULL, idtr, &idtr_paddr, verbose))
		goto quit;

	/* Now we can calculate kaslr_offset and phys_base */
	divide_error_vmcore = get_vec0_addr(idtr_paddr);
	*kaslr_offset = divide_error_vmcore - st->divide_error_vmlinux;
	phys_base = idtr_paddr -
		(st->idt_table_vmlinux + *kaslr_offset - __START_KERNEL_map);

	if (CRASHDEBUG(1)) {
		fprintf(fp, "calc_kaslr_offset: idtr=%lx\n", idtr);
		fprintf(fp, "calc_kaslr_offset: pgd=%lx\n", pgd);
		fprintf(fp, "calc_kaslr_offset: idtr(phys)=%lx\n", idtr_paddr);
		fprintf(fp, "calc_kaslr_offset: divide_error(vmlinux): %lx\n",
			st->divide_error_vmlinux);
		fprintf(fp, "calc_kaslr_offset: divide_error(vmcore): %lx\n",
			divide_error_vmcore);
	}

	/*
	 * Check if current kaslr_offset/phys_base is for 1st kernel or 2nd
	 * kernel. If we are in 2nd kernel, get kaslr_offset/phys_base
	 * from vmcoreinfo
	 */
	if (get_kaslr_offset_from_vmcoreinfo(
		*kaslr_offset, &kaslr_offset_kdump, &phys_base_kdump)) {
		*kaslr_offset =  kaslr_offset_kdump;
		phys_base =  phys_base_kdump;
	} else if (CRASHDEBUG(1)) {
		fprintf(fp, "sadump: failed to determine which kernel was running at crash,\n");
		fprintf(fp, "sadump: asssuming the kdump 1st kernel.\n");
	}

	if (CRASHDEBUG(1)) {
		fprintf(fp, "calc_kaslr_offset: kaslr_offset=%lx\n",
			*kaslr_offset);
		fprintf(fp, "calc_kaslr_offset: phys_base=%lx\n", phys_base);
	}

	sd->phys_base = phys_base;
	ret = TRUE;
quit:
	vt->kernel_pgd[0] = 0;
	machdep->last_pgd_read = 0;
	return ret;
}
#else
int
sadump_calc_kaslr_offset(ulong *kaslr_offset)
{
	return FALSE;
}
#endif /* X86_64 */
