/* lkcd_common.c - core analysis suite

 *

 * Copyright (C) 1999, 2000, 2001, 2002 Mission Critical Linux, Inc.

 * Copyright (C) 2002 Silicon Graphics, Inc. 

 * Copyright (C) 2002 Free Software Foundation, Inc.

 * Copyright (C) 2002-2005, 2007, 2009, 2011, 2013 David Anderson

 * Copyright (C) 2002-2005, 2007, 2009, 2011, 2013 Red Hat, Inc. All rights reserved.

 *

 * 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.

 */

/*

 *  lkcd_uncompress_RLE() is essentially LKCD's __cmpuncompress_page() rountine,

 *  adapted from ../cmd/lcrash/lib/libklib/arch/i386/kl_cmp.c:

 */

/*

 * arch/i386/cmp.c

 *

 * This file handles compression aspects of crash dump files

 * for i386 based systems.  Most of this is taken from the

 * IRIX compression code, with exceptions to how the index

 * is created, because the file format is different with Linux.

 *

 * Copyright 1999 Silicon Graphics, Inc. All rights reserved.

 */

/*

 *  This file has no knowledge of the dump_header_t, dump_header_asm_t or

 *  dump_page_t formats, so it gathers information from them via the version

 *  specific "_v1" or "_v2_v3" type routines.

 */

#define LKCD_COMMON

#include "defs.h"

static void dump_dump_page(char *, void *);

static int lkcd_uncompress_RLE(unsigned char *, unsigned char *,uint32_t,int *);

static int lkcd_uncompress_gzip(unsigned char *, ulong, unsigned char *, ulong);

static int hash_page(ulong);

static int page_is_cached(void);

static int page_is_hashed(long *);

static int cache_page(void);

struct lkcd_environment lkcd_environment = { 0 };

struct lkcd_environment *lkcd = &lkcd_environment;

static int uncompress_errloc;

static int uncompress_recover(unsigned char *, ulong, unsigned char *, ulong);

ulonglong 

fix_lkcd_address(ulonglong addr)

{

    int i; 

    ulong offset;

    for (i = 0; i < lkcd->fix_addr_num; i++) {

	if ( (addr >=lkcd->fix_addr[i].task) && 

		(addr < lkcd->fix_addr[i].task + STACKSIZE())){

	    offset = addr - lkcd->fix_addr[i].task;

	    addr = lkcd->fix_addr[i].saddr + offset;

	}

    }

    return addr;

}

/*

 *  Each version has its own dump initialization.

 */

int

lkcd_dump_init(FILE *fp, int fd, char *dumpfile)

{

	switch (lkcd->version)

	{

        case LKCD_DUMP_V1:

		return(lkcd_dump_init_v1(fp, fd));

        case LKCD_DUMP_V2:

        case LKCD_DUMP_V3:

		return(lkcd_dump_init_v2_v3(fp, fd));

        case LKCD_DUMP_V5:

        case LKCD_DUMP_V6:

		return(lkcd_dump_init_v5(fp, fd));

        case LKCD_DUMP_V7:

		return(lkcd_dump_init_v7(fp, fd, dumpfile));

        case LKCD_DUMP_V8:

        case LKCD_DUMP_V9:

		return(lkcd_dump_init_v8(fp, fd, dumpfile));

	default:

		return FALSE;

	}

}

/*

 *  Return the page size value recorded in the dump header.

 */

uint32_t

lkcd_page_size(void)

{

	return lkcd->page_size;

}

/*

 *  Return the panic task and panic string.

 */

unsigned long

get_lkcd_panic_task(void)

{

	return(lkcd->flags & (LKCD_VALID|LKCD_REMOTE) ? lkcd->panic_task : 0);

}

void

get_lkcd_panicmsg(char *buf)

{

	if (lkcd->flags & (LKCD_VALID|LKCD_REMOTE))

		strcpy(buf, lkcd->panic_string);

}

/*

 *  Called by remote_lkcd_dump_init() the local (!valid) lkcd_environment

 *  is used to store the panic task and panic message for use by the

 *  two routines above.

 */ 

void

set_remote_lkcd_panic_data(ulong task, char *buf)

{

	if (buf) {

		if (!(lkcd->panic_string = (char *)malloc(strlen(buf)+1))) {

			fprintf(stderr, 

			    "cannot malloc space for panic message!\n");

			clean_exit(1);

		}

		strcpy(lkcd->panic_string, buf);

	}

	if (task)

		lkcd->panic_task = task;

	lkcd->flags |= LKCD_REMOTE;

}

/*

 *  Does the magic number indicate an LKCD compressed dump?

 *  If so, set the version number for all future forays into the

 *  functions in this file.

 */

int

is_lkcd_compressed_dump(char *s)

{

        int tmpfd;

        uint64_t magic;

	uint32_t version;

	char errbuf[BUFSIZE];

        if ((tmpfd = open(s, O_RDONLY)) < 0) {

		strcpy(errbuf, s);

                perror(errbuf);

                return FALSE;

        }

        if (read(tmpfd, &magic, sizeof(uint64_t)) != sizeof(uint64_t)) {

                close(tmpfd);

                return FALSE;

        }

        if (read(tmpfd, &version, sizeof(uint32_t)) != sizeof(uint32_t)) {

                close(tmpfd);

                return FALSE;

        }

        close(tmpfd);

        if (!((magic == LKCD_DUMP_MAGIC_NUMBER) || 

	     (magic == LKCD_DUMP_MAGIC_LIVE)))

		return FALSE;

	switch (version & ~(LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1))

	{

	case LKCD_DUMP_V1:

		lkcd->version = LKCD_DUMP_V1;

		return TRUE;

	case LKCD_DUMP_V2:

	case LKCD_DUMP_V3:

		lkcd->version = LKCD_DUMP_V2;

		return TRUE;

	case LKCD_DUMP_V5:

	case LKCD_DUMP_V6:

		lkcd->version = LKCD_DUMP_V5;

		return TRUE;

	case LKCD_DUMP_V7:

		lkcd->version = LKCD_DUMP_V7;

		return TRUE;

	case LKCD_DUMP_V8:

	case LKCD_DUMP_V9:

	case LKCD_DUMP_V10:

		lkcd->version = LKCD_DUMP_V8;

		return TRUE;

	default:

		lkcd_print("unsupported LKCD dump version: %ld (%lx)\n", 

			version & ~(LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1), 

			version);

		return FALSE;

	}

}

/*

 *  console-only output for info regarding current page.

 */

static void

dump_dump_page(char *s, void *dp)

{

        switch (lkcd->version)

        {

        case LKCD_DUMP_V1:

                dump_dump_page_v1(s, dp);

		break;

        case LKCD_DUMP_V2:

        case LKCD_DUMP_V3:

                dump_dump_page_v2_v3(s, dp);

		break;

        case LKCD_DUMP_V5:

                dump_dump_page_v5(s, dp);

                break;

        case LKCD_DUMP_V7:

                dump_dump_page_v7(s, dp);

		break;

        case LKCD_DUMP_V8:

        case LKCD_DUMP_V9:

                dump_dump_page_v8(s, dp);

		break;

        }

}

/*

 *  help -S output, or as specified by arg.

 */

void

dump_lkcd_environment(ulong arg)

{

	int others;

	if (arg == LKCD_DUMP_HEADER_ONLY)

		goto dump_header_only;

	if (arg == LKCD_DUMP_PAGE_ONLY)

		goto dump_page_only;

	lkcd_print("              fd: %d\n", lkcd->fd);

	lkcd_print("              fp: %lx\n", lkcd->fp);

	lkcd_print("           debug: %ld\n", lkcd->debug);

	lkcd_print("           flags: %lx  (", lkcd->flags);

	others = 0;

	if (lkcd->flags & LKCD_VALID)

		lkcd_print("%sLKCD_VALID", others++ ? "|" : "");

	if (lkcd->flags & LKCD_REMOTE)

		lkcd_print("%sLKCD_REMOTE", others++ ? "|" : "");

	if (lkcd->flags & LKCD_NOHASH)

		lkcd_print("%sLKCD_NOHASH", others++ ? "|" : "");

        if (lkcd->flags & LKCD_MCLX)

                lkcd_print("%sLKCD_MCLX", others++ ? "|" : "");

        if (lkcd->flags & LKCD_BAD_DUMP)

                lkcd_print("%sLKCD_BAD_DUMP", others++ ? "|" : "");

	lkcd_print(")\n");

dump_header_only:

        switch (lkcd->version)

        {

        case LKCD_DUMP_V1:

                dump_lkcd_environment_v1(LKCD_DUMP_HEADER_ONLY);

                break;

        case LKCD_DUMP_V2:

        case LKCD_DUMP_V3:

                dump_lkcd_environment_v2_v3(LKCD_DUMP_HEADER_ONLY);

                break;

        case LKCD_DUMP_V5:

                dump_lkcd_environment_v5(LKCD_DUMP_HEADER_ONLY);

                break;

        case LKCD_DUMP_V7:

                dump_lkcd_environment_v7(LKCD_DUMP_HEADER_ONLY);

		break;

        case LKCD_DUMP_V8:

        case LKCD_DUMP_V9:

                dump_lkcd_environment_v8(LKCD_DUMP_HEADER_ONLY);

		break;

        }

        if (arg == LKCD_DUMP_HEADER_ONLY)

                return;

dump_page_only:

        switch (lkcd->version)

        {

        case LKCD_DUMP_V1:

                dump_lkcd_environment_v1(LKCD_DUMP_PAGE_ONLY);

                break;

        case LKCD_DUMP_V2:

        case LKCD_DUMP_V3:

                dump_lkcd_environment_v2_v3(LKCD_DUMP_PAGE_ONLY);

                break;

        case LKCD_DUMP_V5:

                dump_lkcd_environment_v5(LKCD_DUMP_PAGE_ONLY);

                break;

        case LKCD_DUMP_V7:

                dump_lkcd_environment_v7(LKCD_DUMP_PAGE_ONLY);

		break;

        case LKCD_DUMP_V8:

                dump_lkcd_environment_v8(LKCD_DUMP_PAGE_ONLY);

		break;

        }

	if (arg == LKCD_DUMP_PAGE_ONLY)

		return;

	lkcd_print("         version: %ld\n", lkcd->version);

	lkcd_print("       page_size: %ld\n", lkcd->page_size);

	lkcd_print("      page_shift: %d\n", lkcd->page_shift);

	lkcd_print("            bits: %d\n", lkcd->bits);

	lkcd_print("      panic_task: %lx\n", lkcd->panic_task);

	lkcd_print("    panic_string: %s%s", lkcd->panic_string,

		lkcd->panic_string && strstr(lkcd->panic_string, "\n") ? 

		"" : "\n");

	lkcd_print("     get_dp_size: ");

	if (lkcd->get_dp_size == get_dp_size_v1)

		lkcd_print("get_dp_size_v1()\n");

	else if (lkcd->get_dp_size == get_dp_size_v2_v3)

		lkcd_print("get_dp_size_v2_v3()\n");

        else if (lkcd->get_dp_size == get_dp_size_v5)

                lkcd_print("get_dp_size_v5()\n");

	else

		lkcd_print("%lx\n", lkcd->get_dp_size);

        lkcd_print("    get_dp_flags: ");

        if (lkcd->get_dp_flags == get_dp_flags_v1)

                lkcd_print("get_dp_flags_v1()\n");

        else if (lkcd->get_dp_flags == get_dp_flags_v2_v3)

                lkcd_print("get_dp_flags_v2_v3()\n");

        else if (lkcd->get_dp_flags == get_dp_flags_v5)

                lkcd_print("get_dp_flags_v5()\n");

        else

                lkcd_print("%lx\n", lkcd->get_dp_flags);

        lkcd_print("  get_dp_address: ");

        if (lkcd->get_dp_address == get_dp_address_v1)

                lkcd_print("get_dp_address_v1()\n");

        else if (lkcd->get_dp_address == get_dp_address_v2_v3)

                lkcd_print("get_dp_address_v2_v3()\n");

        else if (lkcd->get_dp_address == get_dp_address_v5)

                lkcd_print("get_dp_address_v5()\n");

        else

                lkcd_print("%lx\n", lkcd->get_dp_address);

	lkcd_print("     compression: ");

	lkcd_print(BITS32() ? "%lx  " : "%x  ", lkcd->compression);

	switch (lkcd->compression)

	{

	case LKCD_DUMP_COMPRESS_NONE:

		lkcd_print("(LKCD_DUMP_COMPRESS_NONE)\n");

		break;

	case LKCD_DUMP_COMPRESS_RLE:

		lkcd_print("(LKCD_DUMP_COMPRESS_RLE)\n");

		break;

	case LKCD_DUMP_COMPRESS_GZIP:

		lkcd_print("(LKCD_DUMP_COMPRESS_GZIP)\n");

		break;

	default:

		lkcd_print("(unknown)\n");

		break;

	}

	lkcd_print("page_header_size: %ld\n", lkcd->page_header_size);

	lkcd_print("          curpos: %ld\n", lkcd->curpos);

	lkcd_print("        curpaddr: ");

	lkcd_print(BITS32() ? "%llx\n" : "%lx\n", lkcd->curpaddr);

	lkcd_print("       curbufptr: %lx\n", lkcd->curbufptr);

	lkcd_print("      curhdroffs: %ld\n", lkcd->curhdroffs);

	lkcd_print("          kvbase: ");

	lkcd_print(BITS32() ? "%llx\n" : "%lx\n", lkcd->kvbase);

	lkcd_print("  page_cache_buf: %lx\n", lkcd->page_cache_buf);

	lkcd_print(" compressed_page: %lx\n", lkcd->compressed_page);

	lkcd_print("     evict_index: %d\n", lkcd->evict_index);

	lkcd_print("       evictions: %ld\n", lkcd->evictions);

	lkcd_print(" benchmark_pages: %ld\n", lkcd->benchmark_pages);

	lkcd_print(" benchmarks_done: %ld\n", lkcd->benchmarks_done);

	lkcd_memory_dump(lkcd->fp);

}

/*

 *  Set the shadow debug flag.

 */

void

set_lkcd_debug(ulong debug)

{

	lkcd->debug = debug;

}

/*

 *  Set no-hash flag bit.

 */

void 

set_lkcd_nohash(void)

{

	lkcd->flags |= LKCD_NOHASH; 

}

/*

 *  Set the file pointer for debug output.

 */

FILE *

set_lkcd_fp(FILE *fp)

{

	lkcd->fp = fp;

	return fp;

}

/*

 *  Return the number of pages cached.

 */

int

lkcd_memory_used(void)

{

	int i, pages;

        struct page_cache_hdr *sp;

        sp = &lkcd->page_cache_hdr[0];

        for (i = pages = 0; i < LKCD_CACHED_PAGES; i++, sp++) { 

		if (LKCD_VALID_PAGE(sp->pg_flags))

			pages++;

	}

	return pages;

}

/*

 *  Since the dumpfile pages are temporary tenants of a fixed page cache,

 *  this command doesn't do anything except clear the references. 

 */

int

lkcd_free_memory(void)

{

        int i, pages;

        struct page_cache_hdr *sp;

        sp = &lkcd->page_cache_hdr[0];

        for (i = pages = 0; i < LKCD_CACHED_PAGES; i++, sp++) {

                if (LKCD_VALID_PAGE(sp->pg_flags)) {

			sp->pg_addr = 0;

			sp->pg_hit_count = 0;

                        pages++;

		}

		sp->pg_flags = 0;

        }

        return pages;

}

/*

 *  Dump the page cache;

 */

int

lkcd_memory_dump(FILE *fp)

{

        int i, c, pages;

        struct page_cache_hdr *sp;

        struct page_hash_entry *phe;

	ulong pct_cached, pct_hashed;

	ulong pct_compressed, pct_raw;

	FILE *fpsave;

	char buf[BUFSIZE];

	int wrap;

	fpsave = lkcd->fp;

	lkcd->fp = fp;

        lkcd_print("     total_pages: %ld\n", lkcd->total_pages);

        pct_compressed = (lkcd->compressed*100) /

                (lkcd->hashed ? lkcd->hashed : 1);

        pct_raw = (lkcd->raw*100) /

                (lkcd->hashed ? lkcd->hashed : 1);

        lkcd_print("          hashed: %ld\n", lkcd->hashed);

        lkcd_print("      compressed: %ld (%ld%%)\n", 

		lkcd->compressed, pct_compressed);

        lkcd_print("             raw: %ld (%ld%%)\n", 

		lkcd->raw, pct_raw);

        pct_cached = (lkcd->cached_reads*100) /  

                (lkcd->total_reads ? lkcd->total_reads : 1);

        pct_hashed = (lkcd->hashed_reads*100) /

                (lkcd->total_reads ? lkcd->total_reads : 1); 

        lkcd_print("    cached_reads: %ld (%ld%%)\n", lkcd->cached_reads,

                pct_cached);

        lkcd_print("    hashed_reads: %ld (%ld%%)\n", lkcd->hashed_reads,

                pct_hashed);

        lkcd_print("     total_reads: %ld (hashed or cached: %ld%%) \n",

            lkcd->total_reads, pct_cached+pct_hashed);

        lkcd_print("page_hash[%2d]:\n", LKCD_PAGE_HASH);

	if (LKCD_DEBUG(1)) {

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

	                phe = &lkcd->page_hash[i];

	                if (!LKCD_VALID_PAGE(phe->pg_flags))

	                        continue;

	                lkcd_print("  [%2d]: ", i);

	                wrap = 0;

	                while (phe && LKCD_VALID_PAGE(phe->pg_flags)) {

				sprintf(buf, "%llx@", 

					(ulonglong)phe->pg_addr);

				sprintf(&buf[strlen(buf)],

	                        	"%llx,", (ulonglong)phe->pg_hdr_offset);

				lkcd_print("%18s", buf);

	                        phe = phe->next;

	                        if (phe && (++wrap == 3)) {

	                                lkcd_print("\n        ");

	                                wrap = 0;

	                        }

	                }

	                lkcd_print("\n");

	        }

	} else {

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

	                phe = &lkcd->page_hash[i];

	                if (!LKCD_VALID_PAGE(phe->pg_flags))

	                        continue;

	                lkcd_print("  [%2d]: ", i);

	                wrap = 0;

	                while (phe && LKCD_VALID_PAGE(phe->pg_flags)) {

				lkcd_print(BITS32() ? "%9llx," : "%9lx,",

					phe->pg_addr);

	                        phe = phe->next;

	                        if (phe && (++wrap == 7)) {

	                                lkcd_print("\n        ");

	                                wrap = 0;

	                        }

	                }

	                lkcd_print("\n");

	        }

	}

        lkcd_print("page_cache_hdr[%2d]:\n", LKCD_CACHED_PAGES);

	lkcd_print(" INDEX   PG_ADDR  PG_BUFPTR");

        lkcd_print(BITS32() ? " PG_HIT_COUNT\n" : "        PG_HIT_COUNT\n");

        sp = &lkcd->page_cache_hdr[0];

        for (i = pages = 0; i < LKCD_CACHED_PAGES; i++, sp++) {

                if (LKCD_VALID_PAGE(sp->pg_flags))

                        pages++;

		if (BITS32())

                	lkcd_print("  [%2d] %9llx  %lx        %ld\n",

			    i, sp->pg_addr, sp->pg_bufptr, sp->pg_hit_count);

		else

                	lkcd_print("  [%2d] %9lx  %lx  %ld\n",

			    i, sp->pg_addr, sp->pg_bufptr, sp->pg_hit_count);

        }

	if (lkcd->mb_hdr_offsets) {

		lkcd_print("mb_hdr_offsets[%3ld]: \n", lkcd->benchmark_pages);

		for (i = 0; i < lkcd->benchmark_pages; i += 8) {

			lkcd_print("  [%3d]", i);

			c = 0;

			while ((c < 8) && ((i+c) < lkcd->benchmark_pages)) {

				lkcd_print(" %8lx", lkcd->mb_hdr_offsets[i+c]);

				c++;

			}

			lkcd_print("\n");

		}

	} else {

		lkcd_print("  mb_hdr_offsets: NA\n");

	}

	if (lkcd->zones) {

		lkcd_print("       num_zones: %d / %d\n", lkcd->num_zones,

				lkcd->max_zones);

		lkcd_print("   zoned_offsets: %ld\n", lkcd->zoned_offsets);

	}

	lkcd_print("  dumpfile_index: %s\n", lkcd->dumpfile_index);

	lkcd_print("             ifd: %d\n", lkcd->ifd);

        lkcd_print("    memory_pages: %ld\n", lkcd->memory_pages);

        lkcd_print(" page_offset_max: %ld\n", lkcd->page_offset_max);

        lkcd_print("  page_index_max: %ld\n", lkcd->page_index_max);

        lkcd_print("    page_offsets: %lx\n", lkcd->page_offsets);

	lkcd->fp = fpsave;

        return pages;

}

/*

 *  The lkcd_lseek() routine does the bulk of the work setting things up 

 *  so that the subsequent lkcd_read() simply has to do a bcopy().

 *  Given a physical address, first determine:

 *

 *   (1) its page offset (lkcd->curpos).

 *   (2) its page address as specified in the dumpfile (lkcd->curpaddr).

 *

 *  If the page data is already cached, everything will be set up for the

 *  subsequent read when page_is_cached() returns.

 *

 *  If the page data is not cached, either of the following occurs:

 *

 *   (1) page_is_hashed() will check whether the page header offset is cached,

 *       and if so, will set up the page variable, and lseek to the header.

 *

 *  In either case above, the starting point for the page search is set up.

 *  Lastly, cache_page() stores the requested page's data.

 */

static int

save_offset(uint64_t paddr, off_t off)

{

	uint64_t zone, page;

	int ii, ret;

	int max_zones;

	struct physmem_zone *zones;

	ret = -1;

	zone = paddr & lkcd->zone_mask;

	page = (paddr & ~lkcd->zone_mask) >> lkcd->page_shift;

	if (lkcd->num_zones == 0) {

		lkcd->zones = malloc(ZONE_ALLOC * sizeof(struct physmem_zone));

		if (!lkcd->zones) {

			return -1; /* This should be fatal */

		}

		BZERO(lkcd->zones, ZONE_ALLOC * sizeof(struct physmem_zone));

		lkcd->max_zones = ZONE_ALLOC;

		lkcd->zones[0].start = zone;

		lkcd->zones[0].pages = malloc((ZONE_SIZE >> lkcd->page_shift) *

					sizeof(struct page_desc));

		if (!lkcd->zones[0].pages) {

			return -1; /* this should be fatal */

		}

		BZERO(lkcd->zones[0].pages, (ZONE_SIZE >> lkcd->page_shift) *

					sizeof(struct page_desc));

		lkcd->num_zones++;

	}

retry:

	/* find the zone */

	for (ii=0; ii < lkcd->num_zones; ii++) {

		if (lkcd->zones[ii].start == zone) {

			if (lkcd->zones[ii].pages[page].offset != 0) {

			   if (lkcd->zones[ii].pages[page].offset != off) {

				if (CRASHDEBUG(1) && !STREQ(pc->curcmd, "search"))

				    error(INFO, "LKCD: conflicting page: zone %lld, "

					"page %lld: %lld, %lld != %lld\n",

					(unsigned long long)zone, 

					(unsigned long long)page, 

					(unsigned long long)paddr, 

					(unsigned long long)off,

					(unsigned long long)lkcd->zones[ii].pages[page].offset);

				return -1;

			   }

			   ret = 0;

			} else {

			   lkcd->zones[ii].pages[page].offset = off;

			   ret = 1;

			}

			break;

		}

	}

	if (ii == lkcd->num_zones) {

		/* This is a new zone */

		if (lkcd->num_zones < lkcd->max_zones) {

			/* We have room for another one */

			lkcd->zones[ii].start = zone;

			lkcd->zones[ii].pages = malloc(

					(ZONE_SIZE >> lkcd->page_shift) *

					sizeof(struct page_desc));

			if (!lkcd->zones[ii].pages) {

				return -1; /* this should be fatal */

			}

			BZERO(lkcd->zones[ii].pages, 

					(ZONE_SIZE >> lkcd->page_shift) *

					sizeof(struct page_desc));

			lkcd->zones[ii].pages[page].offset = off;

			ret = 1;

			lkcd->num_zones++;

		} else {

			/* need to expand zone */

			max_zones = lkcd->max_zones * 2;

			zones = malloc(max_zones * sizeof(struct physmem_zone));

			if (!zones) {

				return -1; /* This should be fatal */

			}

			BZERO(zones, max_zones * sizeof(struct physmem_zone));

			memcpy(zones, lkcd->zones,

				lkcd->max_zones * sizeof(struct physmem_zone));

			free(lkcd->zones);

			lkcd->zones = zones;

			lkcd->max_zones = max_zones;

			goto retry;

		}

	}

	return ret;  /* 1 if the page is new */

}

static off_t

get_offset(uint64_t paddr)

{

	uint64_t zone, page;

	int ii;

	zone = paddr & lkcd->zone_mask;

	page = (paddr % ZONE_SIZE) >> lkcd->page_shift;

	if (lkcd->zones == 0) {

		return 0;

	}

	/* find the zone */

	for (ii=0; ii < lkcd->num_zones; ii++) {

		if (lkcd->zones[ii].start == zone) {

			return (lkcd->zones[ii].pages[page].offset);

		}

	}

	return 0;

}

#ifdef IA64

int

lkcd_get_kernel_start(ulong *addr)

{

	if (!addr)

		return 0;

	switch (lkcd->version)

	{

        case LKCD_DUMP_V8:

        case LKCD_DUMP_V9:

		return lkcd_get_kernel_start_v8(addr);

	default:

		return 0;

	}

}

#endif

int

lkcd_lseek(physaddr_t paddr)

{

	int err;

        int eof;

        void *dp;

        long page = 0;

	physaddr_t physaddr;

	int seeked_to_page = 0;

	off_t page_offset;

	dp = lkcd->dump_page;

	lkcd->curpos = paddr & ((physaddr_t)(lkcd->page_size-1));

        lkcd->curpaddr = paddr & ~((physaddr_t)(lkcd->page_size-1));

	if (page_is_cached()) 

		return TRUE;

	/* Faster than paging in lkcd->page_offsets[page] */

	if(page_is_hashed(&page)) {

		seeked_to_page = 1;

	}

	 /* Find the offset for this page, if known */

    if ((page_offset = get_offset(paddr)) > 0) {

	off_t seek_offset;

	seek_offset = lseek(lkcd->fd, page_offset, SEEK_SET);

	if (seek_offset == page_offset) {

	    seeked_to_page = 1;

	    page = 0; /* page doesn't make any sense */

	}

    }

    if (seeked_to_page) {

	err = lkcd_load_dump_page_header(dp, page);

	if (err == LKCD_DUMPFILE_OK) {

	    return(cache_page());

	}

    }	

    /* We have to grind through some more of the dump file */

    lseek(lkcd->fd, lkcd->page_offset_max, SEEK_SET);

    eof = FALSE;

    while (!eof) {

	switch (lkcd_load_dump_page_header(dp, page))

	{

	    case LKCD_DUMPFILE_OK:

		break;

	    case LKCD_DUMPFILE_EOF:

		eof = TRUE;

		continue;

	}

	physaddr = lkcd->get_dp_flags() & 

	    (LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1) ?

	    (lkcd->get_dp_address() - lkcd->kvbase) << lkcd->page_shift:

	    lkcd->get_dp_address() - lkcd->kvbase;

	if (physaddr == lkcd->curpaddr) {

	    return(cache_page());

	}

	lseek(lkcd->fd, lkcd->get_dp_size(), SEEK_CUR);

    }

	return FALSE;

}

/*

 *  Everything's been set up by the previous lkcd_lseek(), so all that has

 *  to be done is to read the uncompressed data into the user buffer:

 *

 *    lkcd->curbufptr points to the uncompressed page base.

 *    lkcd->curpos is the offset into the buffer.

 */

long 

lkcd_read(void *buf, long count)

{

	char *p;

	lkcd->total_reads++;

	p = lkcd->curbufptr + lkcd->curpos;

	BCOPY(p, buf, count);

	return count;

}

/*

 *  Check whether lkcd->curpaddr is already cached.  If it is, update

 *  lkcd->curbufptr to point to the page's uncompressed data.  

 */

static int