RepoMirrors/crash
1
0
Fork 0
mirror of https://github.com/crash-utility/crash synced 2024-12-12 20:24:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
03e3937ec7
crash/lkcd_common.c
Dave Anderson 03e3937ec7 Initial commit: crash-7.0.4
2014-01-28 16:46:11 -05:00

1438 lines
37 KiB
C
Raw Blame History

/* 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;
}
static void
lkcd_speedo(void)
{
static int i = 0;
if (pc->flags & SILENT) {
return;
}
switch (++i%4) {
case 0:
lkcd_print("|\b");
break;
case 1:
lkcd_print("\\\b");
break;
case 2:
lkcd_print("-\b");
break;
case 3:
lkcd_print("/\b");
break;
}
fflush(stdout);
}
/*
* 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)
{
long i = 0;
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) {
if( (i++%2048) == 0) {
lkcd_speedo();
}
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
page_is_cached(void)
{
int i;
for (i = 0; i < LKCD_CACHED_PAGES; i++) {
if (!LKCD_VALID_PAGE(lkcd->page_cache_hdr[i].pg_flags))
continue;
if (lkcd->page_cache_hdr[i].pg_addr == lkcd->curpaddr) {
lkcd->page_cache_hdr[i].pg_hit_count++;
lkcd->curbufptr = lkcd->page_cache_hdr[i].pg_bufptr;
lkcd->cached_reads++;
return TRUE;
}
}
return FALSE;
}
/*
* For an incoming page:
*
* (1) If it's already hashed just return TRUE.
* (2) If the base page_hash_entry is unused, fill it up and return TRUE;
* (3) Otherwise, find the last page_hash_entry on the list, allocate and
* fill a new one, link it on the list, and return TRUE.
* (4) If the malloc fails, quietly return FALSE (with no harm done).
*/
static int
hash_page(ulong type)
{
struct page_hash_entry *phe;
int index;
if (lkcd->flags & LKCD_NOHASH) {
lkcd->flags &= ~LKCD_NOHASH;
return FALSE;
}
index = LKCD_PAGE_HASH_INDEX(lkcd->curpaddr);
for (phe = &lkcd->page_hash[index]; LKCD_VALID_PAGE(phe->pg_flags);
phe = phe->next) {
if (phe->pg_addr == lkcd->curpaddr)
return TRUE;
if (!phe->next)
break;
}
if (LKCD_VALID_PAGE(phe->pg_flags)) {
if ((phe->next = malloc
(sizeof(struct page_hash_entry))) == NULL)
return FALSE;
phe = phe->next;
}
phe->pg_flags |= LKCD_VALID;
phe->pg_addr = lkcd->curpaddr;
phe->pg_hdr_offset = lkcd->curhdroffs;
phe->next = NULL;
lkcd->hashed++;
switch (type)
{
case LKCD_DUMP_COMPRESSED:
lkcd->compressed++;
break;
case LKCD_DUMP_RAW:
lkcd->raw++;
break;
}
return TRUE;
}
/*
* Check whether a page is currently hashed, and if so, return the page
* number so that the subsequent search loop will find it immediately.
*/
static int
page_is_hashed(long *pp)
{
struct page_hash_entry *phe;
int index;
index = LKCD_PAGE_HASH_INDEX(lkcd->curpaddr);
for (phe = &lkcd->page_hash[index]; LKCD_VALID_PAGE(phe->pg_flags);
phe = phe->next) {
if (phe->pg_addr == lkcd->curpaddr) {
*pp = (long)(lkcd->curpaddr >> lkcd->page_shift);
lseek(lkcd->fd, phe->pg_hdr_offset, SEEK_SET);
lkcd->hashed_reads++;
return TRUE;
}
if (!phe->next)
break;
}
return FALSE;
}
/*
* The caller stores the incoming page's page header offset in
* lkcd->curhdroffs.
*/
int
set_mb_benchmark(ulong page)
{
long mb;
if ((mb = LKCD_PAGE_MEGABYTE(page)) >= lkcd->benchmark_pages)
return FALSE;
if (!lkcd->mb_hdr_offsets[mb]) {
lkcd->mb_hdr_offsets[mb] = lkcd->curhdroffs;
lkcd->benchmarks_done++;
}
return TRUE;
}
/*
* Coming into this routine:
*
* (1) lkcd->curpaddr points to the page address as specified in the dumpfile.
* (2) the dump_page header has been copied into lkcd->dump_page.
* (3) the file pointer is sitting at the beginning of the page data,
* be it compressed or otherwise.
* (4) lkcd->curhdroffs contains the file pointer to the incoming page's
* header offset.
*
* If an empty page cache location is available, take it. Otherwise, evict
* the entry indexed by evict_index, and then bump evict index. The hit_count
* is only gathered for dump_lkcd_environment().
*
* If the page is compressed, uncompress it into the selected page cache entry.
* If the page is raw, just copy it into the selected page cache entry.
* If all works OK, update lkcd->curbufptr to point to the page's uncompressed
* data.
*
*/
static int
cache_page(void)
{
int i;
ulong type;
int found, newsz;
uint32_t rawsz;
ssize_t bytes ATTRIBUTE_UNUSED;
for (i = found = 0; i < LKCD_CACHED_PAGES; i++) {
if (LKCD_VALID_PAGE(lkcd->page_cache_hdr[i].pg_flags))
continue;
found = TRUE;
break;
}
if (!found) {
i = lkcd->evict_index;
lkcd->page_cache_hdr[i].pg_hit_count = 0;
lkcd->evict_index = (lkcd->evict_index+1) % LKCD_CACHED_PAGES;
lkcd->evictions++;
}
lkcd->page_cache_hdr[i].pg_flags = 0;
lkcd->page_cache_hdr[i].pg_addr = lkcd->curpaddr;
lkcd->page_cache_hdr[i].pg_hit_count++;
type = lkcd->get_dp_flags() & (LKCD_DUMP_COMPRESSED|LKCD_DUMP_RAW);
switch (type)
{
case LKCD_DUMP_COMPRESSED:
if (LKCD_DEBUG(2))
dump_dump_page("cmp: ", lkcd->dump_page);
newsz = 0;
BZERO(lkcd->compressed_page, lkcd->page_size);
bytes = read(lkcd->fd, lkcd->compressed_page, lkcd->get_dp_size());
switch (lkcd->compression)
{
case LKCD_DUMP_COMPRESS_NONE:
lkcd_print("dump_header: DUMP_COMPRESS_NONE and "
"dump_page: DUMP_COMPRESSED (?)\n");
return FALSE;
case LKCD_DUMP_COMPRESS_RLE:
if (!lkcd_uncompress_RLE((unsigned char *)
lkcd->compressed_page,
(unsigned char *)lkcd->page_cache_hdr[i].pg_bufptr,
lkcd->get_dp_size(), &newsz) ||
(newsz != lkcd->page_size)) {
lkcd_print("uncompress of page ");
lkcd_print(BITS32() ?
"%llx failed!\n" : "%lx failed!\n",
lkcd->get_dp_address());
lkcd_print("newsz returned: %d\n", newsz);
return FALSE;
}
break;
case LKCD_DUMP_COMPRESS_GZIP:
if (!lkcd_uncompress_gzip((unsigned char *)
lkcd->page_cache_hdr[i].pg_bufptr, lkcd->page_size,
(unsigned char *)lkcd->compressed_page,
lkcd->get_dp_size())) {
lkcd_print("uncompress of page ");
lkcd_print(BITS32() ?
"%llx failed!\n" : "%lx failed!\n",
lkcd->get_dp_address());
return FALSE;
}
break;
}
break;
case LKCD_DUMP_RAW:
if (LKCD_DEBUG(2))
dump_dump_page("raw: ", lkcd->dump_page);
if ((rawsz = lkcd->get_dp_size()) == 0)
BZERO(lkcd->page_cache_hdr[i].pg_bufptr,
lkcd->page_size);
else if (rawsz == lkcd->page_size)
bytes = read(lkcd->fd, lkcd->page_cache_hdr[i].pg_bufptr,
lkcd->page_size);
else {
lkcd_print("cache_page: "
"invalid LKCD_DUMP_RAW dp_size\n");
dump_lkcd_environment(LKCD_DUMP_PAGE_ONLY);
return FALSE;
}
break;
default:
lkcd_print("cache_page: bogus page:\n");
dump_lkcd_environment(LKCD_DUMP_PAGE_ONLY);
return FALSE;
}
lkcd->page_cache_hdr[i].pg_flags |= LKCD_VALID;
lkcd->curbufptr = lkcd->page_cache_hdr[i].pg_bufptr;
hash_page(type);
return TRUE;
}
/*
* Uncompress an RLE-encoded buffer.
*/
static int
lkcd_uncompress_RLE(unsigned char *cbuf, unsigned char *ucbuf,
uint32_t blk_size, int *new_size)
{
int i;
unsigned char value, count, cur_byte;
uint32_t ri, wi;
/* initialize the read / write indices */
ri = wi = 0;
/* otherwise decompress using run length encoding */
while(ri < blk_size) {
cur_byte = cbuf[ri++];
if (cur_byte == 0) {
count = cbuf[ri++];
if (count == 0) {
ucbuf[wi++] = 0;
} else {
value = cbuf[ri++];
for (i = 0; i <= count; i++) {
ucbuf[wi++] = value;
}
}
} else {
ucbuf[wi++] = cur_byte;
}
/* if our write index is beyond the page size, exit out */
if (wi > /* PAGE_SIZE */ lkcd->page_size) {
lkcd_print(
"Attempted to decompress beyond page boundaries: file corrupted!\n");
return (0);
}
}
/* set return size to be equal to uncompressed size (in bytes) */
*new_size = wi;
return 1;
}
/* Returns the bit offset if it's able to correct, or negative if not */
static int
uncompress_recover(unsigned char *dest, ulong destlen,
unsigned char *source, ulong sourcelen)
{
int byte, bit;
ulong retlen = destlen;
int good_decomp = 0, good_rv = -1;
/* Generate all single bit errors */
if (sourcelen > 16384) {
lkcd_print("uncompress_recover: sourcelen %ld too long\n",
sourcelen);
return(-1);
}
for (byte = 0; byte < sourcelen; byte++) {
for (bit = 0; bit < 8; bit++) {
source[byte] ^= (1 << bit);
if (uncompress(dest, &retlen, source, sourcelen) == Z_OK &&
retlen == destlen) {
good_decomp++;
lkcd_print("good for flipping byte %d bit %d\n",
byte, bit);
good_rv = bit + byte * 8;
}
/* Put it back */
source[byte] ^= (1 << bit);
}
}
if (good_decomp == 0) {
lkcd_print("Could not correct gzip errors.\n");
return -2;
} else if (good_decomp > 1) {
lkcd_print("Too many valid gzip decompressions: %d.\n", good_decomp);
return -3;
} else {
source[good_rv >> 8] ^= 1 << (good_rv % 8);
uncompress(dest, &retlen, source, sourcelen);
source[good_rv >> 8] ^= 1 << (good_rv % 8);
return good_rv;
}
}
/*
* Uncompress a gzip'd buffer.
*
* Returns FALSE on error. If set, then
* a non-negative value of uncompress_errloc indicates the location of
* a single-bit error, and the data may be used.
*/
static int
lkcd_uncompress_gzip(unsigned char *dest, ulong destlen,
unsigned char *source, ulong sourcelen)
{
ulong retlen = destlen;
int rc = FALSE;
switch (uncompress(dest, &retlen, source, sourcelen))
{
case Z_OK:
if (retlen == destlen)
rc = TRUE;
break;
lkcd_print("uncompress: returned length not page size: %ld\n",
retlen);
rc = FALSE;
break;
case Z_MEM_ERROR:
lkcd_print("uncompress: Z_MEM_ERROR (not enough memory)\n");
rc = FALSE;
break;
case Z_BUF_ERROR:
lkcd_print("uncompress: "
"Z_BUF_ERROR (not enough room in output buffer)\n");
rc = FALSE;
break;
case Z_DATA_ERROR:
lkcd_print("uncompress: Z_DATA_ERROR (input data corrupted)\n");
rc = FALSE;
break;
default:
rc = FALSE;
break;
}
if (rc == FALSE) {
uncompress_errloc =
uncompress_recover(dest, destlen, source, sourcelen);
}
return rc;
}
/*
* Generic print routine to handle integral and remote daemon usage of
*/
void
lkcd_print(char *fmt, ...)
{
char buf[BUFSIZE];
va_list ap;
if (!fmt || !strlen(fmt))
return;
va_start(ap, fmt);
(void)vsnprintf(buf, BUFSIZE, fmt, ap);
va_end(ap);
if (lkcd->fp)
fprintf(lkcd->fp, "%s", buf);
else
console(buf);
}
/*
* Try to read the current dump page header, reporting back either
* LKCD_DUMPFILE_EOF, LKCD_DUMPFILE_END or LKCD_DUMPFILE_OK. The header's
* file pointer position is saved in lkcd->curhdroffs. If the page is
* an even megabyte, save its offset.
*/
int
lkcd_load_dump_page_header(void *dp, ulong page)
{
uint32_t dp_flags;
uint64_t dp_address, physaddr;
off_t page_offset;
int ret;
/* This is wasted effort */
page_offset = lkcd->curhdroffs = lseek(lkcd->fd, 0, SEEK_CUR);
if (read(lkcd->fd, dp, lkcd->page_header_size) !=
lkcd->page_header_size) {
if (page > lkcd->total_pages)
lkcd_dumpfile_complaint(page, lkcd->total_pages,
LKCD_DUMPFILE_EOF);
return LKCD_DUMPFILE_EOF;
}
dp_flags = lkcd->get_dp_flags();
dp_address = lkcd->get_dp_address();
if (dp_flags & LKCD_DUMP_END) {
return LKCD_DUMPFILE_END;
}
if ((lkcd->flags & LKCD_VALID) && (page > lkcd->total_pages))
lkcd->total_pages = page;
#ifdef X86
/*
* Ugly leftover from very early x86 LKCD versions which used
* the kernel unity-mapped virtual address as the dp_address.
*/
if ((page == 0) && !(lkcd->flags & LKCD_VALID) &&
(lkcd->version == LKCD_DUMP_V1) &&
(dp_address == 0xc0000000))
lkcd->kvbase = dp_address;
#endif
physaddr = dp_flags & (LKCD_DUMP_MCLX_V0|LKCD_DUMP_MCLX_V1) ?
(dp_address - lkcd->kvbase) << lkcd->page_shift :
dp_address - lkcd->kvbase;
if ((ret = save_offset(physaddr, page_offset)) < 0) {
return LKCD_DUMPFILE_EOF; /* really an error */
}
lkcd->zoned_offsets += ret; /* return = 0 if already known */
if (page_offset > lkcd->page_offset_max) {
/* doesn't this mean I have to re-read this dp? */
lkcd->page_offset_max = page_offset;
}
return LKCD_DUMPFILE_OK;
}
/*
* Register a complaint one time, if appropriate.
*/
void
lkcd_dumpfile_complaint(uint32_t realpages, uint32_t dh_num_pages, int retval)
{
if (lkcd->flags & LKCD_BAD_DUMP)
return;
lkcd->flags |= LKCD_BAD_DUMP;
if (realpages > dh_num_pages) {
lkcd_print(
"\n\nWARNING: This dumpfile contains more pages than the amount indicated\n"
" in the dumpfile header. This is indicative of a failure during\n"
" the post-panic creation of the dumpfile on the dump device.\n\n");
}
if (realpages < dh_num_pages) {
lkcd_print(
"\n\nWARNING: This dumpfile contains fewer pages than the amount indicated\n"
" in the dumpfile header. This is indicative of a failure during\n"
" the creation of the dumpfile during boot.\n\n");
}
}
int
get_lkcd_regs_for_cpu(struct bt_info *bt, ulong *eip, ulong *esp)
{
switch (lkcd->version) {
case LKCD_DUMP_V8:
case LKCD_DUMP_V9:
return get_lkcd_regs_for_cpu_v8(bt, eip, esp);
default:
return -1;
}
}
Reference in New Issue View Git Blame Copy Permalink