/*

 * 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);