projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / sam / system / mem / Memory.cc
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: Memory.cc
// Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named 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.
//
// You should have received a copy of the GNU General Public
// License along with this work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
/*
* Copyright (C) 2005 Sun Microsystems, Inc.
* All rights reserved.
*/
#include <errno.h>
#include <signal.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include "types.h"
#include "dr.h"
#include "ui.h"
#include "system.h"
#include "Memory.h"
char mem_help_string[] = "Usage : mem -a <start addr> -s <num_of_bytes> [-cpu <id>][-dis -va]\n";
char memdump_help_string[] = "memdump <filename> <start phys addr> <size>\n";
static int mem_cmd_action (void * , int argc, char **argv);
static int memdump_cmd_action (void * , int argc, char **argv);
bool_t mem_dump (DR_OPAQUE pdr);
bool_t mem_restore (DR_OPAQUE pdr);
#if defined(MEMORY_FLAT)
// constructor , e.g. SMemory(uint64_t(0x1) << 36,48);
SMemory::SMemory
(
uint64_t _ram_size, // mem size (bytes)
uint_t pa_bits // number of valid bits in physical address
)
:
mem(0), size(_ram_size)
{
assert(pa_bits < 64);
pa_mask = (uint64_t(1)<<pa_bits)-1;
for (int i = 0; i < SAM_NMEM_LOCKS; i++)
mutex_init(&locks[i], USYNC_THREAD, NULL);
DR_register ((char*)"mm1", mem_dump, mem_restore, (void*)this);
UI_register_cmd_2 ((char*)"mem", mem_help_string, mem_cmd_action, NULL);
UI_register_cmd_2 ((char*)"memdump", memdump_help_string, memdump_cmd_action, NULL);
}
// mem init method
int SMemory::init
(
char *file_name, // file name for private mem file, default is NULL
int is_private // 1 if private file, 0 if a temporary file (default)
)
{
// check if init method was called second time
if (mem && (mem != MAP_FAILED))
{
munmap((char*)mem,size);
}
int prot = PROT_READ|PROT_WRITE;
int flags = MAP_ALIGN;
mfile = -1;
if (file_name == NULL)
{
// map anonymous fragment (in swap space);
// for large mem size it requires to have enough
// swap space on the host machine
flags |= MAP_ANON;
if ( !SYSTEM_get_memreserve() )
{
// do not reserve swap space before the run
ui->warning("You might run out of swap space with -nomemreserve option \n");
flags |= MAP_NORESERVE|MAP_PRIVATE;
}
else
{
// swap space should be reserved before the run
flags |= MAP_SHARED;
}
mem = (uint8_t*)mmap((char*)0,size, prot, flags, -1, 0);
}
else // map memory image to a file
{
if (file_name[0] == '/')
{
// this is an absolute path
mem_file = strdup(file_name);
}
else // file in the working directory
{
char path[PATH_MAX];
if (getwd(path) == NULL)
{
ui->error("memory: cannot get current working directory\n");
return 0;
}
mem_file = (char *)calloc(strlen(path)+strlen(file_name)+16, sizeof(char));
sprintf(mem_file,"%s/%s", path, file_name);
}
ui->output("map ram image to %s, size = %lld bytes\n", mem_file, size);
if (is_private)
{
// open a checkpoint mem image
int img = open ( mem_file, O_RDONLY|O_LARGEFILE );
if (img < 0)
{
ui->error("memory: cannot open %s, %s\n",mem_file, strerror(errno));
return 0;
}
// To avoid the mem image file to be modified during the run
// map it as a private - all changes will go to pages allocated in
// swap space
if ( !SYSTEM_get_memreserve() )
{
// do not reserve swap space before the run
ui->warning("You might run out of swap space with -nomemreserve option \n");
flags |= MAP_NORESERVE;
}
mem = (uint8_t*)mmap((char*)0,size, prot, flags|MAP_PRIVATE, img, 0);
}
else // temporary mem file
{
if (access(mem_file, W_OK)==0)
{
ui->error("memory: another sim is already using %s file\n",mem_file);
return 0;
}
// open a new mem file
mfile = open (mem_file, O_RDWR|O_CREAT|O_LARGEFILE|O_TRUNC,
S_IRWXO|S_IRWXG|S_IRWXU);
if (mfile < 0)
{
ui->error("memory: cannot open %s, %s\n", mem_file, strerror(errno));
return 0;
}
// write the very last byte in the mem file
// to set the effective size of the file
if (lseek(mfile, size-1, SEEK_SET) < 0)
{
ui->error("memory: cannot set mem file size, %s \n", strerror(errno));
return 0;
}
if (write(mfile, "", 1) != 1)
{
ui->error("memory: cannot write mem file, %s \n", strerror(errno));
return 0;
}
mem = (uint8_t*)mmap((char*)0,size, prot, flags|MAP_SHARED, mfile, 0);
}
} // map to a file
if (mem == MAP_FAILED)
{
ui->error("memory: cannot mmap file, %s\n",strerror(errno));
return 0;
}
return 1;
}
/*}}}*/
// load bin format
int SMemory::load_bin( const char *file, uint64_t addr)/*{{{*/
{
FILE *fp = fopen (file, "r");
struct stat s;
if (fp == NULL)
{
ui->perror(file);
return 1;
}
if (stat(file, &s))
{
ui->perror(file);
return 1;
}
uint64_t fsize = s.st_size;
ui->verbose("loading %s, base addr 0x%016llx, size 0x%llx\n", file, addr, fsize);
// check if bin file could fit into the allocated memory
if (addr+fsize > get_size())
{
ui->error("MEM: ram_size = 0x%llx, cannot load 0x%llx bytes \n", get_size(), fsize);
return 1;
}
uint8_t *start_addr = (uint8_t *)(mem + ofs(addr));
if(fread(start_addr, sizeof(uint8_t), fsize, fp) == 0)
{
ui->error("MEM: cannot read file %s \n", file);
return 1;
}
fclose(fp);
return 0;
}
SMemory::~SMemory()/*{{{*/
{
if (mem && (mem != MAP_FAILED))
{
munmap((char*)mem,size);
}
if (mfile > 0)
{
close ( mfile );
remove( mem_file );
}
if (mem_file)
{
free ( mem_file );
}
}
/*}}}*/
///////////////////////////////////////////////////////////////
void SMemory::handle_out_of_range ( uint64_t addr )
{
ui->error("memory: address %llx exceeds mem range %llx, redirect access to address 0; bus error was not signaled \n", addr, size);
exit(1);
}
#elif defined(MEMORY_SPARSE)
SMemory::SMemory
(
uint64_t ram_size,
uint_t pa_bits,
uint_t _l1bits,
uint_t _l2bits,
uint_t _l3bits
)/*{{{*/
:
l1(0),
l1bits(_l1bits),
l2bits(_l2bits),
l3bits(_l3bits),
l1shft((l2bits + l3bits) - 3),// Compensate for pointer indexing, as I don't trust compiler
l2shft(l3bits - 3), // for doing a good job on the index computation code
l1size((1 << l1bits) << 3),
l2size((1 << l2bits) << 3),
l3size( 1 << l3bits),
l1mask(((1 << l1bits) - 1) << 3),
l2mask(((1 << l2bits) - 1) << 3),
l3mask(((1 << l3bits) - 1))
{
assert(l3bits >= 13);
size = ram_size;
pa_mask = (uint64_t(1)<<pa_bits)-1;
memset(uninit_page,0,512);
l1 = (uint8_t***)calloc(l1size, sizeof(uint8_t));
for (int i = 0; i < SAM_NMEM_LOCKS; i++)
mutex_init(&locks[i], USYNC_THREAD, NULL);
mutex_init(&l2_lock, USYNC_THREAD, NULL);
mutex_init(&l3_lock, USYNC_THREAD, NULL);
mlist = 0;
DR_register ((char*)"mm1", mem_dump, mem_restore, (void*)this);
UI_register_cmd_2 ((char*)"mem", mem_help_string, mem_cmd_action, NULL);
UI_register_cmd_2 ((char*)"memdump", memdump_help_string, memdump_cmd_action, NULL);
}
SMemory::~SMemory()/*{{{*/
{
// memory object is constructed only once and
// cannot be reconfigured during the run;
// rely on the system to free up all allocated memory on exit();
return;
/* normally we would need to
* remove sparse mem tables
*/
#if 0
for (int i1=0; i1 < (1 << l1bits); i1++)
{
uint8_t** l2 = l1[i1];
if (l2)
{
for (int i2=0; i2 < (1 <<l2bits); i2++)
{
uint8_t* l3= l2[i2];
if (l3)
{
// it maybe mmaped to a file;
// if some random value is passed to free(),
// the results are undefined.
free(l3);
}
}
free(l2);
}
}
free(l1);
// remove mmaped files
while(mlist)
{
MappedFileEntry *next = mlist->next;
delete(mlist);
mlist = next;
}
#endif
}
////////////////////////////////////////////////////////////////
//
// mem block copy
//
int SMemory::block_read(uint64_t addr, uint8_t *tgt, int _size)
{
//for (int i=0; i<_size; i++) tgt[i] = ld8u(addr+i);
while(_size)
{
uint8_t* paddr = get_st_ptr (addr); // page allocate
uint64_t offset = addr & l3mask;
uint64_t pagebytes = l3size - offset;
uint64_t nb = (_size > pagebytes) ? pagebytes : _size;
memcpy(tgt, paddr, (size_t)nb);
_size -= (int) nb;
addr += nb;
tgt += nb;
} // while more bytes to copy
return 0;
}
int SMemory::block_write(uint64_t addr, const uint8_t *src, int _size)
{
//for (int i=0; i<_size; i++) st8(addr+i, src[i]);
while(_size)
{
uint8_t* paddr = get_st_ptr (addr);
uint64_t offset = addr & l3mask;
uint64_t pagebytes = l3size - offset;
uint64_t nb = (_size > pagebytes) ? pagebytes : _size;
memcpy(paddr, src, (size_t)nb);
_size -= (int) nb;
addr += nb;
src += nb;
} // while more bytes to copy
return 0;
}
// construct memory mapped file entry
MappedFileEntry::MappedFileEntry
(
const char *file_name, // name of the file
uint64_t saddr // starting address
)
:
name (0),
mfile(-1),
mem (0),
size (0),
next (0)
{
addr = saddr; // keep starting address
// check file name
if (file_name[0] == '/')
{
// this is an absolute path
name = strdup(file_name);
}
else // file is in working directory
{
char path[PATH_MAX];
if (getwd(path) == NULL)
{
ui->error("memory: cannot get current working directory\n");
return;
}
// keep absolute file name
name = (char *)calloc(strlen(path)+strlen(file_name)+16, sizeof(char));
sprintf(name,"%s/%s", path, file_name);
}
// check file size
struct stat s;
if (stat(name, &s))
{
ui->perror(name);
return;
}
size = s.st_size;
ui->verbose("loading %s, base addr 0x%016llx, size 0x%llx\n", name, addr, size);
// open the file
mfile = open ( name, O_RDONLY|O_LARGEFILE );
if (mfile < 0)
{
ui->error("memory: cannot open %s, %s\n",name, strerror(errno));
return;
}
// map file as a private - all changes will go to pages allocated in swap space
int prot = PROT_READ|PROT_WRITE;
int flags = MAP_ALIGN|MAP_PRIVATE;
if ( !SYSTEM_get_memreserve() )
{
// do not reserve swap space before the run
ui->warning("You might run out of swap space with -nomemreserve option \n");
flags |= MAP_NORESERVE;
}
mem = (uint8_t*)mmap((char*)0,size, prot, flags, mfile, 0);
}
MappedFileEntry::~MappedFileEntry()
{
if (mem && (mem != MAP_FAILED))
{
munmap((char*)mem,size);
}
if (mfile > 0)
{
close ( mfile );
}
if (name)
{
free (name);
}
}
// load bin format
int SMemory::load_bin( const char *file, uint64_t addr)/*{{{*/
{
MappedFileEntry *mm_entry = new MappedFileEntry(file, addr);
if (!mm_entry->is_valid() || !this->map(mm_entry))
{
ui->error("cannot load %s, base addr 0x%016llx\n", file, addr);
delete mm_entry;
return 1;
}
link(mm_entry);
return 0;
}
// map page from the mmaped file
int SMemory::map_page
(
uint64_t paddr, // page address
uint8_t *maddr // page address in the mmapped file
)
{
// look up the entry in the tables where paddr suppose to reside
uint8_t*** o1 = (uint8_t***)((char*)l1 + ((paddr >> l1shft) & l1mask) );
uint8_t** l2 = *o1;
if (l2 == 0)
{
l2 = *o1 = (uint8_t**)calloc(l2size,sizeof(uint8_t));
}
if (l2==0)
{
ui->error("\nMEM: Run out of memory, exit...\n");
exit(1);
}
uint8_t** o2 = (uint8_t**)((char*)l2 + ((paddr >> l2shft) & l2mask));
uint8_t* l3 = *o2;
if (l3 == 0) // map the page
{
*o2 = maddr;
}
else // page is already allocated
{
return 0;
}
return 1;
}
// map sparse mem pages to mem mapped file
int SMemory::map
(
MappedFileEntry *entry
)
{
// init counters and pointers
int npages = 0; // page counter
uint64_t start_addr = entry->addr;
uint64_t addr = start_addr;
uint64_t fsize = entry->size;
uint8_t *faddr = entry->mem;
off_t foff = 0;
while ( fsize > 0 )
{
uint64_t offset = addr & l3mask;
uint64_t pagebytes = l3size - offset;
// number of bytes that should be on the same sparse mem page
uint64_t nb = (fsize > pagebytes) ? pagebytes : fsize;
// if this address range doesn't fit exactly to the sparse mem page
// and can't be memory mapped (because a previous file as been
// mapped to this range), just allocate space with get_st_ptr and
// read from the file.
if (nb != l3size || !map_page(addr, faddr))
{
// make a copy of this page
uint8_t* paddr = get_st_ptr (addr);
// seek to the beginning of the "page" to copy
if (lseek(entry->mfile, foff, SEEK_SET) == -1)
{
ui->error("\nMEM: can't seek to 0x%llx for file %s\n",
foff, entry->name);
exit(1);
}
if (read(entry->mfile, paddr, nb) != nb)
{
ui->error("\nMEM: can't read 0x%llx bytes from file %s\n",
nb, entry->name);
exit(1);
}
}
fsize -= nb;
addr += nb;
faddr += nb;
foff += nb;
} // while something left in the file
return 1;
}
#endif // end MEMORY_SPARSE
enum { BUFFER_SIZE = 512 };
static char buffer[BUFFER_SIZE];
// load image format;
// use st64_nl, common for all mem models
int SMemory::load( const char* mem_image_filename )/*{{{*/
{
const char* separ = " \t\n";
FILE* image = fopen(mem_image_filename,"r");
uint64_t addr = 0;
if (!image)
{
ui->error("MEM: No such mem image file found.");
return 1;
}
while (fgets(buffer,BUFFER_SIZE,image))
{
if (buffer[0] == '@')
{
addr = strtoull(buffer+1,0,16);
}
else if (isxdigit(buffer[0]))
{
char* token = strtok(buffer,separ);
uint64_t length = strlen(token);
if (length == 16)
{
do
{
uint64_t data = strtoull(token,0,16);
st64_nl(addr,data);
addr += 8;
}
while ((token = strtok(0,separ)));
}
else if (length == 8)
{
do
{
uint32_t data = uint32_t(strtoul(token,0,16));
st32(addr,data);
addr += 4;
}
while ((token = strtok(0,separ)));
}
else if ((length == 1) && buffer[0] == '0')
{
// skip empty line
continue;
}
else
{
ui->error("A memory entry must be either 4 or 8 bytes.");
return 1;
}
}
}
fclose(image);
return 0;
}
/*}}}*/
void SMemory::save( const char* filename, uint64_t addr, uint64_t _size )/*{{{*/
{
const int PAGE_SIZE = 1 << 13;
const int PAGE_MASK = PAGE_SIZE - 1;
FILE* image = fopen(filename,"w");
if (!image)
{
ui->perror(filename);
return;
}
uint8_t *buf8 = (uint8_t *)malloc(PAGE_SIZE);
if ((addr & PAGE_MASK) != 0)
{
uint64_t n = PAGE_SIZE - (addr & PAGE_MASK);
if (_size < n)
n = _size;
block_read(addr, buf8, int(n));
fwrite(buf8,1,n,image);
addr += n;
_size -= n;
}
while (_size >= PAGE_SIZE)
{
block_read(addr, buf8, PAGE_SIZE);
fwrite(buf8,1,PAGE_SIZE,image);
addr += PAGE_SIZE;
_size -= PAGE_SIZE;
}
if (_size)
{
block_read(addr, buf8, _size);
fwrite(buf8,1,_size,image);
}
free(buf8);
fclose(image);
}
//////////////////////////////////////////////////
///
/// Memory object DUMP/RESTORE
///
//////////////////////////////////////////////////
#define DUMPSIZE 1024
#define DISPLAY_SIZE (0x20000000LLU) // 512M
#define THRESHOLD_512M (0x20000000LLU)
#define THRESHOLD_4G (0x100000000LLU)
#define THRESHOLD_16G (0x400000000LLU)
#define MASK_32M (0x1ffffffLLU)
#define MASK_128M (0x7ffffffLLU)
#define MASK_1G (0x3fffffffLLU)
#define MASK_4G (0xffffffffLLU)
#define MAX_ADDR (0xFFFFFFFFFFFFFFFFLLU)
extern void dump_uint32 (FILE * fp, uint32_t val);
extern void dump_uint64 (FILE * fp, uint64_t val);
extern uint64_t restore_uint64 (FILE * fp);
////////////////////////////////////////////////////////
//
// restore mem from dump file
//
int SMemory::restore ( char *dir )
{
if (DR_restore_object (dir, (char*)"mm1"))
return 1;
return 0;
}
bool_t mem_dump (DR_OPAQUE pdr)
{
char *name = DR_get_name (pdr);
char *dir = DR_get_dir ();
SMemory *msp = (SMemory*) DR_get_client_data (pdr);
return msp->dump(dir, name);
}
#if defined(MEMORY_FLAT)
///////////////////////////////////////////////////
int SMemory::dump ( char *dir, char *name)
{
FILE *fp;
uint64_t i,j;
uint64_t npages = this->get_size()/DUMPSIZE;
uint64_t mask;
uint64_t cur_addr = 0;
uint64_t dpages = 0;
char fname[PATH_MAX];
sprintf (fname, "%s/%s.dmp.img", dir, name);
// set to false if older mm1.dmp (v4) format is needed
bool img_format = true;
if ((fp = fopen (fname, "w")) == NULL)
{
ui->perror(fname);
return 0;
}
// depending on memsize mask defines progress update frequency
if (this->get_size() <= THRESHOLD_512M) {
mask = MASK_32M;
}
else if (this->get_size() <= THRESHOLD_4G) {
mask = MASK_128M;
}
else if (this->get_size() <= THRESHOLD_16G) {
mask = MASK_1G;
}
else {
mask = MASK_4G;
}
ui->output("MEM: ram_size = 0x%llx (%lld MB), pages = 0x%lld\n",
get_size(), get_size()>>20, npages);
for (i = 0; i < npages; i++)
{
bool_t clean = 1;
cur_addr += DUMPSIZE;
// show the progress
if ((cur_addr & mask) == 0)
{
ui->output(".");
ui->flush();
}
uint64_t paddr = i*DUMPSIZE;
uint8_t *mem_page = get_base() + paddr;
// check if page is modified - has non-zero values;
// sparse mem files always read 0 from address that
// was never written, by default;
for (j = 0; j < DUMPSIZE; j = j + 8)
{
if (*(uint64_t *) (mem_page + j) != 0) {
clean = 0;
break;
}
}
if (!clean) // dump modified page
{
if (img_format)
{
// write the page using sparse file
if ( fseek(fp, paddr, SEEK_SET) < 0 )
{
ui->error("MEM: cannot set page addr 0x%llx, %s \n",
paddr, strerror(errno));
return 0;
}
}
else // old dmp format
{
dump_uint64(fp, i); // page number
}
if ( fwrite (mem_page, DUMPSIZE, 1, fp) != 1 )
{
ui->perror("DUMP (mm1)");
return 0;
}
dpages++;
}
}
if (img_format)
{
// make sure that the very last byte is written
// to set correct file size
uint64_t last_byte = get_size() - 1;
fseek(fp, last_byte, SEEK_SET);
uint8_t *plast_byte = get_base() + last_byte;
if ( fwrite (plast_byte, 1, 1, fp) != 1 )
{
ui->perror("DUMP (mm1)");
return 0;
}
}
else
{
i = MAX_ADDR;
dump_uint64(fp, i);
}
fclose (fp);
ui->output("MEM: dumped 0x%llx (modified 0x%llx) pages \n", npages, dpages);
return 1;
} // mem_dump()
/////////////////////////////////////////////
//
// restore command
//
bool_t mem_restore (DR_OPAQUE pdr)
{
char *name = DR_get_name (pdr);
char *dir = DR_get_rdir (pdr);
SMemory *msp = (SMemory*) DR_get_client_data (pdr);
FILE *fp;
uint64_t npages = msp->get_size()/DUMPSIZE;
uint64_t zpages = 0;
uint64_t page_no;
char *mem;
char fname[PATH_MAX];
sprintf (fname, "%s/%s.dmp.img", dir, name);
if ( access(fname, R_OK) ==0 )
{
// restore mem image checkpoint;
// map it as a private file
if (msp->init(fname, 1))
{
ui->output("MEM: restored 0x%llx bytes \n", msp->get_size());
return 1;
}
return 0;
}
// restore from mm1.dmp file
if( !msp->init() )
{
ui->error("MEM: cannot allocate enough space \n");
return 0;
}
// mem dmp checkpoint
sprintf (fname, "%s/%s.dmp", dir, name);
if ((fp = fopen (fname, "r")) == NULL) {
ui->perror(fname);
return 0;
}
fseek(fp, 0, SEEK_END);
size_t fsize = ftell(fp);
fseek(fp, 0, SEEK_SET);
int ztotal = (fsize/DUMPSIZE);
ui->output("(dump size %lld MB):\n", (uint64_t)(fsize>>20));;
int pcttarget = 0;
// copy non-zero pages to mem file
while (1) {
uint64_t offset;
page_no = restore_uint64(fp);
if (page_no == MAX_ADDR) {
break;
}
offset = page_no*DUMPSIZE;
if (offset > (msp->get_size() - DUMPSIZE)) {
ui->output("MEM: restore to 0x%llx is beyond memory ram_size (0x%llx), discarding...\n",
offset, msp->get_size());
return 0;
}
else {
mem = (char*) (msp->get_base()+offset);
}
if (fread(mem, DUMPSIZE, 1, fp) != 1) {
ui->output("MEM: restore : restore state failed\n");
return 0;
}
zpages++;
int pct = (100.0*zpages/ztotal);
if (pct >= pcttarget) {
ui->output("%d%% ", pct);
ui->flush();
pcttarget = pct+2;
}
}
ui->output("MEM: restored 0x%llx pages \n", zpages);
return 1;
}
#elif defined(MEMORY_SPARSE)
// dump sparse mem pages
int SMemory::dump ( char *dir, char* name)
{
FILE *fp, *fidx;
char fname[PATH_MAX], iname[PATH_MAX];
sprintf (fname, "%s/%s.dmp.img", dir, name);
sprintf (iname, "%s/%s.dmp.idx", dir, name);
ui->output("\n");
if ((fp = fopen (fname, "w")) == NULL)
{
ui->perror(fname);
return 0;
}
if ((fidx = fopen (iname, "w")) == NULL)
{
ui->perror(iname);
return 0;
}
// version number
dump_uint64(fidx, SAM_MEM_DUMP_VERSION);
// dump sparse mem table sizes
dump_uint64(fidx, l1size);
dump_uint64(fidx, l2size);
dump_uint64(fidx, l3size);
uint64_t npages = 0;
uint64_t dpages = 0;
uint64_t foffset = 0;
uint64_t next_page_addr = MAX_ADDR;
uint64_t block_addr = 0;
uint64_t block_offs = 0;
uint64_t block_size = l3size;
uint64_t nblocks = 0;
uint64_t nidx = 0;
for (uint64_t i1=0; i1 < (1 << l1bits); i1++)
{
uint8_t** l2 = l1[i1];
if (l2)
{
for (uint64_t i2=0; i2 < (1 <<l2bits); i2++)
{
uint64_t page_addr = (i1 << (l2bits + l3bits)) | (i2 << l3bits);
uint8_t* l3= l2[i2];
if (l3) // dump this page
{
if ( page_addr == next_page_addr )
{
// it is a next page in the block
block_size += l3size;
}
else // start a new block
{
if (next_page_addr != MAX_ADDR)
{
// current block address,offset, size
dump_uint64(fidx, block_addr);
dump_uint64(fidx, block_offs);
dump_uint64(fidx, block_size);
nidx++;
}
// start a new block
block_addr = page_addr;
block_offs = foffset;
block_size = l3size;
next_page_addr = page_addr;
nblocks++;
}
if (is_dirty(l3)) dpages++;
// clear dirty bit
l3 = mask_dirty(l3);
l2[i2] = l3;
// dump mem page
if (fwrite ( (char*)l3, l3size, 1, fp ) != 1)
{
ui->perror("DUMP (mm1)");
return 0;
}
foffset += l3size;
next_page_addr += l3size;
npages++; // number of pages
// display progress
if (npages % 32 == 0) {
// erase previous value using back-space chars
ui->output("%-5d MB\r",(npages << (l3bits-20)) );
}
} // if (l3)
}
}
}
// last page
if (nblocks != nidx)
{
dump_uint64(fidx, block_addr);
dump_uint64(fidx, block_offs);
dump_uint64(fidx, block_size);
}
// delimiter
dump_uint64(fidx,MAX_ADDR);
dump_uint64(fidx,nblocks);
dump_uint64(fidx,npages);
fclose (fp);
fclose (fidx);
ui->output("\nMEM: dumped %lld pages (%lld dirty), %lld blocks \n", npages, dpages, nblocks);
return 1;
}
// restore from a checkpoint which has
// addresses and data are in one file
uint64_t restore_mem_checkpoint
(
SMemory *msp,
MappedFileEntry *entry
)
{
// we are here because we didn't find an index file
// if this is a blaze dump, it has to be a flat-memory dump
// otherwise, it has to be a vonk sparse memory dump with addresses & data in one file
// find the first vcpu and get its vcpu type
int cpuid;
Vcpu * first_vcpu = NULL;
for (cpuid=0; cpuid<=g_vcpu_id_max; cpuid++) {
first_vcpu = get_vcpu(cpuid);
if (first_vcpu != NULL) break;
}
if ((first_vcpu->config.cpu_type & VCPU_IMPL_SIM_MASK) == VCPU_IMPL_SIM_BLAZE ) {
ui->output("MEM: mapping in blaze flat-mem dump into sparse-memory model");
msp->map(entry);
return 0;
}
// read sparse mem table sizes
uint64_t r_l1size; read(entry->mfile, &r_l1size, 8);
uint64_t r_l2size; read(entry->mfile, &r_l2size, 8);
uint64_t r_l3size; read(entry->mfile, &r_l3size, 8);
// restored page counter
uint64_t zpages = 0;
// check mem configuration
if (r_l1size != msp->get_l1size() ||
r_l2size != msp->get_l2size() ||
r_l3size != msp->get_l3size() )
{
ui->output("MEM: restore : sparse mem configuration does not match\n");
return 0;
}
// add three table sizes and one page address 8 bytes each = 32
uint8_t *faddr = entry->mem + 32;
while (1)
{
// read page address
uint64_t page_addr; read(entry->mfile, &page_addr, 8);
if (page_addr == MAX_ADDR)
break; // last page was restored
// only l3size pages are written to the file
if (msp->map_page(page_addr, faddr))
{
// page is mapped to the mem file, adjust the file pointer
if (lseek(entry->mfile, r_l3size, SEEK_CUR) < 0)
{
ui->error("MEM: cannot set file pointer, %s \n", strerror(errno));
return 0;
}
}
else
{
// allocate a new mem page
uint8_t* mem_page = msp->get_st_ptr( page_addr );
// read the page from the file
uint64_t restore = read(entry->mfile, mem_page, r_l3size);
if (restore != r_l3size)
{
ui->output("MEM: read 0x%llx bytes from 0x%llx block : restore failed\n", restore, r_l3size);
return 0;
}
}
faddr += (r_l3size+8); // adjust for page address 8 bytes
zpages++;
}
return zpages;
}
// restore mem from the file;
// mem pages are set to point to mmaped file;
// use lseek() to find page addresses;
// speed of mem restore could be improved if addresses are
// stored in a serate file
bool_t mem_restore (DR_OPAQUE pdr)
{
char *name = DR_get_name (pdr);
char *dir = DR_get_rdir (pdr);
char fname[PATH_MAX];
char iname[PATH_MAX];
char dmpfname[PATH_MAX];
struct stat statbuf;
sprintf (fname, "%s/%s.dmp.img", dir, name);
sprintf (iname, "%s/%s.dmp.idx", dir, name);
SMemory *msp = (SMemory*) DR_get_client_data (pdr);
MappedFileEntry *mm_entry = new MappedFileEntry(fname);
if (!mm_entry->is_valid())
{
ui->error("mem_restore: cannot load ");
ui->perror(fname);
if (errno == ENOENT) {
// check if a blaze-v4 style mm1.dmp file exists
sprintf(dmpfname, "%s/%s.dmp", dir, name);
if (stat(dmpfname, &statbuf) == 0) {
ui->warning(
"This dump contains an old, unsupported version of the\n"
"memory dump file (%s). Please contact the owner of this\n"
"checkpoint to update this file.\n\n"
"If you are the owner, you can update this file using:\n\n"
" memdump2image -i %s -o %s\n\n",
dmpfname, dmpfname, fname);
} // if mm1.dmp exists
}
delete mm_entry;
return 0;
}
// add the file to mmapped list
msp->link(mm_entry);
// restored page counter
uint64_t zpages = 0;
uint64_t nblocks = 0;
// open index file
int fidx = open ( iname, O_RDONLY|O_LARGEFILE );
if (fidx < 0)
{
ui->error("MEM: cannot open %s, this is an older checkpoint version.\n",iname);
zpages = restore_mem_checkpoint(msp, mm_entry);
}
else
{
// read sparse mem table sizes
uint64_t r_ver; read(fidx, &r_ver, 8);
uint64_t r_l1size; read(fidx, &r_l1size, 8);
uint64_t r_l2size; read(fidx, &r_l2size, 8);
uint64_t r_l3size; read(fidx, &r_l3size, 8);
// check mem configuration
if (r_l1size != msp->get_l1size() ||
r_l2size != msp->get_l2size() ||
r_l3size != msp->get_l3size() )
{
ui->error("MEM: restore : sparse mem configuration does not match\n");
return 0;
}
while (1)
{
// read page address, size, offset in the file
uint64_t block_addr; read(fidx, &block_addr, 8);
uint64_t block_offs; read(fidx, &block_offs, 8);
uint64_t block_size; read(fidx, &block_size, 8);
if (block_addr == MAX_ADDR)
{
// check counters
if ( nblocks != block_offs || zpages != block_size )
{
ui->error("MEM: read 0x%llx blocks, 0x%llx pages - there should be 0x%llx blocks, 0x%llx pages : restore failed\n",
nblocks, zpages, block_offs, block_size);
return 0;
}
break; // last page was restored
}
nblocks++;
uint64_t page_addr = block_addr;
uint64_t page_offs = block_offs;
while(block_size>0)
{
// try to map page to the file
if ( ! msp->map_page(page_addr, mm_entry->mem + page_offs) )
{
// cannot mmap, something is already there - need to do a copy
// get mem page pointer
uint8_t* mem_page = msp->get_st_ptr( page_addr );
// adjust the file pointer
if (lseek(mm_entry->mfile, page_offs, SEEK_SET) < 0)
{
ui->error("MEM: cannot set file pointer, %s \n", strerror(errno));
return 0;
}
// read the page from the file
uint64_t restore = read(mm_entry->mfile, mem_page, r_l3size);
if (restore != r_l3size)
{
ui->error("MEM: read 0x%llx bytes from 0x%llx block : restore failed\n", restore, r_l3size);
return 0;
}
}
page_addr += r_l3size;
page_offs += r_l3size;
block_size -= r_l3size;
zpages++;
}
}
close(fidx);
}
ui->output("MEM: restored 0x%llx pages, 0x%llx blocks \n", zpages, nblocks );
return 1;
}
#endif // MEMORY_SPARSE
/////////////////////////////////////////////
//
// ui mem command
//
#include "cpu_interface.h"
extern SMemory *mm1;
void print_mem_cmd_usage()
{
ui->output("%s", mem_help_string);
}
static int mem_cmd_action (void *, int argc, char **argv)
{
uint64_t saddr=0;
uint64_t eaddr=0;
uint64_t size=16;
int i;
int is_va = 0;
int is_dis = 0;
int cpuid = 0;
if (mm1 == NULL)
{
ui->output("MEM: RAM is not allocated yet \n");
return 0;
}
if (argc < 2)
{
print_mem_cmd_usage();
return 1;
}
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "-dis")==0)
{
is_dis = 1;
ui->output( " disassemble");
continue;
}
else if (strcmp(argv[i], "-va" )==0)
{
is_va = 1;
ui->output( " addr is virtual");
continue;
}
else if ((strcmp(argv[i], "-cpu")==0) && ((i+1)<argc))
{
cpuid = int(strtol(argv[++i], NULL, 0));
Vcpu *vcpu = get_vcpu(cpuid);
if (!vcpu)
{
ui->output( "cpu id %i is unknown \n",cpuid);
return 0;
}
ui->output( " for cpu[%i]",cpuid);
continue;
}
else if ((strcmp(argv[i], "-a")==0) && ((i+1)<argc))
{
saddr = strtoull(argv[++i], NULL, 0);
saddr &= ~7LLU;
eaddr = saddr + 16;
continue;
}
else if ((strcmp(argv[i], "-s")==0) && ((i+1)<argc))
{
size = strtoull(argv[++i], NULL, 0);
continue;
}
else if (strcmp(argv[i], "?" )==0)
{
print_mem_cmd_usage();
return 1;
}
}
eaddr = saddr + size;
ui->output( " saddr=0x%llx eaddr=0x%llx\n",saddr, eaddr);
uint64_t baddr = saddr;
for (;saddr <= eaddr; saddr)
{
uint64_t v[4];
for (i = 0; i < 4; i++, saddr += 8)
{
#if defined(MEMORY_FLAT)
if (saddr >= mm1->get_size()-8)
{
ui->output( "MEM: phys address 0x%llx is beyond RAM \n", saddr);
return 1;
}
#endif
if (is_va)
{
uint64_t val = 0;
if(g_vcpu[cpuid]->read_mem(saddr, &val, 8) != 0)
{
ui->output( "MEM: cannot translate virtual address \n", saddr);
return 1;
}
else
{
v[i] = val;
}
}
else
{
v[i] = mm1->SMemory::ld64(saddr);
}
if (is_dis)
{
const int LSIZE = 128;
char iline[LSIZE];
uint32_t opc = uint32_t(v[i]>>32);
disassemble(opc, saddr , iline, LSIZE);
ui->output ("%i : 0x%llx: 0x%lx : %s \n", cpuid, saddr, opc, iline);
opc = uint32_t(v[i] & 0xffffffff);
disassemble(opc, saddr+4, iline, LSIZE);
ui->output ("%i : 0x%llx: 0x%lx : %s \n", cpuid, saddr+4, opc, iline);
}
else
{
if ( i==0 ) ui->output ("0x%llx:", baddr);
ui->output (" 0x%016llx", v[i] );
if ( i==3 ) ui->output ("\n");
}
}
baddr = saddr;
}
return 0;
} // mem_cmd_action()
/////////////////////////////////////////////
//
// ui memdump command
//
void print_memdump_cmd_usage()
{
ui->error ("Usage : memdump <filename> <start addr> <size> \n");
}
static int memdump_cmd_action (void *, int argc, char **argv)
{
uint64_t saddr = ~0ull;
uint64_t size = 0;
char *filename;
if (mm1 == NULL)
{
ui->error("MEM: RAM is not allocated yet \n");
return 0;
}
if (argc < 4)
{
print_memdump_cmd_usage();
return 1;
}
filename = argv[1];
saddr = strtoull(argv[2], NULL, 0);
size = strtoull(argv[3], NULL, 0);
if (!saddr || !size)
#ifdef MEMORY_SPARSE
if ((saddr == ~0ull) || (size==0))
#endif
#ifdef MEMORY_FLAT
if ((size==0) || (saddr > mm1->get_size()) || (saddr+size > mm1->get_size()))
#endif
{
ui->error("memdump: incorrect start address or size \n");
print_memdump_cmd_usage();
return 1;
}
ui->output("writing mem image to the file: %s, start address 0x%llx, size 0x%llx ... \n",
filename, saddr, size);
mm1->save(filename, saddr,size);
ui->output("----- MEMDUMP COMPLETED -----\n");
return 0;
} // memdump_cmd_action()
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.