RepoMirrors/crash
1
0
Fork 0
mirror of https://github.com/crash-utility/crash synced 2024-12-14 13:14:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
045c00ac34
crash/xendump.c
Dave Anderson 77537c1273 Fix for the handling of 32-bit ELF xendump dumpfiles if the guest 
was configured with more than 4GB of memory.  Without the patch, the
crash session may fail during initialization with the error message
"crash: vmlinux and <dumpfile> do not match!".
(dslutz@verizon.com)
2014-06-12 10:42:33 -04:00

2864 lines
76 KiB
C
Raw Blame History

/*
* xendump.c
*
* Copyright (C) 2006-2011, 2013-2014 David Anderson
* Copyright (C) 2006-2011, 2013-2014 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.
*/
#include "defs.h"
#include "xendump.h"
static struct xendump_data xendump_data = { 0 };
static struct xendump_data *xd = &xendump_data;
static int xc_save_verify(char *);
static int xc_core_verify(char *, char *);
static int xc_save_read(void *, int, ulong, physaddr_t);
static int xc_core_read(void *, int, ulong, physaddr_t);
static int xc_core_mfns(ulong, FILE *);
static void poc_store(ulong, off_t);
static off_t poc_get(ulong, int *);
static void xen_dump_vmconfig(FILE *);
static void xc_core_create_pfn_tables(void);
static ulong xc_core_pfn_to_page_index(ulong);
static int xc_core_pfn_valid(ulong);
static void xendump_print(char *fmt, ...);
static int xc_core_elf_verify(char *, char *);
static void xc_core_elf_dump(void);
static char *xc_core_elf_mfn_to_page(ulong, char *);
static int xc_core_elf_mfn_to_page_index(ulong);
static ulong xc_core_elf_pfn_valid(ulong);
static ulong xc_core_elf_pfn_to_page_index(ulong);
static void xc_core_dump_Elf32_Ehdr(Elf32_Ehdr *);
static void xc_core_dump_Elf64_Ehdr(Elf64_Ehdr *);
static void xc_core_dump_Elf32_Shdr(Elf32_Off offset, int);
static void xc_core_dump_Elf64_Shdr(Elf64_Off offset, int);
static char *xc_core_strtab(uint32_t, char *);
static void xc_core_dump_elfnote(off_t, size_t, int);
static void xc_core_elf_pfn_init(void);
#define ELFSTORE 1
#define ELFREAD 0
/*
* Determine whether a file is a xendump creation, and if TRUE,
* initialize the xendump_data structure.
*/
int
is_xendump(char *file)
{
int verified;
char buf[BUFSIZE];
if ((xd->xfd = open(file, O_RDWR)) < 0) {
if ((xd->xfd = open(file, O_RDONLY)) < 0) {
sprintf(buf, "%s: open", file);
perror(buf);
return FALSE;
}
}
if (read(xd->xfd, buf, BUFSIZE) != BUFSIZE)
return FALSE;
if (machine_type("X86") || machine_type("X86_64"))
xd->page_size = 4096;
else if (machine_type("IA64") && !machdep->pagesize)
xd->page_size = 16384;
else
xd->page_size = machdep->pagesize;
verified = xc_save_verify(buf) || xc_core_verify(file, buf);
if (!verified)
close(xd->xfd);
return (verified);
}
/*
* Verify whether the dump was created by the xc_domain_dumpcore()
* library function in libxc/xc_core.c.
*/
static int
xc_core_verify(char *file, char *buf)
{
struct xc_core_header *xcp;
xcp = (struct xc_core_header *)buf;
if (xc_core_elf_verify(file, buf))
return TRUE;
if ((xcp->xch_magic != XC_CORE_MAGIC) &&
(xcp->xch_magic != XC_CORE_MAGIC_HVM))
return FALSE;
if (!xcp->xch_nr_vcpus) {
error(INFO,
"faulty xc_core dump file header: xch_nr_vcpus is 0\n\n");
fprintf(stderr, " xch_magic: %x\n", xcp->xch_magic);
fprintf(stderr, " xch_nr_vcpus: %d\n", xcp->xch_nr_vcpus);
fprintf(stderr, " xch_nr_pages: %d\n", xcp->xch_nr_pages);
fprintf(stderr, " xch_ctxt_offset: %d\n", xcp->xch_ctxt_offset);
fprintf(stderr, " xch_index_offset: %d\n", xcp->xch_index_offset);
fprintf(stderr, " xch_pages_offset: %d\n\n", xcp->xch_pages_offset);
clean_exit(1);
}
xd->xc_core.header.xch_magic = xcp->xch_magic;
xd->xc_core.header.xch_nr_vcpus = xcp->xch_nr_vcpus;
xd->xc_core.header.xch_nr_pages = xcp->xch_nr_pages;
xd->xc_core.header.xch_ctxt_offset = (off_t)xcp->xch_ctxt_offset;
xd->xc_core.header.xch_index_offset = (off_t)xcp->xch_index_offset;
xd->xc_core.header.xch_pages_offset = (off_t)xcp->xch_pages_offset;
xd->flags |= (XENDUMP_LOCAL | XC_CORE_ORIG | XC_CORE_P2M_CREATE);
if (xc_core_mfns(XC_CORE_64BIT_HOST, stderr))
xd->flags |= XC_CORE_64BIT_HOST;
if (!xd->page_size)
error(FATAL,
"unknown page size: use -p <pagesize> command line option\n");
if (!(xd->page = (char *)malloc(xd->page_size)))
error(FATAL, "cannot malloc page space.");
if (!(xd->poc = (struct pfn_offset_cache *)calloc
(PFN_TO_OFFSET_CACHE_ENTRIES,
sizeof(struct pfn_offset_cache))))
error(FATAL, "cannot malloc pfn_offset_cache\n");
xd->last_pfn = ~(0UL);
if (CRASHDEBUG(1))
xendump_memory_dump(stderr);
return TRUE;
}
/*
* Do the work for read_xendump() for the XC_CORE dumpfile format.
*/
static int
xc_core_read(void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
ulong pfn, page_index;
off_t offset;
int redundant;
if (xd->flags & (XC_CORE_P2M_CREATE|XC_CORE_PFN_CREATE))
xc_core_create_pfn_tables();
pfn = (ulong)BTOP(paddr);
if ((offset = poc_get(pfn, &redundant))) {
if (!redundant) {
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
return SEEK_ERROR;
if (read(xd->xfd, xd->page, xd->page_size) !=
xd->page_size)
return READ_ERROR;
xd->last_pfn = pfn;
}
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
if ((page_index = xc_core_pfn_to_page_index(pfn)) ==
PFN_NOT_FOUND)
return READ_ERROR;
offset = xd->xc_core.header.xch_pages_offset +
((off_t)(page_index) * (off_t)xd->page_size);
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
return SEEK_ERROR;
if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
return READ_ERROR;
poc_store(pfn, offset);
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
/*
* Verify whether the dumpfile was created by the "xm save" facility.
* This gets started by the "save" function in XendCheckpoint.py, and
* then by xc_save.c, with the work done in the xc_linux_save() library
* function in libxc/xc_linux_save.c.
*/
#define MAX_BATCH_SIZE 1024
/*
* Number of P2M entries in a page.
*/
#define ULPP (xd->page_size/sizeof(unsigned long))
/*
* Number of P2M entries in the pfn_to_mfn_frame_list.
*/
#define P2M_FL_ENTRIES (((xd->xc_save.nr_pfns)+ULPP-1)/ULPP)
/*
* Size in bytes of the pfn_to_mfn_frame_list.
*/
#define P2M_FL_SIZE ((P2M_FL_ENTRIES)*sizeof(unsigned long))
#define XTAB (0xf<<28) /* invalid page */
#define LTAB_MASK XTAB
static int
xc_save_verify(char *buf)
{
int i, batch_count, done_batch, *intptr;
ulong flags, *ulongptr;
ulong batch_index, total_pages_read;
ulong N;
if (!STRNEQ(buf, XC_SAVE_SIGNATURE))
return FALSE;
if (lseek(xd->xfd, strlen(XC_SAVE_SIGNATURE), SEEK_SET) == -1)
return FALSE;
flags = XC_SAVE;
if (CRASHDEBUG(1)) {
fprintf(stderr, "\"%s\"\n", buf);
fprintf(stderr, "endian: %d %s\n", __BYTE_ORDER,
__BYTE_ORDER == __BIG_ENDIAN ? "__BIG_ENDIAN" :
(__BYTE_ORDER == __LITTLE_ENDIAN ?
"__LITTLE_ENDIAN" : "???"));
}
/*
* size of vmconfig data structure (big-endian)
*/
if (read(xd->xfd, buf, sizeof(int)) != sizeof(int))
return FALSE;
intptr = (int *)buf;
if (CRASHDEBUG(1) && BYTE_SWAP_REQUIRED(__BIG_ENDIAN)) {
fprintf(stderr, "byte-swap required for this:\n");
for (i = 0; i < sizeof(int); i++)
fprintf(stderr, "[%x]", buf[i] & 0xff);
fprintf(stderr, ": %x -> ", *intptr);
}
xd->xc_save.vmconfig_size = swab32(*intptr);
if (CRASHDEBUG(1))
fprintf(stderr, "%x\n", xd->xc_save.vmconfig_size);
if (!(xd->xc_save.vmconfig_buf = (char *)malloc
(xd->xc_save.vmconfig_size)))
error(FATAL, "cannot malloc xc_save vmconfig space.");
if (!xd->page_size)
error(FATAL,
"unknown page size: use -p <pagesize> command line option\n");
if (!(xd->page = (char *)malloc(xd->page_size)))
error(FATAL, "cannot malloc page space.");
if (!(xd->poc = (struct pfn_offset_cache *)calloc
(PFN_TO_OFFSET_CACHE_ENTRIES,
sizeof(struct pfn_offset_cache))))
error(FATAL, "cannot malloc pfn_offset_cache\n");
xd->last_pfn = ~(0UL);
if (!(xd->xc_save.region_pfn_type = (ulong *)calloc
(MAX_BATCH_SIZE, sizeof(ulong))))
error(FATAL, "cannot malloc region_pfn_type\n");
if (read(xd->xfd, xd->xc_save.vmconfig_buf,
xd->xc_save.vmconfig_size) != xd->xc_save.vmconfig_size)
goto xc_save_bailout;
/*
* nr_pfns (native byte order)
*/
if (read(xd->xfd, buf, sizeof(ulong)) != sizeof(ulong))
goto xc_save_bailout;
ulongptr = (ulong *)buf;
if (CRASHDEBUG(1)) {
for (i = 0; i < sizeof(ulong); i++)
fprintf(stderr, "[%x]", buf[i] & 0xff);
fprintf(stderr, ": %lx (nr_pfns)\n", *ulongptr);
}
xd->xc_save.nr_pfns = *ulongptr;
if (machine_type("IA64"))
goto xc_save_ia64;
/*
* Get a local copy of the live_P2M_frame_list
*/
if (!(xd->xc_save.p2m_frame_list = (unsigned long *)malloc(P2M_FL_SIZE)))
error(FATAL, "cannot allocate p2m_frame_list array");
if (!(xd->xc_save.batch_offsets = (off_t *)calloc((size_t)P2M_FL_ENTRIES,
sizeof(off_t))))
error(FATAL, "cannot allocate batch_offsets array");
xd->xc_save.batch_count = P2M_FL_ENTRIES;
if (read(xd->xfd, xd->xc_save.p2m_frame_list, P2M_FL_SIZE) !=
P2M_FL_SIZE)
goto xc_save_bailout;
if (CRASHDEBUG(1))
fprintf(stderr, "pre-batch file pointer: %lld\n",
(ulonglong)lseek(xd->xfd, 0L, SEEK_CUR));
/*
* ...
* int batch_count
* ulong region pfn_type[batch_count]
* page 0
* page 1
* ...
* page batch_count-1
* (repeat)
*/
total_pages_read = 0;
batch_index = 0;
done_batch = FALSE;
while (!done_batch) {
xd->xc_save.batch_offsets[batch_index] = (off_t)
lseek(xd->xfd, 0L, SEEK_CUR);
if (read(xd->xfd, &batch_count, sizeof(int)) != sizeof(int))
goto xc_save_bailout;
if (CRASHDEBUG(1))
fprintf(stderr, "batch[%ld]: %d ",
batch_index, batch_count);
batch_index++;
if (batch_index >= P2M_FL_ENTRIES) {
fprintf(stderr, "more than %ld batches encountered?\n",
P2M_FL_ENTRIES);
goto xc_save_bailout;
}
switch (batch_count)
{
case 0:
if (CRASHDEBUG(1)) {
fprintf(stderr,
": Batch work is done: %ld pages read (P2M_FL_ENTRIES: %ld)\n",
total_pages_read, P2M_FL_ENTRIES);
}
done_batch = TRUE;
continue;
case -1:
if (CRASHDEBUG(1))
fprintf(stderr, ": Entering page verify mode\n");
continue;
default:
if (batch_count > MAX_BATCH_SIZE) {
if (CRASHDEBUG(1))
fprintf(stderr,
": Max batch size exceeded. Giving up.\n");
done_batch = TRUE;
continue;
}
if (CRASHDEBUG(1))
fprintf(stderr, "\n");
break;
}
if (read(xd->xfd, xd->xc_save.region_pfn_type, batch_count * sizeof(ulong)) !=
batch_count * sizeof(ulong))
goto xc_save_bailout;
for (i = 0; i < batch_count; i++) {
unsigned long pagetype;
unsigned long pfn;
pfn = xd->xc_save.region_pfn_type[i] & ~LTAB_MASK;
pagetype = xd->xc_save.region_pfn_type[i] & LTAB_MASK;
if (pagetype == XTAB)
/* a bogus/unmapped page: skip it */
continue;
if (pfn > xd->xc_save.nr_pfns) {
if (CRASHDEBUG(1))
fprintf(stderr,
"batch_count: %d pfn %ld out of range",
batch_count, pfn);
}
if (lseek(xd->xfd, xd->page_size, SEEK_CUR) == -1)
goto xc_save_bailout;
total_pages_read++;
}
}
/*
* Get the list of PFNs that are not in the psuedo-phys map
*/
if (read(xd->xfd, &xd->xc_save.pfns_not,
sizeof(xd->xc_save.pfns_not)) != sizeof(xd->xc_save.pfns_not))
goto xc_save_bailout;
if (CRASHDEBUG(1))
fprintf(stderr, "PFNs not in pseudo-phys map: %d\n",
xd->xc_save.pfns_not);
if ((total_pages_read + xd->xc_save.pfns_not) !=
xd->xc_save.nr_pfns)
error(WARNING,
"nr_pfns: %ld != (total pages: %ld + pages not saved: %d)\n",
xd->xc_save.nr_pfns, total_pages_read,
xd->xc_save.pfns_not);
xd->xc_save.pfns_not_offset = lseek(xd->xfd, 0L, SEEK_CUR);
if (lseek(xd->xfd, sizeof(ulong) * xd->xc_save.pfns_not, SEEK_CUR) == -1)
goto xc_save_bailout;
xd->xc_save.vcpu_ctxt_offset = lseek(xd->xfd, 0L, SEEK_CUR);
lseek(xd->xfd, 0, SEEK_END);
lseek(xd->xfd, -((off_t)(xd->page_size)), SEEK_CUR);
xd->xc_save.shared_info_page_offset = lseek(xd->xfd, 0L, SEEK_CUR);
xd->flags |= (XENDUMP_LOCAL | flags);
kt->xen_flags |= (CANONICAL_PAGE_TABLES|XEN_SUSPEND);
if (CRASHDEBUG(1))
xendump_memory_dump(stderr);
return TRUE;
xc_save_ia64:
/*
* Completely different format for ia64:
*
* ...
* pfn #
* page data
* pfn #
* page data
* ...
*/
free(xd->poc);
xd->poc = NULL;
free(xd->xc_save.region_pfn_type);
xd->xc_save.region_pfn_type = NULL;
if (!(xd->xc_save.ia64_page_offsets =
(ulong *)calloc(xd->xc_save.nr_pfns, sizeof(off_t))))
error(FATAL, "cannot allocate ia64_page_offsets array");
/*
* version
*/
if (read(xd->xfd, buf, sizeof(ulong)) != sizeof(ulong))
goto xc_save_bailout;
xd->xc_save.ia64_version = *((ulong *)buf);
if (CRASHDEBUG(1))
fprintf(stderr, "ia64 version: %lx\n",
xd->xc_save.ia64_version);
/*
* xen_domctl_arch_setup structure
*/
if (read(xd->xfd, buf, sizeof(xen_domctl_arch_setup_t)) !=
sizeof(xen_domctl_arch_setup_t))
goto xc_save_bailout;
if (CRASHDEBUG(1)) {
xen_domctl_arch_setup_t *setup =
(xen_domctl_arch_setup_t *)buf;
fprintf(stderr, "xen_domctl_arch_setup:\n");
fprintf(stderr, " flags: %lx\n", (ulong)setup->flags);
fprintf(stderr, " bp: %lx\n", (ulong)setup->bp);
fprintf(stderr, " maxmem: %lx\n", (ulong)setup->maxmem);
fprintf(stderr, " xsi_va: %lx\n", (ulong)setup->xsi_va);
fprintf(stderr, "hypercall_imm: %x\n", setup->hypercall_imm);
}
for (i = N = 0; i < xd->xc_save.nr_pfns; i++) {
if (read(xd->xfd, &N, sizeof(N)) != sizeof(N))
goto xc_save_bailout;
if (N < xd->xc_save.nr_pfns)
xd->xc_save.ia64_page_offsets[N] =
lseek(xd->xfd, 0, SEEK_CUR);
else
error(WARNING,
"[%d]: pfn of %lx (0x%lx) in ia64 canonical page list exceeds %ld\n",
i, N, N, xd->xc_save.nr_pfns);
if (CRASHDEBUG(1)) {
if ((i < 10) || (N >= (xd->xc_save.nr_pfns-10)))
fprintf(stderr, "[%d]: %ld\n%s", i, N,
i == 9 ? "...\n" : "");
}
if ((N+1) >= xd->xc_save.nr_pfns)
break;
if (lseek(xd->xfd, xd->page_size, SEEK_CUR) == -1)
goto xc_save_bailout;
}
if (CRASHDEBUG(1)) {
for (i = N = 0; i < xd->xc_save.nr_pfns; i++) {
if (!xd->xc_save.ia64_page_offsets[i])
N++;
}
fprintf(stderr, "%ld out of %ld pfns not dumped\n",
N, xd->xc_save.nr_pfns);
}
xd->flags |= (XENDUMP_LOCAL | flags | XC_SAVE_IA64);
kt->xen_flags |= (CANONICAL_PAGE_TABLES|XEN_SUSPEND);
if (CRASHDEBUG(1))
xendump_memory_dump(stderr);
return TRUE;
xc_save_bailout:
error(INFO,
"xc_save_verify: \"LinuxGuestRecord\" file handling/format error\n");
if (xd->xc_save.p2m_frame_list) {
free(xd->xc_save.p2m_frame_list);
xd->xc_save.p2m_frame_list = NULL;
}
if (xd->xc_save.batch_offsets) {
free(xd->xc_save.batch_offsets);
xd->xc_save.batch_offsets = NULL;
}
if (xd->xc_save.vmconfig_buf) {
free(xd->xc_save.vmconfig_buf);
xd->xc_save.vmconfig_buf = NULL;
}
if (xd->page) {
free(xd->page);
xd->page = NULL;
}
return FALSE;
}
/*
* Do the work for read_xendump() for the XC_SAVE dumpfile format.
*/
static int
xc_save_read(void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
int b, i, redundant;
ulong reqpfn;
int batch_count;
off_t file_offset;
reqpfn = (ulong)BTOP(paddr);
if (CRASHDEBUG(8))
fprintf(xd->ofp,
"xc_save_read(bufptr: %lx cnt: %d addr: %lx paddr: %llx (%ld, 0x%lx)\n",
(ulong)bufptr, cnt, addr, (ulonglong)paddr, reqpfn, reqpfn);
if (xd->flags & XC_SAVE_IA64) {
if (reqpfn >= xd->xc_save.nr_pfns) {
if (CRASHDEBUG(1))
fprintf(xd->ofp,
"xc_save_read: pfn %lx too large: nr_pfns: %lx\n",
reqpfn, xd->xc_save.nr_pfns);
return SEEK_ERROR;
}
file_offset = xd->xc_save.ia64_page_offsets[reqpfn];
if (!file_offset) {
if (CRASHDEBUG(1))
fprintf(xd->ofp,
"xc_save_read: pfn %lx not stored in xendump\n",
reqpfn);
return SEEK_ERROR;
}
if (reqpfn != xd->last_pfn) {
if (lseek(xd->xfd, file_offset, SEEK_SET) == -1)
return SEEK_ERROR;
if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
return READ_ERROR;
} else {
xd->redundant++;
xd->cache_hits++;
}
xd->accesses++;
xd->last_pfn = reqpfn;
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
if ((file_offset = poc_get(reqpfn, &redundant))) {
if (!redundant) {
if (lseek(xd->xfd, file_offset, SEEK_SET) == -1)
return SEEK_ERROR;
if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
return READ_ERROR;
xd->last_pfn = reqpfn;
} else if (CRASHDEBUG(1))
console("READ %ld (0x%lx) skipped!\n", reqpfn, reqpfn);
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
/*
* ...
* int batch_count
* ulong region pfn_type[batch_count]
* page 0
* page 1
* ...
* page batch_count-1
* (repeat)
*/
for (b = 0; b < xd->xc_save.batch_count; b++) {
if (lseek(xd->xfd, xd->xc_save.batch_offsets[b], SEEK_SET) == -1)
return SEEK_ERROR;
if (CRASHDEBUG(8))
fprintf(xd->ofp, "check batch[%d]: offset: %llx\n",
b, (ulonglong)xd->xc_save.batch_offsets[b]);
if (read(xd->xfd, &batch_count, sizeof(int)) != sizeof(int))
return READ_ERROR;
switch (batch_count)
{
case 0:
if (CRASHDEBUG(1) && !STREQ(pc->curcmd, "search")) {
fprintf(xd->ofp,
"batch[%d]: has count of zero -- bailing out on pfn %ld\n",
b, reqpfn);
}
return READ_ERROR;
case -1:
return READ_ERROR;
default:
if (CRASHDEBUG(8))
fprintf(xd->ofp,
"batch[%d]: offset: %llx batch count: %d\n",
b, (ulonglong)xd->xc_save.batch_offsets[b],
batch_count);
break;
}
if (read(xd->xfd, xd->xc_save.region_pfn_type, batch_count * sizeof(ulong)) !=
batch_count * sizeof(ulong))
return READ_ERROR;
for (i = 0; i < batch_count; i++) {
unsigned long pagetype;
unsigned long pfn;
pfn = xd->xc_save.region_pfn_type[i] & ~LTAB_MASK;
pagetype = xd->xc_save.region_pfn_type[i] & LTAB_MASK;
if (pagetype == XTAB)
/* a bogus/unmapped page: skip it */
continue;
if (pfn > xd->xc_save.nr_pfns) {
if (CRASHDEBUG(1))
fprintf(stderr,
"batch_count: %d pfn %ld out of range",
batch_count, pfn);
}
if (pfn == reqpfn) {
file_offset = lseek(xd->xfd, 0, SEEK_CUR);
poc_store(pfn, file_offset);
if (read(xd->xfd, xd->page, xd->page_size) !=
xd->page_size)
return READ_ERROR;
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
if (lseek(xd->xfd, xd->page_size, SEEK_CUR) == -1)
return SEEK_ERROR;
}
}
return READ_ERROR;
}
/*
* Stash a pfn's offset. If they're all in use, put it in the
* least-used slot that's closest to the beginning of the array.
*/
static void
poc_store(ulong pfn, off_t file_offset)
{
int i;
struct pfn_offset_cache *poc, *plow;
ulong curlow;
curlow = ~(0UL);
plow = NULL;
poc = xd->poc;
for (i = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++, poc++) {
if (poc->cnt == 0) {
poc->cnt = 1;
poc->pfn = pfn;
poc->file_offset = file_offset;
xd->last_pfn = pfn;
return;
}
if (poc->cnt < curlow) {
curlow = poc->cnt;
plow = poc;
}
}
plow->cnt = 1;
plow->pfn = pfn;
plow->file_offset = file_offset;
xd->last_pfn = pfn;
}
/*
* Check whether a pfn's offset has been cached.
*/
static off_t
poc_get(ulong pfn, int *redundant)
{
int i;
struct pfn_offset_cache *poc;
xd->accesses++;
if (pfn == xd->last_pfn) {
xd->redundant++;
*redundant = TRUE;
return 1;
} else
*redundant = FALSE;
poc = xd->poc;
for (i = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++, poc++) {
if (poc->cnt && (poc->pfn == pfn)) {
poc->cnt++;
xd->cache_hits++;
return poc->file_offset;
}
}
return 0;
}
/*
* Perform any post-dumpfile determination stuff here.
*/
int
xendump_init(char *unused, FILE *fptr)
{
if (!XENDUMP_VALID())
return FALSE;
xd->ofp = fptr;
return TRUE;
}
int
read_xendump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
if (pc->curcmd_flags & XEN_MACHINE_ADDR)
return READ_ERROR;
switch (xd->flags & (XC_SAVE|XC_CORE_ORIG|XC_CORE_ELF))
{
case XC_SAVE:
return xc_save_read(bufptr, cnt, addr, paddr);
case XC_CORE_ORIG:
case XC_CORE_ELF:
return xc_core_read(bufptr, cnt, addr, paddr);
default:
return READ_ERROR;
}
}
int
read_xendump_hyper(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
ulong pfn, page_index;
off_t offset;
pfn = (ulong)BTOP(paddr);
/* ODA: pfn == mfn !!! */
if ((page_index = xc_core_mfn_to_page_index(pfn)) == PFN_NOT_FOUND)
return READ_ERROR;
offset = xd->xc_core.header.xch_pages_offset +
((off_t)(page_index) * (off_t)xd->page_size);
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
return SEEK_ERROR;
if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
return READ_ERROR;
BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
return cnt;
}
int
write_xendump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
{
return WRITE_ERROR;
}
uint
xendump_page_size(void)
{
if (!XENDUMP_VALID())
return 0;
return xd->page_size;
}
/*
* xendump_free_memory(), and xendump_memory_used()
* are debug only, and typically unnecessary to implement.
*/
int
xendump_free_memory(void)
{
return 0;
}
int
xendump_memory_used(void)
{
return 0;
}
/*
* This function is dump-type independent, used here to
* to dump the xendump_data structure contents.
*/
int
xendump_memory_dump(FILE *fp)
{
int i, linefeed, used, others;
ulong *ulongptr;
Elf32_Off offset32;
Elf64_Off offset64;
FILE *fpsave;
fprintf(fp, " flags: %lx (", xd->flags);
others = 0;
if (xd->flags & XENDUMP_LOCAL)
fprintf(fp, "%sXENDUMP_LOCAL", others++ ? "|" : "");
if (xd->flags & XC_SAVE)
fprintf(fp, "%sXC_SAVE", others++ ? "|" : "");
if (xd->flags & XC_CORE_ORIG)
fprintf(fp, "%sXC_CORE_ORIG", others++ ? "|" : "");
if (xd->flags & XC_CORE_ELF)
fprintf(fp, "%sXC_CORE_ELF", others++ ? "|" : "");
if (xd->flags & XC_CORE_P2M_CREATE)
fprintf(fp, "%sXC_CORE_P2M_CREATE", others++ ? "|" : "");
if (xd->flags & XC_CORE_PFN_CREATE)
fprintf(fp, "%sXC_CORE_PFN_CREATE", others++ ? "|" : "");
if (xd->flags & XC_CORE_NO_P2M)
fprintf(fp, "%sXC_CORE_NO_P2M", others++ ? "|" : "");
if (xd->flags & XC_SAVE_IA64)
fprintf(fp, "%sXC_SAVE_IA64", others++ ? "|" : "");
if (xd->flags & XC_CORE_64BIT_HOST)
fprintf(fp, "%sXC_CORE_64BIT_HOST", others++ ? "|" : "");
fprintf(fp, ")\n");
fprintf(fp, " xfd: %d\n", xd->xfd);
fprintf(fp, " page_size: %d\n", xd->page_size);
fprintf(fp, " ofp: %lx\n", (ulong)xd->ofp);
fprintf(fp, " page: %lx\n", (ulong)xd->page);
fprintf(fp, " panic_pc: %lx\n", xd->panic_pc);
fprintf(fp, " panic_sp: %lx\n", xd->panic_sp);
fprintf(fp, " accesses: %ld\n", (ulong)xd->accesses);
fprintf(fp, " cache_hits: %ld ", (ulong)xd->cache_hits);
if (xd->accesses)
fprintf(fp, "(%ld%%)\n", xd->cache_hits * 100 / xd->accesses);
else
fprintf(fp, "\n");
fprintf(fp, " last_pfn: %ld\n", xd->last_pfn);
fprintf(fp, " redundant: %ld ", (ulong)xd->redundant);
if (xd->accesses)
fprintf(fp, "(%ld%%)\n", xd->redundant * 100 / xd->accesses);
else
fprintf(fp, "\n");
for (i = used = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++)
if (xd->poc && xd->poc[i].cnt)
used++;
if (xd->poc)
fprintf(fp, " poc[%d]: %lx %s", PFN_TO_OFFSET_CACHE_ENTRIES,
(ulong)xd->poc, xd->poc ? "" : "(none)");
else
fprintf(fp, " poc[0]: (unused)\n");
for (i = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++) {
if (!xd->poc)
break;
if (!xd->poc[i].cnt) {
if (!i)
fprintf(fp, "(none used)\n");
break;
} else if (!i)
fprintf(fp, "(%d used)\n", used);
if (CRASHDEBUG(2))
fprintf(fp,
" [%d]: pfn: %ld (0x%lx) count: %ld file_offset: %llx\n",
i,
xd->poc[i].pfn,
xd->poc[i].pfn,
xd->poc[i].cnt,
(ulonglong)xd->poc[i].file_offset);
}
if (!xd->poc)
fprintf(fp, "\n");
fprintf(fp, "\n xc_save:\n");
fprintf(fp, " nr_pfns: %ld (0x%lx)\n",
xd->xc_save.nr_pfns, xd->xc_save.nr_pfns);
fprintf(fp, " vmconfig_size: %d (0x%x)\n", xd->xc_save.vmconfig_size,
xd->xc_save.vmconfig_size);
fprintf(fp, " vmconfig_buf: %lx\n", (ulong)xd->xc_save.vmconfig_buf);
if (xd->flags & XC_SAVE)
xen_dump_vmconfig(fp);
fprintf(fp, " p2m_frame_list: %lx ", (ulong)xd->xc_save.p2m_frame_list);
if ((xd->flags & XC_SAVE) && xd->xc_save.p2m_frame_list) {
fprintf(fp, "\n");
ulongptr = xd->xc_save.p2m_frame_list;
for (i = 0; i < P2M_FL_ENTRIES; i++, ulongptr++)
fprintf(fp, "%ld ", *ulongptr);
fprintf(fp, "\n");
} else
fprintf(fp, "(none)\n");
fprintf(fp, " pfns_not: %d\n", xd->xc_save.pfns_not);
fprintf(fp, " pfns_not_offset: %lld\n",
(ulonglong)xd->xc_save.pfns_not_offset);
fprintf(fp, " vcpu_ctxt_offset: %lld\n",
(ulonglong)xd->xc_save.vcpu_ctxt_offset);
fprintf(fp, " shared_info_page_offset: %lld\n",
(ulonglong)xd->xc_save.shared_info_page_offset);
fprintf(fp, " region_pfn_type: %lx\n", (ulong)xd->xc_save.region_pfn_type);
fprintf(fp, " batch_count: %ld\n", (ulong)xd->xc_save.batch_count);
fprintf(fp, " batch_offsets: %lx %s\n",
(ulong)xd->xc_save.batch_offsets,
xd->xc_save.batch_offsets ? "" : "(none)");
for (i = linefeed = 0; i < xd->xc_save.batch_count; i++) {
fprintf(fp, "[%d]: %llx ", i,
(ulonglong)xd->xc_save.batch_offsets[i]);
if (((i+1)%4) == 0) {
fprintf(fp, "\n");
linefeed = FALSE;
} else
linefeed = TRUE;
}
if (linefeed)
fprintf(fp, "\n");
fprintf(fp, " ia64_version: %ld\n", (ulong)xd->xc_save.ia64_version);
fprintf(fp, " ia64_page_offsets: %lx ", (ulong)xd->xc_save.ia64_page_offsets);
if (xd->xc_save.ia64_page_offsets)
fprintf(fp, "(%ld entries)\n\n", xd->xc_save.nr_pfns);
else
fprintf(fp, "(none)\n\n");
fprintf(fp, " xc_core:\n");
fprintf(fp, " header:\n");
fprintf(fp, " xch_magic: %x ",
xd->xc_core.header.xch_magic);
if (xd->xc_core.header.xch_magic == XC_CORE_MAGIC)
fprintf(fp, "(XC_CORE_MAGIC)\n");
else if (xd->xc_core.header.xch_magic == XC_CORE_MAGIC_HVM)
fprintf(fp, "(XC_CORE_MAGIC_HVM)\n");
else
fprintf(fp, "(unknown)\n");
fprintf(fp, " xch_nr_vcpus: %d\n",
xd->xc_core.header.xch_nr_vcpus);
fprintf(fp, " xch_nr_pages: %d (0x%x)\n",
xd->xc_core.header.xch_nr_pages,
xd->xc_core.header.xch_nr_pages);
fprintf(fp, " xch_ctxt_offset: %llu (0x%llx)\n",
(ulonglong)xd->xc_core.header.xch_ctxt_offset,
(ulonglong)xd->xc_core.header.xch_ctxt_offset);
fprintf(fp, " xch_index_offset: %llu (0x%llx)\n",
(ulonglong)xd->xc_core.header.xch_index_offset,
(ulonglong)xd->xc_core.header.xch_index_offset);
fprintf(fp, " xch_pages_offset: %llu (0x%llx)\n",
(ulonglong)xd->xc_core.header.xch_pages_offset,
(ulonglong)xd->xc_core.header.xch_pages_offset);
fprintf(fp, " elf_class: %s\n", xd->xc_core.elf_class == ELFCLASS64 ? "ELFCLASS64" :
xd->xc_core.elf_class == ELFCLASS32 ? "ELFCLASS32" : "n/a");
fprintf(fp, " elf_strtab_offset: %lld (0x%llx)\n",
(ulonglong)xd->xc_core.elf_strtab_offset,
(ulonglong)xd->xc_core.elf_strtab_offset);
fprintf(fp, " format_version: %016llx\n",
(ulonglong)xd->xc_core.format_version);
fprintf(fp, " shared_info_offset: %lld (0x%llx)\n",
(ulonglong)xd->xc_core.shared_info_offset,
(ulonglong)xd->xc_core.shared_info_offset);
if (machine_type("IA64"))
fprintf(fp, " ia64_mapped_regs_offset: %lld (0x%llx)\n",
(ulonglong)xd->xc_core.ia64_mapped_regs_offset,
(ulonglong)xd->xc_core.ia64_mapped_regs_offset);
fprintf(fp, " elf_index_pfn[%d]: %s", INDEX_PFN_COUNT,
xd->xc_core.elf_class ? "\n" : "(none used)\n");
if (xd->xc_core.elf_class) {
for (i = 0; i < INDEX_PFN_COUNT; i++) {
fprintf(fp, "%ld:%ld ",
xd->xc_core.elf_index_pfn[i].index,
xd->xc_core.elf_index_pfn[i].pfn);
}
fprintf(fp, "\n");
}
fprintf(fp, " last_batch:\n");
fprintf(fp, " index: %ld (%ld - %ld)\n",
xd->xc_core.last_batch.index,
xd->xc_core.last_batch.start, xd->xc_core.last_batch.end);
fprintf(fp, " accesses: %ld\n",
xd->xc_core.last_batch.accesses);
fprintf(fp, " duplicates: %ld ",
xd->xc_core.last_batch.duplicates);
if (xd->xc_core.last_batch.accesses)
fprintf(fp, "(%ld%%)\n",
xd->xc_core.last_batch.duplicates * 100 /
xd->xc_core.last_batch.accesses);
else
fprintf(fp, "\n");
fprintf(fp, " elf32: %lx\n", (ulong)xd->xc_core.elf32);
fprintf(fp, " elf64: %lx\n", (ulong)xd->xc_core.elf64);
fprintf(fp, " p2m_frames: %d\n",
xd->xc_core.p2m_frames);
fprintf(fp, " p2m_frame_index_list: %s\n",
(xd->flags & (XC_CORE_NO_P2M|XC_SAVE)) ? "(not used)" : "");
for (i = 0; i < xd->xc_core.p2m_frames; i++) {
fprintf(fp, "%ld ",
xd->xc_core.p2m_frame_index_list[i]);
}
fprintf(fp, xd->xc_core.p2m_frames ? "\n" : "");
if ((xd->flags & XC_CORE_ORIG) && CRASHDEBUG(8))
xc_core_mfns(XENDUMP_LOCAL, fp);
switch (xd->xc_core.elf_class)
{
case ELFCLASS32:
fpsave = xd->ofp;
xd->ofp = fp;
xc_core_elf_dump();
offset32 = xd->xc_core.elf32->e_shoff;
for (i = 0; i < xd->xc_core.elf32->e_shnum; i++) {
xc_core_dump_Elf32_Shdr(offset32, ELFREAD);
offset32 += xd->xc_core.elf32->e_shentsize;
}
xendump_print("\n");
xd->ofp = fpsave;
break;
case ELFCLASS64:
fpsave = xd->ofp;
xd->ofp = fp;
xc_core_elf_dump();
offset64 = xd->xc_core.elf64->e_shoff;
for (i = 0; i < xd->xc_core.elf64->e_shnum; i++) {
xc_core_dump_Elf64_Shdr(offset64, ELFREAD);
offset64 += xd->xc_core.elf64->e_shentsize;
}
xendump_print("\n");
xd->ofp = fpsave;
break;
}
return 0;
}
static void
xen_dump_vmconfig(FILE *fp)
{
int i, opens, closes;
char *p;
opens = closes = 0;
p = xd->xc_save.vmconfig_buf;
for (i = 0; i < xd->xc_save.vmconfig_size; i++, p++) {
if (ascii(*p))
fprintf(fp, "%c", *p);
else
fprintf(fp, "<%x>", *p);
if (*p == '(')
opens++;
else if (*p == ')')
closes++;
}
fprintf(fp, "\n");
if (opens != closes)
error(WARNING, "invalid vmconfig contents?\n");
}
/*
* Looking at the active set, try to determine who panicked,
* or who was the "suspend" kernel thread.
*/
ulong get_xendump_panic_task(void)
{
int i;
ulong task;
struct task_context *tc;
switch (xd->flags & (XC_CORE_ORIG|XC_CORE_ELF|XC_SAVE))
{
case XC_CORE_ORIG:
case XC_CORE_ELF:
if (machdep->xendump_panic_task)
return (machdep->xendump_panic_task((void *)xd));
break;
case XC_SAVE:
for (i = 0; i < NR_CPUS; i++) {
if (!(task = tt->active_set[i]))
continue;
tc = task_to_context(task);
if (is_kernel_thread(task) &&
STREQ(tc->comm, "suspend"))
return tc->task;
}
break;
}
return NO_TASK;
}
/*
* Figure out the back trace hooks.
*/
void get_xendump_regs(struct bt_info *bt, ulong *pc, ulong *sp)
{
int i;
ulong *up;
if ((tt->panic_task == bt->task) &&
(xd->panic_pc && xd->panic_sp)) {
*pc = xd->panic_pc;
*sp = xd->panic_sp;
return;
}
switch (xd->flags & (XC_CORE_ORIG|XC_CORE_ELF|XC_SAVE))
{
case XC_CORE_ORIG:
case XC_CORE_ELF:
if (machdep->get_xendump_regs)
return (machdep->get_xendump_regs(xd, bt, pc, sp));
break;
case XC_SAVE:
if (tt->panic_task != bt->task)
break;
for (i = 0, up = (ulong *)bt->stackbuf;
i < LONGS_PER_STACK; i++, up++) {
if (is_kernel_text(*up) &&
(STREQ(closest_symbol(*up),
"__do_suspend"))) {
*pc = *up;
*sp = tt->flags & THREAD_INFO ?
bt->tc->thread_info +
(i * sizeof(long)) :
bt->task +
(i * sizeof(long));
xd->panic_pc = *pc;
xd->panic_sp = *sp;
return;
}
}
}
machdep->get_stack_frame(bt, pc, sp);
}
/*
* Farm out most of the work to the proper architecture to create
* the p2m table. For ELF core dumps, create the index;pfn table.
*/
static void
xc_core_create_pfn_tables(void)
{
if (xd->flags & XC_CORE_P2M_CREATE) {
if (!machdep->xendump_p2m_create)
error(FATAL,
"xen xc_core dumpfiles not supported on this architecture");
if (!machdep->xendump_p2m_create((void *)xd))
error(FATAL,
"cannot create xen pfn-to-mfn mapping\n");
}
if (xd->flags & XC_CORE_ELF)
xc_core_elf_pfn_init();
xd->flags &= ~(XC_CORE_P2M_CREATE|XC_CORE_PFN_CREATE);
if (CRASHDEBUG(1))
xendump_memory_dump(xd->ofp);
}
/*
* Find the page index containing the mfn, and read the
* machine page into the buffer.
*/
char *
xc_core_mfn_to_page(ulong mfn, char *pgbuf)
{
int i, b, idx, done;
ulong tmp[MAX_BATCH_SIZE];
off_t offset;
size_t size;
uint nr_pages;
if (xd->flags & XC_CORE_ELF)
return xc_core_elf_mfn_to_page(mfn, pgbuf);
if (lseek(xd->xfd, xd->xc_core.header.xch_index_offset,
SEEK_SET) == -1) {
error(INFO, "cannot lseek to page index\n");
return NULL;
}
nr_pages = xd->xc_core.header.xch_nr_pages;
if (xd->flags & XC_CORE_64BIT_HOST)
nr_pages *= 2;
for (b = 0, idx = -1, done = FALSE;
!done && (b < nr_pages); b += MAX_BATCH_SIZE) {
size = sizeof(ulong) * MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, tmp, size) != size) {
error(INFO, "cannot read index page %d\n", b);
return NULL;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages) {
done = TRUE;
break;
}
if (tmp[i] == mfn) {
idx = i+b;
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"page: found mfn 0x%lx (%ld) at index %d\n",
mfn, mfn, idx);
done = TRUE;
}
}
}
if (idx == -1) {
error(INFO, "cannot find mfn %ld (0x%lx) in page index\n",
mfn, mfn);
return NULL;
}
if (lseek(xd->xfd, xd->xc_core.header.xch_pages_offset,
SEEK_SET) == -1) {
error(INFO, "cannot lseek to xch_pages_offset\n");
return NULL;
}
offset = (off_t)(idx) * (off_t)xd->page_size;
if (lseek(xd->xfd, offset, SEEK_CUR) == -1) {
error(INFO, "cannot lseek to mfn-specified page\n");
return NULL;
}
if (read(xd->xfd, pgbuf, xd->page_size) != xd->page_size) {
error(INFO, "cannot read mfn-specified page\n");
return NULL;
}
return pgbuf;
}
/*
* Find the page index containing the mfn, and read the
* machine page into the buffer.
*/
static char *
xc_core_elf_mfn_to_page(ulong mfn, char *pgbuf)
{
int i, b, idx, done;
off_t offset;
size_t size;
uint nr_pages;
ulong tmp;
struct xen_dumpcore_p2m p2m_batch[MAX_BATCH_SIZE];
offset = xd->xc_core.header.xch_index_offset;
nr_pages = xd->xc_core.header.xch_nr_pages;
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL, "cannot lseek to page index\n");
for (b = 0, idx = -1, done = FALSE;
!done && (b < nr_pages); b += MAX_BATCH_SIZE) {
size = sizeof(struct xen_dumpcore_p2m) *
MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, &p2m_batch[0], size) != size) {
error(INFO, "cannot read index page %d\n", b);
return NULL;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages) {
done = TRUE;
break;
}
tmp = (ulong)p2m_batch[i].gmfn;
if (tmp == mfn) {
idx = i+b;
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"page: found mfn 0x%lx (%ld) at index %d\n",
mfn, mfn, idx);
done = TRUE;
}
}
}
if (idx == -1) {
error(INFO, "cannot find mfn %ld (0x%lx) in page index\n",
mfn, mfn);
return NULL;
}
if (lseek(xd->xfd, xd->xc_core.header.xch_pages_offset,
SEEK_SET) == -1)
error(FATAL, "cannot lseek to xch_pages_offset\n");
offset = (off_t)(idx) * (off_t)xd->page_size;
if (lseek(xd->xfd, offset, SEEK_CUR) == -1) {
error(INFO, "cannot lseek to mfn-specified page\n");
return NULL;
}
if (read(xd->xfd, pgbuf, xd->page_size) != xd->page_size) {
error(INFO, "cannot read mfn-specified page\n");
return NULL;
}
return pgbuf;
}
/*
* Find and return the page index containing the mfn.
*/
int
xc_core_mfn_to_page_index(ulong mfn)
{
int i, b;
ulong tmp[MAX_BATCH_SIZE];
uint nr_pages;
size_t size;
if (xd->flags & XC_CORE_ELF)
return xc_core_elf_mfn_to_page_index(mfn);
if (lseek(xd->xfd, xd->xc_core.header.xch_index_offset,
SEEK_SET) == -1) {
error(INFO, "cannot lseek to page index\n");
return MFN_NOT_FOUND;
}
nr_pages = xd->xc_core.header.xch_nr_pages;
if (xd->flags & XC_CORE_64BIT_HOST)
nr_pages *= 2;
for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(ulong) * MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, tmp, size) != size) {
error(INFO, "cannot read index page %d\n", b);
return MFN_NOT_FOUND;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
if (tmp[i] == mfn) {
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"index: batch: %d found mfn %ld (0x%lx) at index %d\n",
b/MAX_BATCH_SIZE, mfn, mfn, i+b);
return (i+b);
}
}
}
return MFN_NOT_FOUND;
}
/*
* Find and return the page index containing the mfn.
*/
static int
xc_core_elf_mfn_to_page_index(ulong mfn)
{
int i, b;
off_t offset;
size_t size;
uint nr_pages;
ulong tmp;
struct xen_dumpcore_p2m p2m_batch[MAX_BATCH_SIZE];
offset = xd->xc_core.header.xch_index_offset;
nr_pages = xd->xc_core.header.xch_nr_pages;
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL, "cannot lseek to page index\n");
for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(struct xen_dumpcore_p2m) *
MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, &p2m_batch[0], size) != size) {
error(INFO, "cannot read index page %d\n", b);
return MFN_NOT_FOUND;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
tmp = (ulong)p2m_batch[i].gmfn;
if (tmp == mfn) {
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"index: batch: %d found mfn %ld (0x%lx) at index %d\n",
b/MAX_BATCH_SIZE, mfn, mfn, i+b);
return (i+b);
}
}
}
return MFN_NOT_FOUND;
}
/*
* XC_CORE mfn-related utility function.
*/
static int
xc_core_mfns(ulong arg, FILE *ofp)
{
int i, b;
uint nr_pages;
ulong tmp[MAX_BATCH_SIZE];
ulonglong tmp64[MAX_BATCH_SIZE];
size_t size;
if (lseek(xd->xfd, xd->xc_core.header.xch_index_offset,
SEEK_SET) == -1) {
error(INFO, "cannot lseek to page index\n");
return FALSE;
}
switch (arg)
{
case XC_CORE_64BIT_HOST:
/*
* Determine whether this is a 32-bit guest xendump that
* was taken on a 64-bit xen host.
*/
if (machine_type("X86_64") || machine_type("IA64"))
return FALSE;
check_next_4:
if (read(xd->xfd, tmp, sizeof(ulong) * 4) != (4 * sizeof(ulong))) {
error(INFO, "cannot read index pages\n");
return FALSE;
}
if ((tmp[0] == 0xffffffff) || (tmp[1] == 0xffffffff) ||
(tmp[2] == 0xffffffff) || (tmp[3] == 0xffffffff) ||
(!tmp[0] && !tmp[1]) || (!tmp[2] && !tmp[3]))
goto check_next_4;
if (CRASHDEBUG(2))
fprintf(ofp, "mfns: %08lx %08lx %08lx %08lx\n",
tmp[0], tmp[1], tmp[2], tmp[3]);
if (tmp[0] && !tmp[1] && tmp[2] && !tmp[3])
return TRUE;
else
return FALSE;
case XENDUMP_LOCAL:
if (BITS64() || (xd->flags & XC_CORE_64BIT_HOST))
goto show_64bit_mfns;
fprintf(ofp, "xch_index_offset mfn list:\n");
nr_pages = xd->xc_core.header.xch_nr_pages;
for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(ulong) *
MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, tmp, size) != size) {
error(INFO, "cannot read index page %d\n", b);
return FALSE;
}
if (b) fprintf(ofp, "\n");
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
if ((i%8) == 0)
fprintf(ofp, "%s[%d]:",
i ? "\n" : "", b+i);
if (tmp[i] == 0xffffffff)
fprintf(ofp, " INVALID");
else
fprintf(ofp, " %lx", tmp[i]);
}
}
fprintf(ofp, "\nxch_nr_pages: %d\n",
xd->xc_core.header.xch_nr_pages);
return TRUE;
show_64bit_mfns:
fprintf(ofp, "xch_index_offset mfn list: %s\n",
BITS32() ? "(64-bit mfns)" : "");
nr_pages = xd->xc_core.header.xch_nr_pages;
for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(ulonglong) *
MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, tmp64, size) != size) {
error(INFO, "cannot read index page %d\n", b);
return FALSE;
}
if (b) fprintf(ofp, "\n");
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
if ((i%8) == 0)
fprintf(ofp, "%s[%d]:",
i ? "\n" : "", b+i);
if (tmp64[i] == 0xffffffffffffffffULL)
fprintf(ofp, " INVALID");
else
fprintf(ofp, " %llx", tmp64[i]);
}
}
fprintf(ofp, "\nxch_nr_pages: %d\n", nr_pages);
return TRUE;
default:
return FALSE;
}
}
/*
* Given a normal kernel pfn, determine the page index in the dumpfile.
*
* - First determine which of the pages making up the
* phys_to_machine_mapping[] array would contain the pfn.
* - From the phys_to_machine_mapping page, determine the mfn.
* - Find the mfn in the dumpfile page index.
*/
#define PFNS_PER_PAGE (xd->page_size/sizeof(unsigned long))
static ulong
xc_core_pfn_to_page_index(ulong pfn)
{
ulong idx, p2m_idx, mfn_idx;
ulong *up, mfn;
off_t offset;
/*
* This function does not apply when there's no p2m
* mapping and/or if this is an ELF format dumpfile.
*/
switch (xd->flags & (XC_CORE_NO_P2M|XC_CORE_ELF))
{
case (XC_CORE_NO_P2M|XC_CORE_ELF):
return xc_core_elf_pfn_valid(pfn);
case XC_CORE_NO_P2M:
return(xc_core_pfn_valid(pfn) ? pfn : PFN_NOT_FOUND);
case XC_CORE_ELF:
return xc_core_elf_pfn_to_page_index(pfn);
}
idx = pfn/PFNS_PER_PAGE;
if (idx >= xd->xc_core.p2m_frames) {
error(INFO, "pfn: %lx is too large for dumpfile\n",
pfn);
return PFN_NOT_FOUND;
}
p2m_idx = xd->xc_core.p2m_frame_index_list[idx];
if (lseek(xd->xfd, xd->xc_core.header.xch_pages_offset,
SEEK_SET) == -1) {
error(INFO, "cannot lseek to xch_pages_offset\n");
return PFN_NOT_FOUND;
}
offset = (off_t)(p2m_idx) * (off_t)xd->page_size;
if (lseek(xd->xfd, offset, SEEK_CUR) == -1) {
error(INFO, "cannot lseek to pfn-specified page\n");
return PFN_NOT_FOUND;
}
if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size) {
error(INFO, "cannot read pfn-specified page\n");
return PFN_NOT_FOUND;
}
up = (ulong *)xd->page;
up += (pfn%PFNS_PER_PAGE);
mfn = *up;
if ((mfn_idx = xc_core_mfn_to_page_index(mfn)) == MFN_NOT_FOUND) {
if (!STREQ(pc->curcmd, "search"))
error(INFO, "cannot find mfn in page index\n");
return PFN_NOT_FOUND;
}
return mfn_idx;
}
/*
* Search the .xen_p2m array for the target pfn, starting at a
* higher batch if appropriate. This presumes that the pfns
* are laid out in ascending order.
*/
static ulong
xc_core_elf_pfn_to_page_index(ulong pfn)
{
int i, b, start_index;
off_t offset;
size_t size;
uint nr_pages;
ulong tmp;
struct xen_dumpcore_p2m p2m_batch[MAX_BATCH_SIZE];
offset = xd->xc_core.header.xch_index_offset;
nr_pages = xd->xc_core.header.xch_nr_pages;
/*
* Initialize the start_index.
*/
xd->xc_core.last_batch.accesses++;
start_index = 0;
if ((pfn >= xd->xc_core.last_batch.start) &&
(pfn <= xd->xc_core.last_batch.end)) {
xd->xc_core.last_batch.duplicates++;
start_index = xd->xc_core.last_batch.index;
} else {
for (i = 0; i <= INDEX_PFN_COUNT; i++) {
if ((i == INDEX_PFN_COUNT) ||
(pfn < xd->xc_core.elf_index_pfn[i].pfn)) {
if (--i < 0)
i = 0;
start_index = xd->xc_core.elf_index_pfn[i].index;
break;
}
}
}
offset += (start_index * sizeof(struct xen_dumpcore_p2m));
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL, "cannot lseek to page index\n");
for (b = start_index; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(struct xen_dumpcore_p2m) *
MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, &p2m_batch[0], size) != size) {
error(INFO, "cannot read index page %d\n", b);
return PFN_NOT_FOUND;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
tmp = (ulong)p2m_batch[i].pfn;
if (tmp == pfn) {
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"index: batch: %d found pfn %ld (0x%lx) at index %d\n",
b/MAX_BATCH_SIZE, pfn, pfn, i+b);
if ((b+MAX_BATCH_SIZE) < nr_pages) {
xd->xc_core.last_batch.index = b;
xd->xc_core.last_batch.start = p2m_batch[0].pfn;
xd->xc_core.last_batch.end = p2m_batch[MAX_BATCH_SIZE-1].pfn;
}
return (i+b);
}
}
}
return PFN_NOT_FOUND;
}
/*
* In xendumps containing INVALID_MFN markers in the page index,
* return the validity of the pfn.
*/
static int
xc_core_pfn_valid(ulong pfn)
{
ulong mfn;
off_t offset;
if (pfn >= (ulong)xd->xc_core.header.xch_nr_pages)
return FALSE;
offset = xd->xc_core.header.xch_index_offset;
if (xd->flags & XC_CORE_64BIT_HOST)
offset += (off_t)(pfn * sizeof(ulonglong));
else
offset += (off_t)(pfn * sizeof(ulong));
/*
* The lseek and read should never fail, so report
* any errors unconditionally.
*/
if (lseek(xd->xfd, offset, SEEK_SET) == -1) {
error(INFO,
"xendump: cannot lseek to page index for pfn %lx\n",
pfn);
return FALSE;
}
if (read(xd->xfd, &mfn, sizeof(ulong)) != sizeof(ulong)) {
error(INFO,
"xendump: cannot read index page for pfn %lx\n",
pfn);
return FALSE;
}
/*
* If it's an invalid mfn, let the caller decide whether
* to display an error message (unless debugging).
*/
if (mfn == INVALID_MFN) {
if (CRASHDEBUG(1) && !STREQ(pc->curcmd, "search"))
error(INFO,
"xendump: pfn %lx contains INVALID_MFN\n",
pfn);
return FALSE;
}
return TRUE;
}
/*
* Return the index into the .xen_pfn array containing the pfn.
* If not found, return PFN_NOT_FOUND.
*/
static ulong
xc_core_elf_pfn_valid(ulong pfn)
{
int i, b, start_index;
off_t offset;
size_t size;
uint nr_pages;
ulong tmp;
uint64_t pfn_batch[MAX_BATCH_SIZE];
offset = xd->xc_core.header.xch_index_offset;
nr_pages = xd->xc_core.header.xch_nr_pages;
/*
* Initialize the start_index.
*/
xd->xc_core.last_batch.accesses++;
start_index = 0;
if ((pfn >= xd->xc_core.last_batch.start) &&
(pfn <= xd->xc_core.last_batch.end)) {
xd->xc_core.last_batch.duplicates++;
start_index = xd->xc_core.last_batch.index;
} else {
for (i = 0; i <= INDEX_PFN_COUNT; i++) {
if ((i == INDEX_PFN_COUNT) ||
(pfn < xd->xc_core.elf_index_pfn[i].pfn)) {
if (--i < 0)
i = 0;
start_index = xd->xc_core.elf_index_pfn[i].index;
break;
}
}
}
offset += (start_index * sizeof(uint64_t));
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL, "cannot lseek to page index\n");
for (b = start_index; b < nr_pages; b += MAX_BATCH_SIZE) {
size = sizeof(uint64_t) * MIN(MAX_BATCH_SIZE, nr_pages - b);
if (read(xd->xfd, &pfn_batch[0], size) != size) {
error(INFO, "cannot read index page %d\n", b);
return PFN_NOT_FOUND;
}
for (i = 0; i < MAX_BATCH_SIZE; i++) {
if ((b+i) >= nr_pages)
break;
tmp = (ulong)pfn_batch[i];
if (tmp == pfn) {
if (CRASHDEBUG(4))
fprintf(xd->ofp,
"index: batch: %d found pfn %ld (0x%lx) at index %d\n",
b/MAX_BATCH_SIZE, pfn, pfn, i+b);
if ((b+MAX_BATCH_SIZE) < nr_pages) {
xd->xc_core.last_batch.index = b;
xd->xc_core.last_batch.start = (ulong)pfn_batch[0];
xd->xc_core.last_batch.end = (ulong)pfn_batch[MAX_BATCH_SIZE-1];
}
return (i+b);
}
}
}
return PFN_NOT_FOUND;
}
/*
* Store the panic task's stack hooks from where it was found
* in get_active_set_panic_task().
*/
void
xendump_panic_hook(char *stack)
{
int i, err, argc;
char *arglist[MAXARGS];
char buf[BUFSIZE];
ulong value, *sp;
if (machine_type("IA64")) /* needs switch_stack address */
return;
strcpy(buf, stack);
argc = parse_line(buf, arglist);
if ((value = htol(strip_ending_char(arglist[0], ':'),
RETURN_ON_ERROR, &err)) == BADADDR)
return;
for (sp = (ulong *)value, i = 1; i < argc; i++, sp++) {
if (strstr(arglist[i], "xen_panic_event")) {
if (!readmem((ulong)sp, KVADDR, &value,
sizeof(ulong), "xen_panic_event address",
RETURN_ON_ERROR))
return;
xd->panic_sp = (ulong)sp;
xd->panic_pc = value;
} else if (strstr(arglist[i], "panic") && !xd->panic_sp) {
if (!readmem((ulong)sp, KVADDR, &value,
sizeof(ulong), "xen_panic_event address",
RETURN_ON_ERROR))
return;
xd->panic_sp = (ulong)sp;
xd->panic_pc = value;
}
}
}
static void
xendump_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 (xd->ofp)
fprintf(xd->ofp, "%s", buf);
else if (!XENDUMP_VALID() && CRASHDEBUG(7))
fprintf(stderr, "%s", buf);
}
/*
* Support for xc_core ELF dumpfile format.
*/
static int
xc_core_elf_verify(char *file, char *buf)
{
int i;
Elf32_Ehdr *elf32;
Elf64_Ehdr *elf64;
Elf32_Off offset32;
Elf64_Off offset64;
char *eheader;
int swap;
eheader = buf;
if (!STRNEQ(eheader, ELFMAG) || eheader[EI_VERSION] != EV_CURRENT)
goto bailout;
swap = (((eheader[EI_DATA] == ELFDATA2LSB) &&
(__BYTE_ORDER == __BIG_ENDIAN)) ||
((eheader[EI_DATA] == ELFDATA2MSB) &&
(__BYTE_ORDER == __LITTLE_ENDIAN)));
elf32 = (Elf32_Ehdr *)buf;
elf64 = (Elf64_Ehdr *)buf;
if ((elf32->e_ident[EI_CLASS] == ELFCLASS32) &&
(swap16(elf32->e_type, swap) == ET_CORE) &&
(swap32(elf32->e_version, swap) == EV_CURRENT) &&
(swap16(elf32->e_shnum, swap) > 0)) {
switch (swap16(elf32->e_machine, swap))
{
case EM_386:
if (machine_type_mismatch(file, "X86", NULL, 0))
goto bailout;
break;
default:
if (machine_type_mismatch(file, "(unknown)", NULL, 0))
goto bailout;
break;
}
if (endian_mismatch(file, elf32->e_ident[EI_DATA], 0))
goto bailout;
xd->xc_core.elf_class = ELFCLASS32;
if ((xd->xc_core.elf32 = (Elf32_Ehdr *)malloc(sizeof(Elf32_Ehdr))) == NULL) {
fprintf(stderr, "cannot malloc ELF header buffer\n");
clean_exit(1);
}
BCOPY(buf, xd->xc_core.elf32, sizeof(Elf32_Ehdr));
} else if ((elf64->e_ident[EI_CLASS] == ELFCLASS64) &&
(swap16(elf64->e_type, swap) == ET_CORE) &&
(swap32(elf64->e_version, swap) == EV_CURRENT) &&
(swap16(elf64->e_shnum, swap) > 0)) {
switch (swap16(elf64->e_machine, swap))
{
case EM_IA_64:
if (machine_type_mismatch(file, "IA64", NULL, 0))
goto bailout;
break;
case EM_X86_64:
if (machine_type_mismatch(file, "X86_64", "X86", 0))
goto bailout;
break;
case EM_386:
if (machine_type_mismatch(file, "X86", NULL, 0))
goto bailout;
break;
default:
if (machine_type_mismatch(file, "(unknown)", NULL, 0))
goto bailout;
}
if (endian_mismatch(file, elf64->e_ident[EI_DATA], 0))
goto bailout;
xd->xc_core.elf_class = ELFCLASS64;
if ((xd->xc_core.elf64 = (Elf64_Ehdr *)malloc(sizeof(Elf64_Ehdr))) == NULL) {
fprintf(stderr, "cannot malloc ELF header buffer\n");
clean_exit(1);
}
BCOPY(buf, xd->xc_core.elf64, sizeof(Elf64_Ehdr));
} else {
if (CRASHDEBUG(1))
error(INFO, "%s: not a xen ELF core file\n", file);
goto bailout;
}
xc_core_elf_dump();
switch (xd->xc_core.elf_class)
{
case ELFCLASS32:
offset32 = xd->xc_core.elf32->e_shoff;
for (i = 0; i < xd->xc_core.elf32->e_shnum; i++) {
xc_core_dump_Elf32_Shdr(offset32, ELFSTORE);
offset32 += xd->xc_core.elf32->e_shentsize;
}
xendump_print("\n");
break;
case ELFCLASS64:
offset64 = xd->xc_core.elf64->e_shoff;
for (i = 0; i < xd->xc_core.elf64->e_shnum; i++) {
xc_core_dump_Elf64_Shdr(offset64, ELFSTORE);
offset64 += xd->xc_core.elf64->e_shentsize;
}
xendump_print("\n");
break;
}
xd->flags |= (XENDUMP_LOCAL | XC_CORE_ELF);
if (!xd->page_size)
error(FATAL,
"unknown page size: use -p <pagesize> command line option\n");
if (!(xd->page = (char *)malloc(xd->page_size)))
error(FATAL, "cannot malloc page space.");
if (!(xd->poc = (struct pfn_offset_cache *)calloc
(PFN_TO_OFFSET_CACHE_ENTRIES,
sizeof(struct pfn_offset_cache))))
error(FATAL, "cannot malloc pfn_offset_cache\n");
xd->last_pfn = ~(0UL);
for (i = 0; i < INDEX_PFN_COUNT; i++)
xd->xc_core.elf_index_pfn[i].pfn = ~0UL;
if (CRASHDEBUG(1))
xendump_memory_dump(fp);
return TRUE;
bailout:
return FALSE;
}
/*
* Dump the relevant ELF header.
*/
static void
xc_core_elf_dump(void)
{
switch (xd->xc_core.elf_class)
{
case ELFCLASS32:
xc_core_dump_Elf32_Ehdr(xd->xc_core.elf32);
break;
case ELFCLASS64:
xc_core_dump_Elf64_Ehdr(xd->xc_core.elf64);
break;
}
}
/*
* Dump the 32-bit ELF header, and grab a pointer to the strtab section.
*/
static void
xc_core_dump_Elf32_Ehdr(Elf32_Ehdr *elf)
{
char buf[BUFSIZE];
Elf32_Off offset32;
Elf32_Shdr shdr;
BZERO(buf, BUFSIZE);
BCOPY(elf->e_ident, buf, SELFMAG);
xendump_print("\nElf32_Ehdr:\n");
xendump_print(" e_ident: \\%o%s\n", buf[0],
&buf[1]);
xendump_print(" e_ident[EI_CLASS]: %d ", elf->e_ident[EI_CLASS]);
switch (elf->e_ident[EI_CLASS])
{
case ELFCLASSNONE:
xendump_print("(ELFCLASSNONE)");
break;
case ELFCLASS32:
xendump_print("(ELFCLASS32)\n");
break;
case ELFCLASS64:
xendump_print("(ELFCLASS64)\n");
break;
case ELFCLASSNUM:
xendump_print("(ELFCLASSNUM)\n");
break;
default:
xendump_print("(?)\n");
break;
}
xendump_print(" e_ident[EI_DATA]: %d ", elf->e_ident[EI_DATA]);
switch (elf->e_ident[EI_DATA])
{
case ELFDATANONE:
xendump_print("(ELFDATANONE)\n");
break;
case ELFDATA2LSB:
xendump_print("(ELFDATA2LSB)\n");
break;
case ELFDATA2MSB:
xendump_print("(ELFDATA2MSB)\n");
break;
case ELFDATANUM:
xendump_print("(ELFDATANUM)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_ident[EI_VERSION]: %d ",
elf->e_ident[EI_VERSION]);
if (elf->e_ident[EI_VERSION] == EV_CURRENT)
xendump_print("(EV_CURRENT)\n");
else
xendump_print("(?)\n");
xendump_print(" e_ident[EI_OSABI]: %d ", elf->e_ident[EI_OSABI]);
switch (elf->e_ident[EI_OSABI])
{
case ELFOSABI_SYSV:
xendump_print("(ELFOSABI_SYSV)\n");
break;
case ELFOSABI_HPUX:
xendump_print("(ELFOSABI_HPUX)\n");
break;
case ELFOSABI_ARM:
xendump_print("(ELFOSABI_ARM)\n");
break;
case ELFOSABI_STANDALONE:
xendump_print("(ELFOSABI_STANDALONE)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_ident[EI_ABIVERSION]: %d\n",
elf->e_ident[EI_ABIVERSION]);
xendump_print(" e_type: %d ", elf->e_type);
switch (elf->e_type)
{
case ET_NONE:
xendump_print("(ET_NONE)\n");
break;
case ET_REL:
xendump_print("(ET_REL)\n");
break;
case ET_EXEC:
xendump_print("(ET_EXEC)\n");
break;
case ET_DYN:
xendump_print("(ET_DYN)\n");
break;
case ET_CORE:
xendump_print("(ET_CORE)\n");
break;
case ET_NUM:
xendump_print("(ET_NUM)\n");
break;
case ET_LOOS:
xendump_print("(ET_LOOS)\n");
break;
case ET_HIOS:
xendump_print("(ET_HIOS)\n");
break;
case ET_LOPROC:
xendump_print("(ET_LOPROC)\n");
break;
case ET_HIPROC:
xendump_print("(ET_HIPROC)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_machine: %d ", elf->e_machine);
switch (elf->e_machine)
{
case EM_386:
xendump_print("(EM_386)\n");
break;
default:
xendump_print("(unsupported)\n");
break;
}
xendump_print(" e_version: %ld ", (ulong)elf->e_version);
xendump_print("%s\n", elf->e_version == EV_CURRENT ?
"(EV_CURRENT)" : "");
xendump_print(" e_entry: %lx\n", (ulong)elf->e_entry);
xendump_print(" e_phoff: %lx\n", (ulong)elf->e_phoff);
xendump_print(" e_shoff: %lx\n", (ulong)elf->e_shoff);
xendump_print(" e_flags: %lx\n", (ulong)elf->e_flags);
xendump_print(" e_ehsize: %x\n", elf->e_ehsize);
xendump_print(" e_phentsize: %x\n", elf->e_phentsize);
xendump_print(" e_phnum: %x\n", elf->e_phnum);
xendump_print(" e_shentsize: %x\n", elf->e_shentsize);
xendump_print(" e_shnum: %x\n", elf->e_shnum);
xendump_print(" e_shstrndx: %x\n", elf->e_shstrndx);
/* Determine the strtab location. */
offset32 = elf->e_shoff +
(elf->e_shstrndx * elf->e_shentsize);
if (lseek(xd->xfd, offset32, SEEK_SET) != offset32)
error(FATAL,
"xc_core_dump_Elf32_Ehdr: cannot seek to strtab Elf32_Shdr\n");
if (read(xd->xfd, &shdr, sizeof(Elf32_Shdr)) != sizeof(Elf32_Shdr))
error(FATAL,
"xc_core_dump_Elf32_Ehdr: cannot read strtab Elf32_Shdr\n");
xd->xc_core.elf_strtab_offset = (ulonglong)shdr.sh_offset;
}
/*
* Dump the 64-bit ELF header, and grab a pointer to the strtab section.
*/
static void
xc_core_dump_Elf64_Ehdr(Elf64_Ehdr *elf)
{
char buf[BUFSIZE];
Elf64_Off offset64;
Elf64_Shdr shdr;
BZERO(buf, BUFSIZE);
BCOPY(elf->e_ident, buf, SELFMAG);
xendump_print("\nElf64_Ehdr:\n");
xendump_print(" e_ident: \\%o%s\n", buf[0],
&buf[1]);
xendump_print(" e_ident[EI_CLASS]: %d ", elf->e_ident[EI_CLASS]);
switch (elf->e_ident[EI_CLASS])
{
case ELFCLASSNONE:
xendump_print("(ELFCLASSNONE)");
break;
case ELFCLASS32:
xendump_print("(ELFCLASS32)\n");
break;
case ELFCLASS64:
xendump_print("(ELFCLASS64)\n");
break;
case ELFCLASSNUM:
xendump_print("(ELFCLASSNUM)\n");
break;
default:
xendump_print("(?)\n");
break;
}
xendump_print(" e_ident[EI_DATA]: %d ", elf->e_ident[EI_DATA]);
switch (elf->e_ident[EI_DATA])
{
case ELFDATANONE:
xendump_print("(ELFDATANONE)\n");
break;
case ELFDATA2LSB:
xendump_print("(ELFDATA2LSB)\n");
break;
case ELFDATA2MSB:
xendump_print("(ELFDATA2MSB)\n");
break;
case ELFDATANUM:
xendump_print("(ELFDATANUM)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_ident[EI_VERSION]: %d ",
elf->e_ident[EI_VERSION]);
if (elf->e_ident[EI_VERSION] == EV_CURRENT)
xendump_print("(EV_CURRENT)\n");
else
xendump_print("(?)\n");
xendump_print(" e_ident[EI_OSABI]: %d ", elf->e_ident[EI_OSABI]);
switch (elf->e_ident[EI_OSABI])
{
case ELFOSABI_SYSV:
xendump_print("(ELFOSABI_SYSV)\n");
break;
case ELFOSABI_HPUX:
xendump_print("(ELFOSABI_HPUX)\n");
break;
case ELFOSABI_ARM:
xendump_print("(ELFOSABI_ARM)\n");
break;
case ELFOSABI_STANDALONE:
xendump_print("(ELFOSABI_STANDALONE)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_ident[EI_ABIVERSION]: %d\n",
elf->e_ident[EI_ABIVERSION]);
xendump_print(" e_type: %d ", elf->e_type);
switch (elf->e_type)
{
case ET_NONE:
xendump_print("(ET_NONE)\n");
break;
case ET_REL:
xendump_print("(ET_REL)\n");
break;
case ET_EXEC:
xendump_print("(ET_EXEC)\n");
break;
case ET_DYN:
xendump_print("(ET_DYN)\n");
break;
case ET_CORE:
xendump_print("(ET_CORE)\n");
break;
case ET_NUM:
xendump_print("(ET_NUM)\n");
break;
case ET_LOOS:
xendump_print("(ET_LOOS)\n");
break;
case ET_HIOS:
xendump_print("(ET_HIOS)\n");
break;
case ET_LOPROC:
xendump_print("(ET_LOPROC)\n");
break;
case ET_HIPROC:
xendump_print("(ET_HIPROC)\n");
break;
default:
xendump_print("(?)\n");
}
xendump_print(" e_machine: %d ", elf->e_machine);
switch (elf->e_machine)
{
case EM_386:
xendump_print("(EM_386)\n");
break;
case EM_IA_64:
xendump_print("(EM_IA_64)\n");
break;
case EM_PPC64:
xendump_print("(EM_PPC64)\n");
break;
case EM_X86_64:
xendump_print("(EM_X86_64)\n");
break;
default:
xendump_print("(unsupported)\n");
break;
}
xendump_print(" e_version: %ld ", (ulong)elf->e_version);
xendump_print("%s\n", elf->e_version == EV_CURRENT ?
"(EV_CURRENT)" : "");
xendump_print(" e_entry: %lx\n", (ulong)elf->e_entry);
xendump_print(" e_phoff: %lx\n", (ulong)elf->e_phoff);
xendump_print(" e_shoff: %lx\n", (ulong)elf->e_shoff);
xendump_print(" e_flags: %lx\n", (ulong)elf->e_flags);
xendump_print(" e_ehsize: %x\n", elf->e_ehsize);
xendump_print(" e_phentsize: %x\n", elf->e_phentsize);
xendump_print(" e_phnum: %x\n", elf->e_phnum);
xendump_print(" e_shentsize: %x\n", elf->e_shentsize);
xendump_print(" e_shnum: %x\n", elf->e_shnum);
xendump_print(" e_shstrndx: %x\n", elf->e_shstrndx);
/* Determine the strtab location. */
offset64 = elf->e_shoff +
(elf->e_shstrndx * elf->e_shentsize);
if (lseek(xd->xfd, offset64, SEEK_SET) != offset64)
error(FATAL,
"xc_core_dump_Elf64_Ehdr: cannot seek to strtab Elf32_Shdr\n");
if (read(xd->xfd, &shdr, sizeof(Elf32_Shdr)) != sizeof(Elf32_Shdr))
error(FATAL,
"xc_core_dump_Elf64_Ehdr: cannot read strtab Elf32_Shdr\n");
xd->xc_core.elf_strtab_offset = (ulonglong)shdr.sh_offset;
}
/*
* Dump each 32-bit section header and the data that they reference.
*/
static void
xc_core_dump_Elf32_Shdr(Elf32_Off offset, int store)
{
Elf32_Shdr shdr;
char name[BUFSIZE];
int i;
char c;
if (lseek(xd->xfd, offset, SEEK_SET) != offset)
error(FATAL,
"xc_core_dump_Elf32_Shdr: cannot seek to Elf32_Shdr\n");
if (read(xd->xfd, &shdr, sizeof(Elf32_Shdr)) != sizeof(Elf32_Shdr))
error(FATAL,
"xc_core_dump_Elf32_Shdr: cannot read Elf32_Shdr\n");
xendump_print("\nElf32_Shdr:\n");
xendump_print(" sh_name: %lx ", shdr.sh_name);
xendump_print("\"%s\"\n", xc_core_strtab(shdr.sh_name, name));
xendump_print(" sh_type: %lx ", shdr.sh_type);
switch (shdr.sh_type)
{
case SHT_NULL:
xendump_print("(SHT_NULL)\n");
break;
case SHT_PROGBITS:
xendump_print("(SHT_PROGBITS)\n");
break;
case SHT_STRTAB:
xendump_print("(SHT_STRTAB)\n");
break;
case SHT_NOTE:
xendump_print("(SHT_NOTE)\n");
break;
default:
xendump_print("\n");
break;
}
xendump_print(" sh_flags: %lx\n", shdr.sh_flags);
xendump_print(" sh_addr: %lx\n", shdr.sh_addr);
xendump_print(" sh_offset: %lx\n", shdr.sh_offset);
xendump_print(" sh_size: %lx\n", shdr.sh_size);
xendump_print(" sh_link: %lx\n", shdr.sh_link);
xendump_print(" sh_info: %lx\n", shdr.sh_info);
xendump_print(" sh_addralign: %lx\n", shdr.sh_addralign);
xendump_print(" sh_entsize: %lx\n", shdr.sh_entsize);
if (STREQ(name, ".shstrtab")) {
if (lseek(xd->xfd, xd->xc_core.elf_strtab_offset, SEEK_SET) !=
xd->xc_core.elf_strtab_offset)
error(FATAL,
"xc_core_dump_Elf32_Shdr: cannot seek to strtab data\n");
xendump_print(" ");
for (i = 0; i < shdr.sh_size; i++) {
if (read(xd->xfd, &c, sizeof(char)) != sizeof(char))
error(FATAL,
"xc_core_dump_Elf32_Shdr: cannot read strtab data\n");
if (i && !c)
xendump_print("\n ");
else
xendump_print("%c", c);
}
}
if (STREQ(name, ".note.Xen"))
xc_core_dump_elfnote((off_t)shdr.sh_offset,
(size_t)shdr.sh_size, store);
if (!store)
return;
if (STREQ(name, ".xen_prstatus"))
xd->xc_core.header.xch_ctxt_offset =
(off_t)shdr.sh_offset;
if (STREQ(name, ".xen_shared_info"))
xd->xc_core.shared_info_offset = (off_t)shdr.sh_offset;
if (STREQ(name, ".xen_pfn")) {
xd->xc_core.header.xch_index_offset =
(off_t)shdr.sh_offset;
xd->flags |= (XC_CORE_NO_P2M|XC_CORE_PFN_CREATE);
}
if (STREQ(name, ".xen_p2m")) {
xd->xc_core.header.xch_index_offset =
(off_t)shdr.sh_offset;
xd->flags |= XC_CORE_P2M_CREATE;
}
if (STREQ(name, ".xen_pages"))
xd->xc_core.header.xch_pages_offset =
(off_t)shdr.sh_offset;
if (STREQ(name, ".xen_ia64_mapped_regs"))
xd->xc_core.ia64_mapped_regs_offset =
(off_t)shdr.sh_offset;
}
/*
* Dump each 64-bit section header and the data that they reference.
*/
static void
xc_core_dump_Elf64_Shdr(Elf64_Off offset, int store)
{
Elf64_Shdr shdr;
char name[BUFSIZE];
int i;
char c;
if (lseek(xd->xfd, offset, SEEK_SET) != offset)
error(FATAL,
"xc_core_dump_Elf64_Shdr: cannot seek to Elf64_Shdr\n");
if (read(xd->xfd, &shdr, sizeof(Elf64_Shdr)) != sizeof(Elf64_Shdr))
error(FATAL,
"xc_core_dump_Elf64_Shdr: cannot read Elf64_Shdr\n");
xendump_print("\nElf64_Shdr:\n");
xendump_print(" sh_name: %x ", shdr.sh_name);
xendump_print("\"%s\"\n", xc_core_strtab(shdr.sh_name, name));
xendump_print(" sh_type: %x ", shdr.sh_type);
switch (shdr.sh_type)
{
case SHT_NULL:
xendump_print("(SHT_NULL)\n");
break;
case SHT_PROGBITS:
xendump_print("(SHT_PROGBITS)\n");
break;
case SHT_STRTAB:
xendump_print("(SHT_STRTAB)\n");
break;
case SHT_NOTE:
xendump_print("(SHT_NOTE)\n");
break;
default:
xendump_print("\n");
break;
}
xendump_print(" sh_flags: %lx\n", shdr.sh_flags);
xendump_print(" sh_addr: %lx\n", shdr.sh_addr);
xendump_print(" sh_offset: %lx\n", shdr.sh_offset);
xendump_print(" sh_size: %lx\n", shdr.sh_size);
xendump_print(" sh_link: %x\n", shdr.sh_link);
xendump_print(" sh_info: %x\n", shdr.sh_info);
xendump_print(" sh_addralign: %lx\n", shdr.sh_addralign);
xendump_print(" sh_entsize: %lx\n", shdr.sh_entsize);
if (STREQ(name, ".shstrtab")) {
if (lseek(xd->xfd, xd->xc_core.elf_strtab_offset, SEEK_SET) !=
xd->xc_core.elf_strtab_offset)
error(FATAL,
"xc_core_dump_Elf64_Shdr: cannot seek to strtab data\n");
xendump_print(" ");
for (i = 0; i < shdr.sh_size; i++) {
if (read(xd->xfd, &c, sizeof(char)) != sizeof(char))
error(FATAL,
"xc_core_dump_Elf64_Shdr: cannot read strtab data\n");
if (i && !c)
xendump_print("\n ");
else
xendump_print("%c", c);
}
}
if (STREQ(name, ".note.Xen"))
xc_core_dump_elfnote((off_t)shdr.sh_offset,
(size_t)shdr.sh_size, store);
if (!store)
return;
if (STREQ(name, ".xen_prstatus"))
xd->xc_core.header.xch_ctxt_offset =
(off_t)shdr.sh_offset;
if (STREQ(name, ".xen_shared_info"))
xd->xc_core.shared_info_offset = (off_t)shdr.sh_offset;
if (STREQ(name, ".xen_pfn")) {
xd->xc_core.header.xch_index_offset =
(off_t)shdr.sh_offset;
xd->flags |= (XC_CORE_NO_P2M|XC_CORE_PFN_CREATE);
}
if (STREQ(name, ".xen_p2m")) {
xd->xc_core.header.xch_index_offset =
(off_t)shdr.sh_offset;
xd->flags |= XC_CORE_P2M_CREATE;
}
if (STREQ(name, ".xen_pages"))
xd->xc_core.header.xch_pages_offset =
(off_t)shdr.sh_offset;
if (STREQ(name, ".xen_ia64_mapped_regs"))
xd->xc_core.ia64_mapped_regs_offset =
(off_t)shdr.sh_offset;
}
/*
* Return the string found at the specified index into
* the dumpfile's strtab.
*/
static char *
xc_core_strtab(uint32_t index, char *buf)
{
off_t offset;
int i;
offset = xd->xc_core.elf_strtab_offset + index;
if (lseek(xd->xfd, offset, SEEK_SET) != offset)
error(FATAL,
"xc_core_strtab: cannot seek to Elf64_Shdr\n");
BZERO(buf, BUFSIZE);
i = 0;
while (read(xd->xfd, &buf[i], sizeof(char)) == sizeof(char)) {
if (buf[i] == NULLCHAR)
break;
i++;
}
return buf;
}
/*
* Dump the array of elfnote structures, storing relevant info
* when requested during initialization. This function is
* common to both 32-bit and 64-bit ELF files.
*/
static void
xc_core_dump_elfnote(off_t sh_offset, size_t sh_size, int store)
{
int i, lf, index;
char *notes_buffer;
struct elfnote *elfnote;
ulonglong *data;
struct xen_dumpcore_elfnote_header_desc *elfnote_header;
struct xen_dumpcore_elfnote_format_version_desc *format_version;
elfnote_header = NULL;
format_version = NULL;
if (!(notes_buffer = (char *)malloc(sh_size)))
error(FATAL, "cannot malloc notes space.");
if (lseek(xd->xfd, sh_offset, SEEK_SET) != sh_offset)
error(FATAL,
"xc_core_dump_elfnote: cannot seek to sh_offset\n");
if (read(xd->xfd, notes_buffer, sh_size) != sh_size)
error(FATAL,
"xc_core_dump_elfnote: cannot read elfnote data\n");
for (index = 0; index < sh_size; ) {
elfnote = (struct elfnote *)&notes_buffer[index];
xendump_print(" namesz: %d\n", elfnote->namesz);
xendump_print(" descz: %d\n", elfnote->descsz);
xendump_print(" type: %x ", elfnote->type);
switch (elfnote->type)
{
case XEN_ELFNOTE_DUMPCORE_NONE:
xendump_print("(XEN_ELFNOTE_DUMPCORE_NONE)\n");
break;
case XEN_ELFNOTE_DUMPCORE_HEADER:
xendump_print("(XEN_ELFNOTE_DUMPCORE_HEADER)\n");
elfnote_header = (struct xen_dumpcore_elfnote_header_desc *)
(elfnote+1);
break;
case XEN_ELFNOTE_DUMPCORE_XEN_VERSION:
xendump_print("(XEN_ELFNOTE_DUMPCORE_XEN_VERSION)\n");
break;
case XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION:
xendump_print("(XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION)\n");
format_version = (struct xen_dumpcore_elfnote_format_version_desc *)
(elfnote+1);
break;
default:
xendump_print("(unknown)\n");
break;
}
xendump_print(" name: %s\n", elfnote->name);
data = (ulonglong *)(elfnote+1);
for (i = lf = 0; i < elfnote->descsz/sizeof(ulonglong); i++) {
if (((i%2)==0)) {
xendump_print("%s ",
i ? "\n" : "");
lf++;
} else
lf = 0;
xendump_print("%016llx ", *data++);
}
if (!elfnote->descsz)
xendump_print(" (empty)");
xendump_print("\n");
index += sizeof(struct elfnote) + elfnote->descsz;
}
if (!store)
return;
if (elfnote_header) {
xd->xc_core.header.xch_magic = elfnote_header->xch_magic;
xd->xc_core.header.xch_nr_vcpus = elfnote_header->xch_nr_vcpus;
xd->xc_core.header.xch_nr_pages = elfnote_header->xch_nr_pages;
xd->page_size = elfnote_header->xch_page_size;
}
if (format_version) {
switch (format_version->version)
{
case FORMAT_VERSION_0000000000000001:
break;
default:
error(WARNING,
"unsupported xen dump-core format version: %016llx\n",
format_version->version);
}
xd->xc_core.format_version = format_version->version;
}
}
/*
* Initialize the batching list for the .xen_p2m or .xen_pfn
* arrays.
*/
static void
xc_core_elf_pfn_init(void)
{
int i, c, chunk;
off_t offset;
struct xen_dumpcore_p2m p2m;
uint64_t pfn;
switch (xd->flags & (XC_CORE_ELF|XC_CORE_NO_P2M))
{
case (XC_CORE_ELF|XC_CORE_NO_P2M):
chunk = xd->xc_core.header.xch_nr_pages/INDEX_PFN_COUNT;
for (i = c = 0; i < INDEX_PFN_COUNT; i++, c += chunk) {
offset = xd->xc_core.header.xch_index_offset +
(off_t)(c * sizeof(uint64_t));
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL,
"cannot lseek to page index %d\n", c);
if (read(xd->xfd, &pfn, sizeof(uint64_t)) !=
sizeof(uint64_t))
error(FATAL,
"cannot read page index %d\n", c);
xd->xc_core.elf_index_pfn[i].index = c;
xd->xc_core.elf_index_pfn[i].pfn = (ulong)pfn;
}
break;
case XC_CORE_ELF:
chunk = xd->xc_core.header.xch_nr_pages/INDEX_PFN_COUNT;
for (i = c = 0; i < INDEX_PFN_COUNT; i++, c += chunk) {
offset = xd->xc_core.header.xch_index_offset +
(off_t)(c * sizeof(struct xen_dumpcore_p2m));
if (lseek(xd->xfd, offset, SEEK_SET) == -1)
error(FATAL,
"cannot lseek to page index %d\n", c);
if (read(xd->xfd, &p2m, sizeof(struct xen_dumpcore_p2m)) !=
sizeof(struct xen_dumpcore_p2m))
error(FATAL,
"cannot read page index %d\n", c);
xd->xc_core.elf_index_pfn[i].index = c;
xd->xc_core.elf_index_pfn[i].pfn = (ulong)p2m.pfn;
}
break;
}
}
struct xendump_data *
get_xendump_data(void)
{
return (XENDUMP_VALID() ? xd : NULL);
}
Reference in New Issue View Git Blame Copy Permalink