mirror of
https://github.com/crash-utility/crash
synced 2025-02-23 17:06:49 +00:00
1ed90b28af
There may be holes in the memory address saved for PCI, etc. In such cases, the memory dump is divided into regions. With this patch, up to 3 memory regions are supported. (hfu@vmware.com)
353 lines
9.0 KiB
C
353 lines
9.0 KiB
C
/*
|
|
* vmware_vmss.c
|
|
*
|
|
* Copyright (c) 2015 VMware, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* Author: Dyno Hongjun Fu <hfu@vmware.com>
|
|
*/
|
|
|
|
#include "defs.h"
|
|
#include "vmware_vmss.h"
|
|
|
|
#define LOGPRX "vmw: "
|
|
|
|
/* VMware only supports X86/X86_64 virtual machines. */
|
|
#define VMW_PAGE_SIZE (4096)
|
|
#define VMW_PAGE_SHIFT (12)
|
|
|
|
static vmssdata vmss = { 0 };
|
|
|
|
int
|
|
is_vmware_vmss(char *filename)
|
|
{
|
|
struct cptdumpheader hdr;
|
|
FILE *fp;
|
|
|
|
if ((fp = fopen(filename, "r")) == NULL) {
|
|
error(INFO, LOGPRX"Failed to open '%s': [Error %d] %s\n",
|
|
filename, errno, strerror(errno));
|
|
return FALSE;
|
|
}
|
|
|
|
if (fread(&hdr, sizeof(cptdumpheader), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Failed to read '%s': [Error %d] %s\n",
|
|
filename, errno, strerror(errno));
|
|
fclose(fp);
|
|
return FALSE;
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
if (hdr.id != CPTDUMP_OLD_MAGIC_NUMBER &&
|
|
hdr.id != CPTDUMP_MAGIC_NUMBER &&
|
|
hdr.id != CPTDUMP_PARTIAL_MAGIC_NUMBER &&
|
|
hdr.id != CPTDUMP_RESTORED_MAGIC_NUMBER &&
|
|
hdr.id != CPTDUMP_NORESTORE_MAGIC_NUMBER) {
|
|
if (CRASHDEBUG(1))
|
|
error(INFO, LOGPRX"Unrecognized .vmss file (magic %x).\n", hdr.id);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
vmware_vmss_init(char *filename, FILE *ofp)
|
|
{
|
|
cptdumpheader hdr;
|
|
cptgroupdesc *grps = NULL;
|
|
unsigned grpsize;
|
|
unsigned i;
|
|
FILE *fp = NULL;
|
|
int result = TRUE;
|
|
|
|
if (!machine_type("X86") && !machine_type("X86_64")) {
|
|
error(INFO,
|
|
LOGPRX"Invalid or unsupported host architecture for .vmss file: %s\n",
|
|
MACHINE_TYPE);
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
if ((fp = fopen(filename, "r")) == NULL) {
|
|
error(INFO, LOGPRX"Failed to open '%s': %s [Error %d] %s\n",
|
|
filename, errno, strerror(errno));
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
if (fread(&hdr, sizeof(cptdumpheader), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Failed to read '%s': %s [Error %d] %s\n",
|
|
filename, errno, strerror(errno));
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
DEBUG_PARSE_PRINT((ofp, LOGPRX"Header: id=%x version=%d numgroups=%d\n",
|
|
hdr.id, hdr.version, hdr.numgroups));
|
|
|
|
vmss.cpt64bit = (hdr.id != CPTDUMP_OLD_MAGIC_NUMBER);
|
|
DEBUG_PARSE_PRINT((ofp, LOGPRX"Checkpoint is %d-bit\n", vmss.cpt64bit ? 64 : 32));
|
|
if (!vmss.cpt64bit) {
|
|
error(INFO, LOGPRX"Not implemented for 32-bit VMSS file!\n");
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
grpsize = hdr.numgroups * sizeof (cptgroupdesc);
|
|
grps = (cptgroupdesc *) malloc(grpsize * sizeof(cptgroupdesc));
|
|
if (grps == NULL) {
|
|
error(INFO, LOGPRX"Failed to allocate memory! [Error %d] %s\n",
|
|
errno, strerror(errno));
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
if (fread(grps, sizeof(cptgroupdesc), grpsize, fp) != grpsize) {
|
|
error(INFO, LOGPRX"Failed to read '%s': [Error %d] %s\n",
|
|
filename, errno, strerror(errno));
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
|
|
for (i = 0; i < hdr.numgroups; i++) {
|
|
if (fseek(fp, grps[i].position, SEEK_SET) == -1) {
|
|
error(INFO, LOGPRX"Bad offset of VMSS Group['%s'] in '%s' at %#llx.\n",
|
|
grps[i].name, filename, (ulonglong)grps[i].position);
|
|
continue;
|
|
}
|
|
DEBUG_PARSE_PRINT((ofp, LOGPRX"Group: %-20s offset=%#llx size=0x%#llx.\n",
|
|
grps[i].name, (ulonglong)grps[i].position, (ulonglong)grps[i].size));
|
|
|
|
if (strcmp(grps[i].name, "memory") != 0) {
|
|
continue;
|
|
}
|
|
|
|
for (;;) {
|
|
uint16_t tag;
|
|
char name[TAG_NAMELEN_MASK + 1];
|
|
unsigned nameLen;
|
|
unsigned nindx;
|
|
int idx[3];
|
|
unsigned j;
|
|
int nextgroup = FALSE;
|
|
|
|
if (fread(&tag, sizeof(tag), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read tag.\n");
|
|
break;
|
|
}
|
|
if (tag == NULL_TAG)
|
|
break;
|
|
|
|
nameLen = TAG_NAMELEN(tag);
|
|
if (fread(name, nameLen, 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read tag name.\n");
|
|
break;
|
|
}
|
|
name[nameLen] = 0;
|
|
DEBUG_PARSE_PRINT((ofp, LOGPRX"\t Item %20s", name));
|
|
|
|
nindx = TAG_NINDX(tag);
|
|
if (nindx > 3) {
|
|
error(INFO, LOGPRX"Too many indexes %d (> 3).\n", nindx);
|
|
break;
|
|
}
|
|
idx[0] = idx[1] = idx[2] = NO_INDEX;
|
|
for (j= 0; j < nindx; j++) {
|
|
if (fread(&idx[j], sizeof(idx[0]), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read index.\n");
|
|
nextgroup = TRUE;
|
|
break;
|
|
}
|
|
DEBUG_PARSE_PRINT((ofp, "[%d]", idx[j]));
|
|
}
|
|
if (nextgroup)
|
|
break;
|
|
|
|
if (IS_BLOCK_TAG(tag)) {
|
|
uint64_t nbytes;
|
|
uint64_t blockpos;
|
|
uint64_t nbytesinmem;
|
|
int compressed = IS_BLOCK_COMPRESSED_TAG(tag);
|
|
uint16_t padsize;
|
|
|
|
if (fread(&nbytes, sizeof(nbytes), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read block size.\n");
|
|
break;
|
|
}
|
|
if (fread(&nbytesinmem, sizeof(nbytesinmem), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read block memory size.\n");
|
|
break;
|
|
}
|
|
if (fread(&padsize, sizeof(padsize), 1, fp) != 1) {
|
|
error(INFO, LOGPRX"Cannot read block padding size.\n");
|
|
break;
|
|
}
|
|
if ((blockpos = ftell(fp)) == -1) {
|
|
error(INFO, LOGPRX"Cannot determine location within VMSS file.\n");
|
|
break;
|
|
}
|
|
blockpos += padsize;
|
|
|
|
if (fseek(fp, blockpos + nbytes, SEEK_SET) == -1) {
|
|
error(INFO, LOGPRX"Cannot seek past block at %#llx.\n",
|
|
(ulonglong)(blockpos + nbytes));
|
|
break;
|
|
}
|
|
|
|
if (strcmp(name, "Memory") == 0) {
|
|
/* The things that we really care about...*/
|
|
vmss.memoffset = blockpos;
|
|
vmss.memsize = nbytesinmem;
|
|
DEBUG_PARSE_PRINT((ofp, "\t=> %sBLOCK: position=%#llx size=%#llx memsize=%#llx\n",
|
|
compressed ? "COMPRESSED " : "",
|
|
(ulonglong)blockpos, (ulonglong)nbytes, (ulonglong)nbytesinmem));
|
|
|
|
if (compressed) {
|
|
error(INFO, LOGPRX"Cannot handle compressed memory dump yet!\n");
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
} else {
|
|
union {
|
|
uint8_t val[TAG_VALSIZE_MASK];
|
|
uint32_t val32;
|
|
} u;
|
|
unsigned k;
|
|
unsigned valsize = TAG_VALSIZE(tag);
|
|
uint64_t blockpos = ftell(fp);
|
|
|
|
DEBUG_PARSE_PRINT((ofp, "\t=> position=%#llx size=%#x: ", (ulonglong)blockpos, valsize));
|
|
if (fread(u.val, sizeof(u.val[0]), valsize, fp) != valsize) {
|
|
error(INFO, LOGPRX"Cannot read item.\n");
|
|
break;
|
|
}
|
|
for (k = 0; k < valsize; k++) {
|
|
/* Assume Little Endian */
|
|
DEBUG_PARSE_PRINT((ofp, "%02X", u.val[valsize - k - 1]));
|
|
}
|
|
|
|
if (strcmp(grps[i].name, "memory") == 0) {
|
|
if (strcmp(name, "regionsCount") == 0) {
|
|
vmss.regionscount = u.val32;
|
|
}
|
|
if (strcmp(name, "regionPageNum") == 0) {
|
|
vmss.regions[idx[0]].startpagenum = u.val32;
|
|
}
|
|
if (strcmp(name, "regionPPN") == 0) {
|
|
vmss.regions[idx[0]].startppn = u.val32;
|
|
}
|
|
if (strcmp(name, "regionSize") == 0) {
|
|
vmss.regions[idx[0]].size = u.val32;
|
|
}
|
|
if (strcmp(name, "align_mask") == 0) {
|
|
vmss.alignmask = u.val32;
|
|
}
|
|
}
|
|
|
|
DEBUG_PARSE_PRINT((ofp, "\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (vmss.memsize == 0) {
|
|
char *vmem_filename, *p;
|
|
|
|
fprintf(ofp, LOGPRX"Memory dump is not part of this vmss file.\n");
|
|
fclose(fp);
|
|
fp = NULL;
|
|
|
|
fprintf(ofp, LOGPRX"Try to locate the companion vmem file ...\n");
|
|
/* check the companion vmem file */
|
|
vmem_filename = strdup(filename);
|
|
p = vmem_filename + strlen(vmem_filename) - 4;
|
|
if (strcmp(p, "vmss") != 0 && strcmp(p, "vmsn") != 0) {
|
|
free(vmem_filename);
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
strcpy(p, "vmem");
|
|
if ((fp = fopen(vmem_filename, "r")) == NULL) {
|
|
error(INFO, LOGPRX"%s: %s\n", vmem_filename, strerror(errno));
|
|
free(vmem_filename);
|
|
result = FALSE;
|
|
goto exit;
|
|
}
|
|
fseek(fp, 0L, SEEK_END);
|
|
vmss.memsize = ftell(fp);
|
|
fseek(fp, 0L, SEEK_SET);
|
|
|
|
fprintf(ofp, LOGPRX"vmem file: %s\n\n", vmem_filename);
|
|
free(vmem_filename);
|
|
}
|
|
|
|
vmss.dfp = fp;
|
|
|
|
exit:
|
|
if (grps)
|
|
free(grps);
|
|
|
|
if (!result && fp)
|
|
fclose(fp);
|
|
|
|
return result;
|
|
}
|
|
|
|
uint vmware_vmss_page_size(void)
|
|
{
|
|
return VMW_PAGE_SIZE;
|
|
}
|
|
|
|
int
|
|
read_vmware_vmss(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
|
|
{
|
|
uint64_t pos = paddr;
|
|
|
|
if (vmss.regionscount > 0) {
|
|
/* Memory is divided into regions and there are holes between them. */
|
|
uint32_t ppn = (uint32_t) (pos >> VMW_PAGE_SHIFT);
|
|
int i;
|
|
|
|
for (i = 0; i < vmss.regionscount; i++) {
|
|
if (ppn < vmss.regions[i].startppn)
|
|
break;
|
|
|
|
/* skip holes. */
|
|
pos -= ((vmss.regions[i].startppn - vmss.regions[i].startpagenum)
|
|
<< VMW_PAGE_SHIFT);
|
|
}
|
|
}
|
|
|
|
if (pos + cnt > vmss.memsize) {
|
|
error(INFO, LOGPRX"Read beyond the end of file! paddr=%#lx cnt=%d\n",
|
|
paddr, cnt);
|
|
}
|
|
|
|
pos += vmss.memoffset;
|
|
if (fseek(vmss.dfp, pos, SEEK_SET) != 0)
|
|
return SEEK_ERROR;
|
|
|
|
if (fread(bufptr, 1, cnt, vmss.dfp) != cnt)
|
|
return READ_ERROR;
|
|
|
|
return cnt;
|
|
}
|
|
|
|
int
|
|
write_vmware_vmss(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
|
|
{
|
|
return SEEK_ERROR;
|
|
}
|
|
|