uchar *
dbg_print_domain(uchar * hdr, uchar * itor)
{
uchar len;
uchar *tmp = NULL;
ushort offset;
int debug = 100;
len = itor[0];
if (len == 0) {
printf("root\n");
return 0;
}
offset = ntohs((ushort) * (ushort *) itor);
if (IS_PTR(offset))
itor = hdr + GET_OFFSET(offset);
while (len != 0 && debug--) {
if (IS_PTR(offset)) {
tmp = itor + 2;
itor = dbg_print_label(hdr + GET_OFFSET(offset), 1);
} else
itor = dbg_print_label(itor, 1);
printf(".");
len = itor[0];
offset = ntohs((ushort) * (ushort *) itor);
}
printf("\n");
if (tmp == NULL)
tmp = itor + 1;
return tmp;
}
/** チェックサムを書き込む。
* @param モジュール番号
**************************************************************************** */
BOOL PARA_SetCheckSum( void )
{
uint16_t offset;
BOOL stat = FALSE;
Parameter.CheckSum = 0;
Parameter.CheckSum = 0 - para_GetSum( (void*)&Parameter, sizeof( Parameter ) );
offset = GET_OFFSET( Parameter, CheckSum );
if( EEPROM_WriteData( EEPROM_PAGE_0 + offset, (uint8_t*)&Parameter.CheckSum, sizeof( int8_t ) ) )
stat = TRUE;
if( EEPROM_WriteData( EEPROM_PAGE_1 + offset, (uint8_t*)&Parameter.CheckSum, sizeof( int8_t ) ) )
stat = TRUE;
ParameterEx.CheckSum = 0;
ParameterEx.CheckSum = 0 - para_GetSum( (void*)&ParameterEx, sizeof( ParameterEx ) );
offset = GET_OFFSET( ParameterEx, CheckSum );
if( EEPROM_WriteData( EEPROM_PAGE_0 + offset, (uint8_t*)&ParameterEx.CheckSum, sizeof( int8_t ) ) )
stat = TRUE;
if( EEPROM_WriteData( EEPROM_PAGE_1 + offset, (uint8_t*)&ParameterEx.CheckSum, sizeof( int8_t ) ) )
stat = TRUE;
// if( !stat )
// LAMP_DisplayError( Hkz0001_ERROR_EEPROM_WRITE ); // EEPROM書き込みエラー表示
return stat;
}
int check_address(int addr) {
/* If beyond the number of pages */
if( num_pages <= GET_PAGE(addr) ) {
printf("%s: Fault! Invalid Page Reference (%d)!\n", current_ref, GET_PAGE(addr));
return -1;
}
/* If offset is larger than a page */
if( PAGE_SIZE <= GET_OFFSET(addr) ) {
printf("%s: Fault! Invalid Offset (%d)!\n", current_ref, GET_OFFSET(addr));
return -1;
}
return 0;
}
static float m_get_fcell(matrix_t *m, unsigned int row, unsigned int col)
{
if (!m)
return ERROR;
if (row > m->num_rows || col > m->num_cols)
return FAIL;
switch(m->ptype) {
case SHORT:
return (float)m->psdata[GET_OFFSET(row, col, m->num_cols)];
case INT:
return (float)m->pldata[GET_OFFSET(row, col, m->num_cols)];
case FLOAT:
return m->pfdata[GET_OFFSET(row, col, m->num_cols)];
}
}
int acq_SetChannelThreshold(rp_channel_t channel, float voltage)
{
float gainV;
rp_pinState_t gain;
ECHECK(acq_GetGainV(channel, &gainV));
ECHECK(acq_GetGain(channel, &gain));;
if (fabs(voltage) - fabs(gainV) > FLOAT_EPS) {
return RP_EOOR;
}
rp_calib_params_t calib = calib_GetParams();
int32_t dc_offs = GET_OFFSET(channel, gain, calib);
uint32_t calibScale = calib_GetFrontEndScale(channel, gain);
uint32_t cnt = cmn_CnvVToCnt(ADC_BITS, voltage, gainV, gain == RP_HIGH ? false : true, calibScale, dc_offs, 0.0);
// We cut high bits of negative numbers
cnt = cnt & ((1 << ADC_BITS) - 1);
if (channel == RP_CH_1) {
return osc_SetThresholdChA(cnt);
}
else {
return osc_SetThresholdChB(cnt);
}
}
/* Reset the verticalOffset fields in all the bookmarks */
void ResetBookmarkVerticalOffsets( void )
{
UInt8* bookmarkPtr;
MemHandle handle;
UInt16 offset;
Int16 entries;
handle = ReturnMetaHandle( INTERNAL_BOOKMARKS_ID, NO_PARAGRAPHS );
if ( handle == NULL )
return;
bookmarkPtr = MemHandleLock( handle );
offset = GET_OFFSET( bookmarkPtr );
entries = GET_ENTRIES( bookmarkPtr );
while ( entries-- ) {
YOffset verticalOffset;
verticalOffset = NO_VERTICAL_OFFSET;
DmWrite( bookmarkPtr, offset + OFFSETOF( BookmarkData, verticalOffset ),
&verticalOffset, sizeof( YOffset ) );
offset += sizeof( BookmarkData );
}
MemHandleUnlock( handle );
}
WG_PRIVATE gboolean
on_expose(GtkWidget *widget, cairo_t *cr, gpointer data)
{
Gui_display *display = NULL;
Gui_display_line *line = NULL;
Iterator itr;
display = (Gui_display*)data;
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
cairo_paint(cr);
if (display->pixbuf != NULL){
gdk_cairo_set_source_pixbuf(cr,
display->pixbuf,
display->widget_width, display->widget_height);
cairo_paint(cr);
iterator_list_init(&itr, &display->lines,
GET_OFFSET(Gui_display_line, list));
while((line = iterator_list_next(&itr)) != NULL){
paint_line(cr, line);
}
cairo_fill(cr);
}
return TRUE;
}
/* Upgrade bookmarks from the old system to the current bookmark system */
void UpgradeBookmarks( void )
{
MemHandle handle;
UInt8* startBookmarkPtr;
OldBookmarkData* startDataPtr;
UInt8* bookmarkPtr;
UInt16 entries;
Boolean success;
OldBookmarkData* dataPtr;
UInt16 i;
Boolean* done;
handle = ReturnMetaHandle( INTERNAL_BOOKMARKS_ID, NO_PARAGRAPHS );
if ( handle == NULL )
return;
bookmarkPtr = MemHandleLock( handle );
dataPtr = ( OldBookmarkData* )( bookmarkPtr + GET_OFFSET( bookmarkPtr ) );
entries = GET_ENTRIES( bookmarkPtr );
bookmarkPtr += BOOKMARK_HEADER_LEN;
startDataPtr = dataPtr;
startBookmarkPtr = bookmarkPtr;
if ( 0 == entries ) {
MemHandleUnlock( handle );
CloseRecord( handle, true );
DeleteMetaRecord( INTERNAL_BOOKMARKS_ID );
return;
}
success = false;
done = SafeMemPtrNew( sizeof( Boolean ) * entries );
MemSet( done, sizeof( Boolean ) * entries, 0 );
success = true;
for ( i = 0 ; i < entries ; i++ ) {
if ( ! done[ i ] )
success = ConvertBookmarksForRecord( dataPtr->recordId,
startBookmarkPtr, startDataPtr, entries, done ) &&
success;
bookmarkPtr += StrLen( bookmarkPtr ) + 1;
dataPtr++;
}
SafeMemPtrFree( done );
MemHandleUnlock( handle );
CloseRecord( handle, true );
DeleteMetaRecord( INTERNAL_BOOKMARKS_ID );
}
/** チェックサムを有効・無効にする。
* @param flag TRUE:有効、FALSE:無効
**************************************************************************** */
BOOL para_SetCheckSumEnable( BOOL flag )
{
BOOL stat = FALSE;
if( flag )
Parameter.Behavior1 |= BEHAVIOR1_SUM_VALID;
else
Parameter.Behavior1 &= ~BEHAVIOR1_SUM_VALID;
if( EEPROM_WriteData( EEPROM_PAGE_0 + GET_OFFSET( Parameter, Behavior1 ),
(uint8_t*)&Parameter.Behavior1, sizeof( Parameter.Behavior1 ) ) )
stat = TRUE;
if( EEPROM_WriteData( EEPROM_PAGE_1 + GET_OFFSET( Parameter, Behavior1 ),
(uint8_t*)&Parameter.Behavior1, sizeof( Parameter.Behavior1 ) ) )
stat = TRUE;
// if( !stat )
// LAMP_DisplayError( Hkz0001_ERROR_EEPROM_WRITE ); // EEPROM書き込みエラー表示
return stat;
}
static int m_set_fcell(matrix_t *m, unsigned int row, unsigned int col, float new_value)
{
if (!m)
return ERROR;
if (row > m->num_rows || col > m->num_cols)
return FAIL;
switch(m->ptype) {
case SHORT:
m->psdata[GET_OFFSET(row, col, m->num_cols)] = (short) new_value;
break;
case INT:
m->pldata[GET_OFFSET(row, col, m->num_cols)] = (int) new_value;
break;
case FLOAT:
m->pfdata[GET_OFFSET(row, col, m->num_cols)] = new_value;
break;
}
return SUCCESS;
}
// Define equation for pressure at t+1 based on values from vel and pressure at t.
virtual void define(const IntTuple& offsets) {
GET_OFFSET(t);
GET_OFFSET(x);
GET_OFFSET(y);
GET_OFFSET(z);
// start with center value multiplied by coeff 0.
GridValue v = pressure(t, x, y, z) * coeff(0);
// add values from x, y, and z axes multiplied by the
// coeff for the given radius.
for (int r = 1; r <= _order/2; r++) {
// Add values from axes at radius r.
v += (
// x-axis.
pressure(t, x-r, y, z) +
pressure(t, x+r, y, z) +
// y-axis.
pressure(t, x, y-r, z) +
pressure(t, x, y+r, z) +
// z-axis.
pressure(t, x, y, z-r) +
pressure(t, x, y, z+r)
) * coeff(r);
}
// finish equation, including t-1 and velocity components.
v = (2.0 * pressure(t, x, y, z))
- pressure(t-1, x, y, z) // subtract pressure from t-1.
+ (v * vel(x, y, z)); // add v * velocity.
// define the value at t+1 to be equivalent to v.
pressure(t+1, x, y, z) == v;
}
int _option_parse(gnrc_tcp_tcb_t *tcb, tcp_hdr_t *hdr)
{
/* Extract Offset value. Return if no options are set */
uint8_t offset = GET_OFFSET(byteorder_ntohs(hdr->off_ctl));
if (offset <= TCP_HDR_OFFSET_MIN) {
return 0;
}
/* Get Pointer to option field and field-size */
uint8_t *opt_ptr = (uint8_t *) hdr + sizeof(tcp_hdr_t);
uint8_t opt_left = (offset - TCP_HDR_OFFSET_MIN) * 4;
/* Parse Options via tcp_hdr_opt_t */
while (opt_left > 0) {
tcp_hdr_opt_t *option = (tcp_hdr_opt_t *) opt_ptr;
/* Examine current option */
switch (option->kind) {
case TCP_OPTION_KIND_EOL:
DEBUG("gnrc_tcp_option.c : _option_parse() : EOL option found\n");
return 0;
case TCP_OPTION_KIND_NOP:
DEBUG("gnrc_tcp_option.c : _option_parse() : NOP option found\n");
opt_ptr += 1;
opt_left -= 1;
continue;
case TCP_OPTION_KIND_MSS:
if (option->length != TCP_OPTION_LENGTH_MSS) {
DEBUG("gnrc_tcp_option.c : _option_parse() : invalid MSS Option length.\n");
return -1;
}
tcb->mss = (option->value[0] << 8) | option->value[1];
DEBUG("gnrc_tcp_option.c : _option_parse() : MSS option found. MSS=%"PRIu16"\n",
tcb->mss);
break;
default:
DEBUG("gnrc_tcp_option.c : _option_parse() : Unknown option found.\
KIND=%"PRIu8", LENGTH=%"PRIu8"\n", option->kind, option->length);
}
opt_ptr += option->length;
opt_left -= option->length;
}
return 0;
}
/**
* @brief Clean all lines
*
* @param display gui_display instance
*
* @retval WG_SUCCESS
* @retval WG_FAILURE
*/
wg_status
gui_display_clean_lines(Gui_display *display)
{
Iterator itr;
Gui_display_line *line = NULL;
iterator_list_init(&itr, &display->lines,
GET_OFFSET(Gui_display_line, list));
while((line = iterator_list_next(&itr)) != NULL){
WG_FREE(line);
}
list_init(&display->lines);
return WG_SUCCESS;
}
//transfrom domain from lenlabel format to string
int
get_domain_from_msg(uchar * itor, uchar * hdr, uchar * to, int *tmplen)
{
uchar len;
ushort offset = 0;
len = itor[0];
int dlen = 0;
int hasptr = 0, infinite = 20;
offset = ntohs((ushort) * (ushort *) itor);
*tmplen = 0;
while ((len != 0) && (infinite--)) {
if (IS_PTR(offset)) {
itor = hdr + GET_OFFSET(offset);
if (hasptr == 0) {
dlen = 2;
if (*tmplen != 0)
dlen += *tmplen;
}
hasptr = 1;
offset = ntohs((ushort) * (ushort *) itor);
continue;
}
to[0] = itor[0];
*tmplen += 1; //len
*tmplen += to[0]; //label
if (to[0] > 64)
return -1;
to++;
memcpy(to, itor + 1, itor[0]);
to += itor[0];
itor = itor + itor[0] + 1;
len = itor[0];
offset = ntohs((ushort) * (ushort *) itor);
}
if (infinite <= 0) //loops error
return -1;
to[0] = 0;
to++;
(*tmplen)++;
if (dlen == 0)
dlen = *tmplen; //root len is 1
if (dlen > MAX_DOMAIN_LEN)
return -1;
return dlen;
}
void *CarveMapIndex( carve_t cv, void *aindex )
/*********************************************/
{
unsigned index = (unsigned)(pointer_int)aindex;
blk_t * block;
blk_t ** block_map;
unsigned block_index;
unsigned block_offset;
/* given an index; find and allocate the carve element */
if( index == CARVE_NULL_INDEX ) {
return( NULL );
}
block_index = GET_BLOCK( index );
block_offset = GET_OFFSET( index );
block_map = cv->blk_map;
block = block_map[ block_index - 1 ];
return( &(block->data[ block_offset ]) );
}
/* Restore data for current bookmark, return the record ID or if
there are no bookmarks NO_RECORD */
UInt16 RestoreBookmarkData
(
UInt16 index /* index in bookmarks list */
)
{
MetaRecord* meta;
BookmarkData bookmarkData;
UInt8* bookmarkPtr;
MemHandle handle;
UInt16 offset;
handle = ReturnMetaHandle( INTERNAL_BOOKMARKS_ID, NO_PARAGRAPHS );
if ( handle == NULL )
return NO_RECORD;
bookmarkPtr = MemHandleLock( handle );
offset = GET_OFFSET( bookmarkPtr );
bookmarkPtr += offset + index * sizeof( BookmarkData );
MemMove( &bookmarkData, bookmarkPtr, sizeof( BookmarkData ) );
meta = MemHandleLock( GetMetaHandle( bookmarkData.recordId, false ) );
DmWrite( meta, OFFSETOF( MetaRecord, verticalOffset ), &bookmarkData,
sizeof( BookmarkData ) - sizeof( UInt16 ) );
/* Add to history */
AddToHistory( bookmarkData.recordId );
SetHistoryFirstParagraph( bookmarkData.firstVisibleParagraph,
bookmarkData.firstParagraphY );
#ifdef STORE_LAST_VISIBLE
SetHistoryLastParagraph( bookmarkData.lastVisibleParagraph,
bookmarkData.lastParagraphY );
#endif
SetHistoryVerticalOffset( bookmarkData.verticalOffset );
SetHistoryCharacterPosition( bookmarkData.characterPosition );
MemPtrUnlock( meta );
MemHandleUnlock( handle );
return bookmarkData.recordId;
}
// Get the real address in order to apply some read, write
// or execute action on it.
// access is either RD, RW, or EX.
// Returns a pointer or NULL if it fails.
void* accesPhysicalAddress(address virt, char access){
void* realAddr = NULL;
int addrInVirtRam = 0;
int index = GET_INDEX(virt);
int offset = GET_OFFSET(virt);
if(DECODE_PROTECTION(pageTable[index]) == access){
if(IS_VALID(pageTable[index])){
addrInVirtRam = (int)(pageTable[index] & 0b11111) * 0x1000;
addrInVirtRam = (int)(DECODE_PAGENB(pageTable[index])) * 0x1000;
realAddr = beginOfMem + addrInVirtRam + offset;
}
else{
// Page fault
}
}
else{
// Access denied
// traps
}
return realAddr;
}
int emi_msg_read_ret(struct sk_dpr *sd, struct emi_msg *msg){
if (emi_msg_read_payload(sd, msg)){
return -1;
}
emilog(EMI_DEBUG, "Read with retdata, retsize %d\n", msg->retsize);
if (msg->retsize > 0) {
void *data = (char *)malloc(msg->retsize);
if(data == NULL){
return -1;
}
msg->retdata_offset = GET_OFFSET(msg, data);
if (emi_msg_read_retdata(sd, msg)) {
emi_msg_free_data(msg);
return -1;
}
}
return 0;
}
int acq_GetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)
{
*size = MIN(*size, ADC_BUFFER_SIZE);
float gainV;
rp_pinState_t gain;
ECHECK(acq_GetGainV(channel, &gainV));
ECHECK(acq_GetGain(channel, &gain));
rp_calib_params_t calib = calib_GetParams();
int32_t dc_offs = GET_OFFSET(channel, gain, calib);
uint32_t calibScale = calib_GetFrontEndScale(channel, gain);
const volatile uint32_t* raw_buffer = getRawBuffer(channel);
uint32_t cnts;
for (uint32_t i = 0; i < (*size); ++i) {
cnts = raw_buffer[(pos + i) % ADC_BUFFER_SIZE];
buffer[i] = cmn_CnvCntToV(ADC_BITS, cnts, gainV, calibScale, dc_offs, 0.0);
}
return RP_OK;
}
int acq_GetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)
{
*size = MIN(*size, ADC_BUFFER_SIZE);
uint32_t cnts;
const volatile uint32_t* raw_buffer = getRawBuffer(channel);
rp_pinState_t gain;
ECHECK(acq_GetGain(channel, &gain));
rp_calib_params_t calib = calib_GetParams();
int32_t dc_offs = GET_OFFSET(channel, gain, calib);
for (uint32_t i = 0; i < (*size); ++i) {
cnts = (raw_buffer[(pos + i) % ADC_BUFFER_SIZE]) & ADC_BITS_MAK;
buffer[i] = cmn_CalibCnts(ADC_BITS, cnts, dc_offs);
}
return RP_OK;
}
int acq_GetChannelThresholdHyst(rp_channel_t channel, float* voltage)
{
float gainV;
rp_pinState_t gain;
uint32_t cnts;
if (channel == RP_CH_1) {
ECHECK(osc_GetHysteresisChA(&cnts));
}
else {
ECHECK(osc_GetHysteresisChB(&cnts));
}
ECHECK(acq_GetGainV(channel, &gainV));
ECHECK(acq_GetGain(channel, &gain));
rp_calib_params_t calib = calib_GetParams();
int32_t dc_offs = GET_OFFSET(channel, gain, calib);
uint32_t calibScale = calib_GetFrontEndScale(channel, gain);
*voltage = cmn_CnvCntToV(ADC_BITS, cnts, gainV, calibScale, dc_offs, 0.0);
return RP_OK;
}
int acq_SetChannelThresholdHyst(rp_channel_t channel, float voltage)
{
float gainV;
rp_pinState_t gain;
acq_GetGainV(channel, &gainV);
acq_GetGain(channel, &gain);
if (fabs(voltage) - fabs(gainV) > FLOAT_EPS) {
return RP_EOOR;
}
rp_calib_params_t calib = calib_GetParams();
int32_t dc_offs = GET_OFFSET(channel, gain, calib);
uint32_t calibScale = calib_GetFrontEndScale(channel, gain);
uint32_t cnt = cmn_CnvVToCnt(ADC_BITS, voltage, gainV, gain == RP_HIGH ? false : true, calibScale, dc_offs, 0.0);
if (channel == RP_CH_1) {
return osc_SetHysteresisChA(cnt);
}
else {
return osc_SetHysteresisChB(cnt);
}
}
/********************** ************************/
int main(int argc,char *argv[]) {
int n_pages = 0;
//int n_frames = 0;
ram_info_t ram_info;//
ram_info.n_frames = 0;//
ram_info.algorithm = NULL;//
int n_cache = 0;
int n_tlb = 0;
char *access_file = NULL;
FILE *access_fd = NULL;
addr_t virtual_addr = 0;
addr_t physical_addr;
pid_t pid = 0;
char mode;
/*
* Parse arguments
*/
if( 0 != parse_args(argc, argv, &access_file, &n_pages, &ram_info.n_frames, &n_cache, &n_tlb, &ram_info.algorithm) ) {//
return -1;
}
/*
* Setup data structures
*/
srand(time(NULL));
current_ref = (char *)malloc(sizeof(char) * MAX_LINE);
clear_stats();
stats.cache_size = n_cache;
stats.tlb_size = n_tlb;
stats.num_pages = n_pages;
stats.num_frames = ram_info.n_frames;//
printf("Allocating resources...\n");
allocate_cache(n_cache);
allocate_tlb(n_tlb);
allocate_page_table(n_pages);
allocate_page_directory(n_pages);
//allocate_ram(n_frames);
allocate_ram(ram_info);
/*
* Open the file that we are going to read
*/
if( NULL == (access_fd = fopen(access_file, "r") ) ) {
fprintf(stderr, "Error: Unable to open the access file <%s>\n", access_file);
return -1;
}
/*
* Read page requests from the file
*/
gettimeofday(&stats.start, NULL);
while(0 == feof(access_fd) ) {
/* Read one line */
current_ref[0] = '\0';
if( NULL == fgets(current_ref, MAX_LINE, access_fd) ) {
break;
}
/* Strip off the newline */
if( '\n' == current_ref[strlen(current_ref)-1] ) {
current_ref[strlen(current_ref)-1] = '\0';
}
extract_args(current_ref, &pid, &mode, &virtual_addr);
/*
* Memory management operations to access the page
*/
if(VERBOSE){
printf("-----------------------------------------------------------\n");
printf("%s: Process %*d \t Access [Page %4d, Offset %#05x] (%#010x)\n",
current_ref,
MAX_PID_LEN, pid,
GET_PAGE(virtual_addr), GET_OFFSET(virtual_addr), virtual_addr);
}
access_page(pid, mode, virtual_addr, &physical_addr);
if(VERBOSE){
printf("%s: Process %*d \t Access [Page %4d, Offset %#05x] (%#010x) --> (%#010x) [Frame %4d, Offset %#05x]\n",
current_ref,
MAX_PID_LEN, pid,
GET_PAGE(virtual_addr), GET_OFFSET(virtual_addr), virtual_addr,
physical_addr, GET_FRAME(physical_addr), GET_OFFSET(physical_addr));
}
}
gettimeofday(&stats.end, NULL);
display_stats();
/*
* Cleanup
*/
fclose(access_fd);
if( NULL != current_ref ) {
free(current_ref);
current_ref = NULL;
}
free_ram();
free_page_dir();
free_tlb();
free_cache();
return 0;
}
static int
nandsim_read(nand_device_t ndev, size_t len, uint8_t *data)
{
off_t real_address;
int i;
/*
* We are attempring to read the status,
* don't touch the state except on failure
*/
if (nand_chip.read_status != 0) {
if (len != 1) {
RESET_STATE();
return (EIO);
}
nand_chip.read_status = 0;
data[0] = NAND_STATUS_WP;
if (nand_chip.incmd == 0 && nand_chip.inaddr == 0 &&
nand_chip.inread == 0 && nand_chip.inwrite == 0)
data[0] |= NAND_STATUS_RDY | NAND_STATUS_ARDY;
return (0);
}
if (nand_chip.inread == 0) {
printf("NANDSIM: nandsim_read: "
"Attempting to read when we can't read\n");
RESET_STATE();
return (EIO);
}
CLEAR_IN_STATE();
switch(nand_chip.cmd[0]) {
case NAND_CMD_READID:
switch(nand_chip.address) {
case NAND_READID_MANFID:
/* Read the Manufacturer ID */
if (nand_chip.data_pos > 1) {
printf("NANDSIM: nandsim_read: "
"Too much data have already been read\n");
RESET_STATE();
return (EIO);
} else if (len > 0) {
if (nand_chip.data_pos == 0) {
data[0] = nand_chip.manuf;
if (len > 1)
data[1] = nand_chip.device;
} else if (nand_chip.data_pos == 1)
data[0] = nand_chip.device;
printf("NANDSIM: nandsim_read: Read chip ID (");
for (i = 0; i < len; i++) {
printf("%.2X", data[i]);
if (i != len - 1)
printf(" ");
}
printf(")\n");
} else {
printf("NANDSIM: nandsim_read: "
"Read chip ID length too short\n");
RESET_STATE();
return (EIO);
}
break;
default:
printf("NANDSIM: nandsim_read: "
"Unknown or unimplemented address %X "
"after NAND_READID_MANFID\n", nand_chip.address);
RESET_STATE();
return (EIO);
}
RESET_STATE();
nand_chip.inread = 1;
break;
case NAND_CMD_READ:
switch(ndev->ndev_cell_size) {
case 8:
case 16:
printf("NANDSIM: nandsim_read: Read page %X\n",
nand_chip.address);
/* Copy the data to NAND */
GET_OFFSET(real_address, len);
printf("NANDSIM: nandsim_read: Reading offset %X\n",
(unsigned int)real_address);
/* The length is in terms of ndev->ndi_cell_size bits */
len = len * ndev->ndev_cell_size / 8;
memcpy(data, &nand_chip.data[real_address], len);
break;
default:
printf("NANDSIM: nandsim_read: Unknown bus width %d\n",
ndev->ndev_cell_size);
RESET_STATE();
return (EIO);
}
RESET_STATE();
break;
default:
printf("NANDSIM: nandsim_read: Unknown command:");
for (i = 0; i < nand_chip.cmd_len; i++)
printf(" %.2X", nand_chip.cmd[i]);
printf("\n");
RESET_STATE();
return (EIO);
}
nand_chip.data_pos += len;
CHECK_STATE();
return (0);
}
ULONG kernel_patchimport(PPROCESS_ENV pProcEnv){
ULONG rl;
ULONG index;
FUNC_ZwQueryInformationProcess ZwQueryInformationProcess;
PROCESS_BASIC_INFORMATION PBI;
PEB peb;
IMAGE_DOS_HEADER IDH;
IMAGE_NT_HEADERS INH;
PVOID AddrIID;
ULONG NumIID;
IMAGE_IMPORT_DESCRIPTOR IID;
IMPORT_ENTRY IE;
PVOID rIE;
PVOID newAddrIID;
PVOID AddrPatch;
ULONG PatchVA;
ZwQueryInformationProcess=(FUNC_ZwQueryInformationProcess)GetProcAddress(GetModuleHandle(L"ntdll.dll"),"ZwQueryInformationProcess");
ZwQueryInformationProcess(pProcEnv->hProc,ProcessBasicInformation,&PBI,sizeof(PROCESS_BASIC_INFORMATION),&rl);
ReadProcessMemory(pProcEnv->hProc,PBI.PebBaseAddress,&peb,sizeof(PEB),&rl);
ReadProcessMemory(pProcEnv->hProc,peb.ImageBaseAddress,&IDH,sizeof(IMAGE_DOS_HEADER),&rl);
ReadProcessMemory(pProcEnv->hProc,peb.ImageBaseAddress+IDH.e_lfanew,&INH,sizeof(IMAGE_NT_HEADERS),&rl);
AddrIID=peb.ImageBaseAddress+INH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
NumIID=0;
while(TRUE){
ReadProcessMemory(pProcEnv->hProc,AddrIID,&IID,sizeof(IMAGE_IMPORT_DESCRIPTOR),&rl);
NumIID++;
if(IID.OriginalFirstThunk==0){
break;
}
AddrIID+=sizeof(IMAGE_IMPORT_DESCRIPTOR);
}
strcpy(IE.Name,HOOKDLL_NAME);
IE.OriginalFirstThunk.u1.Ordinal=IMAGE_ORDINAL_FLAG32 | 1;
IE.FirstThunk.u1.Ordinal=IMAGE_ORDINAL_FLAG32 | 1;
rIE=VirtualAllocEx(pProcEnv->hProc,NULL,sizeof(IMPORT_ENTRY),MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
WriteProcessMemory(pProcEnv->hProc,rIE,&IE,sizeof(IMPORT_ENTRY),&rl);
newAddrIID=VirtualAllocEx(pProcEnv->hProc,NULL,sizeof(IMAGE_IMPORT_DESCRIPTOR)*(NumIID+1),MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
PatchVA=(ULONG)newAddrIID-(ULONG)peb.ImageBaseAddress;
IID.Name=((ULONG)rIE-(ULONG)peb.ImageBaseAddress)+GET_OFFSET(IE,Name);
IID.OriginalFirstThunk=((ULONG)rIE-(ULONG)peb.ImageBaseAddress)+GET_OFFSET(IE,OriginalFirstThunk);
IID.FirstThunk=((ULONG)rIE-(ULONG)peb.ImageBaseAddress)+GET_OFFSET(IE,FirstThunk);
IID.TimeDateStamp=0;
IID.ForwarderChain=0;
WriteProcessMemory(pProcEnv->hProc,newAddrIID,&IID,sizeof(IMAGE_IMPORT_DESCRIPTOR),&rl);
newAddrIID+=sizeof(IMAGE_IMPORT_DESCRIPTOR);
AddrIID=peb.ImageBaseAddress+INH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
for(index=0;index<NumIID;index++){
ReadProcessMemory(pProcEnv->hProc,AddrIID,&IID,sizeof(IMAGE_IMPORT_DESCRIPTOR),&rl);
WriteProcessMemory(pProcEnv->hProc,newAddrIID,&IID,sizeof(IMAGE_IMPORT_DESCRIPTOR),&rl);
newAddrIID+=sizeof(IMAGE_IMPORT_DESCRIPTOR);
AddrIID+=sizeof(IMAGE_IMPORT_DESCRIPTOR);
}
AddrPatch=peb.ImageBaseAddress+IDH.e_lfanew+GET_OFFSET(INH,OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
VirtualProtectEx(pProcEnv->hProc,AddrPatch,4,PAGE_READWRITE,&rl);
WriteProcessMemory(pProcEnv->hProc,AddrPatch,&PatchVA,4,&rl);
return 0;
}
static int
nandsim_write(nand_device_t ndev, size_t len, uint8_t *data)
{
off_t real_address;
int i;
CLEAR_IN_STATE();
if (nand_chip.inwrite == 0) {
printf("NANDSIM: nandsim_read: "
"Attempting to write when we can't write\n");
RESET_STATE();
return (EIO);
}
switch (nand_chip.cmd[0]) {
case NAND_CMD_PROGRAM:
switch(ndev->ndev_cell_size) {
case 8:
case 16:
GET_OFFSET(real_address, len);
printf("NANDSIM: nandsim_write: "
"Programming offset %X\n",
(unsigned int)real_address);
/*
* The length is in terms of ndev->ndev_width bits.
* Adjust the length to be in terms of 8 bits.
*/
len = len * ndev->ndev_cell_size / 8;
/*
* Iterate through each byte anding in the new
* data to ensure we only move from 1 -> 0
*/
for (i = 0; i < len; i++) {
nand_chip.data[real_address + i] &= data[i];
}
RESET_STATE();
break;
default:
printf("NANDSIM: nandsim_write: "
"Write of unknown bus width %d\n",
ndev->ndev_cell_size);
RESET_STATE();
return (EIO);
}
break;
default:
printf("NANDSIM: nandsim_write: Unknown command:");
for (i = 0; i < nand_chip.cmd_len; i++)
printf(" %.2X", nand_chip.cmd[i]);
printf("\n");
RESET_STATE();
return (EIO);
}
CHECK_STATE();
return (0);
}
void
initVirAddr(icp_firml_handle_t * handle)
{
unsigned int cap_offset, ae_offset;
unsigned int pmu_offset, scratch_offset, ssu_offset, ep_offset;
GET_OFFSET(handle->sysMemInfo.deviceId, cap_offset, ae_offset,
pmu_offset, scratch_offset, ssu_offset, ep_offset);
if(handle->Hal_dram_ch0_virtAddr == 0 )
{
handle->Hal_dram_ch0_virtAddr =
handle->sysMemInfo.dramDesc[0].dramBaseAddr_v;
}
if(handle->Hal_dram_ch1_virtAddr == 0 )
{
handle->Hal_dram_ch1_virtAddr =
handle->sysMemInfo.dramDesc[1].dramBaseAddr_v;
}
if(handle->Hal_sram_virtAddr == 0 )
{
handle->Hal_sram_virtAddr =
handle->sysMemInfo.sramDesc.sramBaseAddr_v;
}
if(handle->Hal_cap_global_ctl_csr_virtAddr == 0 )
{
handle->Hal_cap_global_ctl_csr_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
cap_offset);
}
if(handle->Hal_cap_ae_xfer_csr_virtAddr == 0 )
{
handle->Hal_cap_ae_xfer_csr_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
ae_offset);
}
if(handle->Hal_cap_ae_local_csr_virtAddr == 0 )
{
handle->Hal_cap_ae_local_csr_virtAddr =
SADD(handle->Hal_cap_ae_xfer_csr_virtAddr,
LOCAL_TO_XFER_REG_OFFSET);
}
/* to be initialized later while icp_hal_debug.ko is loaded */
if(handle->Hal_cap_pmu_csr_virtAddr == 0 )
{
if(handle->sysMemInfo.deviceId == ICP_ACCELCOMP_R_PCIE_DEVICE_ID_AC)
{
handle->Hal_cap_pmu_csr_virtAddr = 0;
}
else
{
handle->Hal_cap_pmu_csr_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
pmu_offset);
}
}
if(handle->Hal_cap_hash_csr_virtAddr == 0 )
{
handle->Hal_cap_hash_csr_virtAddr =
SADD(handle->Hal_cap_global_ctl_csr_virtAddr,
HASH_TO_GLOBAL_REG_OFFSET);
}
if(handle->Hal_scratch_rd_wr_swap_virtAddr == 0 )
{
if((handle->sysMemInfo.deviceId ==
ICP_ACCELCOMP_R_PCIE_DEVICE_ID_AC) ||
(handle->sysMemInfo.deviceId ==
ICP_ACCELCOMP_B_PCIE_DEVICE_ID_AC) ||
(handle->sysMemInfo.deviceId ==
ICP_ACCELCOMP_RS_PCIE_DEVICE_ID_AC))
{
handle->Hal_scratch_rd_wr_swap_virtAddr = 0;
}
else
{
handle->Hal_scratch_rd_wr_swap_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
scratch_offset);
}
}
handle->Hal_ae_fastaccess_csr_virtAddr = 0;
if(handle->Hal_ssu_csr_virtAddr == 0 )
{
handle->Hal_ssu_csr_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
ssu_offset);
}
if(handle->Hal_ep_csr_virtAddr == 0 )
{
handle->Hal_ep_csr_virtAddr =
SADD(handle->sysMemInfo.pciBars[ICP_AC_PMISC_BAR].virtAddr,
ep_offset);
}
if(handle->Hal_eagletail_ring_csr_virtAddr == 0 )
{
handle->Hal_eagletail_ring_csr_virtAddr =
handle->sysMemInfo.pciBars[ICP_AC_PETRINGCSR_BAR].virtAddr;
}
}
/*********************************************************
* Core Memory Management Operation
*********************************************************/
static int access_page(pid_t pid, char mode, addr_t address, addr_t *physical_addr) {
frame_t frame;
int ret;
/*
* Check for a context switch
*/
if(last_pid != pid ) {
last_pid = pid;
stats.num_context_switch++;
//stats.num_procs++;
stats.pid_list[stats.num_procs++] = pid;
}
/*
* Check for valid page reference
*/
if( 0 != check_address(address) ) {
/*printf("%s: Fault! Invalid Address Reference!\n", current_ref);*/
stats.num_errors++;
return -1;
}
/*
* Check the Cache
* - Success: Load page!
* - Failure: Check TLB
* Return:
* > 0: Resolved in cache
* = 0: Not resolved in cache
* < 0: Error!
*/
ret = check_cache(pid, mode, address, &frame);
if( ret < 0 ) {
fprintf(stderr, "Error: Cache lookup failed!\n");
stats.num_errors++;
return -1;
}
else if( ret > 0 ) {
/*printf("%s: Cache Hit!\n", current_ref);*/
stats.cache_hit++;
*physical_addr = frame*PAGE_SIZE + GET_OFFSET(address);
return 0;
}
stats.cache_miss++;
printf("%s: Cache Miss...\n", current_ref);
/*
* Check the TLB
* - Success: Access page from RAM, update cache
* - Failure: Look in Page Table
*
* Return:
* > 0: Resolved in TLB
* = 0: Not resolved in TLB
* < 0: Error!
*/
ret = check_tlb(pid, mode, address, &frame);
if( ret < 0 ) {
fprintf(stderr, "Error: TLB lookup failed!\n");
stats.num_errors++;
return -1;
}
else if( ret > 0 ) {
printf("%s: TLB Hit!\n", current_ref);
stats.tlb_hit++;
*physical_addr = frame*PAGE_SIZE + GET_OFFSET(address);
return 0;
}
stats.tlb_miss++;
printf("%s: TLB Miss...\n", current_ref);
/*
* Check the Page Table
* - In RAM:
* - Access Page from RAM
* - Update TLB, Cache
* - In Swap:
* - Find a frame to replace
* - Page-Fault
* - Update Page Table
* - Update TLB, Cache
*/
//ret = check_page_table(pid, mode, address, &frame);
ret = check_page_dir(pid, mode, address, &frame);
if( ret < 0 ) {
fprintf(stderr, "Error: Page Table lookup failed!\n");
stats.num_errors++;
return -1;
}
else if( ret > 0 ) {
*physical_addr = frame*PAGE_SIZE + GET_OFFSET(address);
return 0;
}
fprintf(stderr, "%s: Error: Page Table Miss! This should never happen\n", current_ref);
exit(-1);
return -1;
}
/* Delete bookmark, return true if list is empty */
void DeleteBookmark
(
UInt16 index /* index in bookmarks list */
)
{
BookmarkData bookmarkData;
MemHandle handle;
UInt16 entries;
UInt16 offset;
UInt16 tempOffset;
UInt16 newSize;
UInt16 nameLength;
UInt16 i;
UInt8* bookmarkPtr;
UInt8* readPtr;
handle = ReturnMetaHandle( INTERNAL_BOOKMARKS_ID, NO_PARAGRAPHS );
if ( handle == NULL )
return;
bookmarkPtr = MemHandleLock( handle );
entries = GET_ENTRIES( bookmarkPtr );
if ( entries <= 1 ) {
MemHandleUnlock( handle );
ReleaseBookmarkList();
RemoveBookmarkRecord();
return;
}
/* Find name string for bookmark */
readPtr = bookmarkPtr + BOOKMARK_HEADER_LEN;
for ( i = 0; i < index; i++ )
readPtr += StrLen( readPtr ) + 1;
tempOffset = readPtr - bookmarkPtr;
nameLength = StrLen( readPtr ) + 1;
readPtr += nameLength;
for ( i = 0; i < entries - index - 1; i++ ) {
UInt16 length;
Char tempString[ MAX_BOOKMARK_LEN + 1 ];
MemMove( tempString, readPtr, StrLen( readPtr ) + 1 );
length = StrLen( tempString ) + 1;
DmWrite( bookmarkPtr, tempOffset, tempString, length );
tempOffset += length;
readPtr += length;
}
/* Reshuffle blocks with bookmark data */
offset = GET_OFFSET( bookmarkPtr );
readPtr = bookmarkPtr + offset;
for ( i = 0; i < index; i++ ) {
MemMove( &bookmarkData, readPtr, sizeof( BookmarkData ) );
DmWrite( bookmarkPtr, tempOffset, &bookmarkData,
sizeof( BookmarkData ) );
tempOffset += sizeof( BookmarkData );
readPtr += sizeof( BookmarkData );
}
readPtr += sizeof( BookmarkData );
for ( i = index + 1; i < entries; i++ ) {
MemMove( &bookmarkData, readPtr, sizeof( BookmarkData ) );
DmWrite( bookmarkPtr, tempOffset, &bookmarkData,
sizeof( BookmarkData ) );
tempOffset += sizeof( BookmarkData );
readPtr += sizeof( BookmarkData );
}
entries--;
DmWrite( bookmarkPtr, sizeof( UInt16 ), &entries, sizeof( UInt16 ) );
offset -= nameLength;
DmWrite( bookmarkPtr, 2 * sizeof( UInt16 ), &offset, sizeof( UInt16 ) );
newSize = MemHandleSize( handle ) - sizeof( BookmarkData ) - nameLength;
MemHandleUnlock( handle );
ResizeMetaRecord( INTERNAL_BOOKMARKS_ID, newSize, &handle );
}
/* Add data for bookmark */
void AddBookmark
(
Char* name /* name of bookmark */
)
/* THROWS */
{
MetaRecord* meta;
BookmarkData bookmarkData;
UInt8* bookmarkPtr;
MemHandle handle;
UInt32 endOfRecord;
UInt16 entries;
UInt16 offset;
UInt16 newSize;
UInt16 nameLength;
UInt16 i;
THROW_IF( name == NULL || *name == '\0', errNoBookmarkName );
handle = ReturnMetaHandle( INTERNAL_BOOKMARKS_ID, NO_PARAGRAPHS );
if ( handle == NULL )
AddBookmarkRecord( &handle );
endOfRecord = MemHandleSize( handle );
TrimText( name, BOOKMARKLISTWIDTH );
nameLength = StrLen( name ) + 1;
newSize = endOfRecord + sizeof( BookmarkData ) + nameLength;
ResizeMetaRecord( INTERNAL_BOOKMARKS_ID, newSize, &handle );
bookmarkPtr = MemHandleLock( handle );
entries = GET_ENTRIES( bookmarkPtr ) + 1;
offset = GET_OFFSET( bookmarkPtr ) + nameLength;
DmWrite( bookmarkPtr, sizeof( UInt16 ), &entries, sizeof( UInt16 ) );
DmWrite( bookmarkPtr, 2 * sizeof( UInt16 ), &offset, sizeof( UInt16 ) );
meta = MemHandleLock( GetMetaRecord() );
bookmarkData.verticalOffset = meta->verticalOffset;
bookmarkData.characterPosition = meta->characterPosition;
bookmarkData.firstVisibleParagraph = meta->firstVisibleParagraph;
bookmarkData.firstParagraphY = meta->firstParagraphY;
#ifdef STORE_LAST_VISIBLE
bookmarkData.lastVisibleParagraph = meta->lastVisibleParagraph;
bookmarkData.lastParagraphY = meta->lastParagraphY;
#endif
bookmarkData.recordId = GetHistoryCurrent();
/* Write new block of bookmark data */
DmWrite( bookmarkPtr, endOfRecord + nameLength, &bookmarkData,
sizeof( BookmarkData ) );
endOfRecord -= sizeof( BookmarkData );
/* Reshuffle old blocks with bookmark data */
for ( i = 1; i < entries; i++ ) {
MemMove( &bookmarkData, bookmarkPtr + endOfRecord,
sizeof( BookmarkData ) );
DmWrite( bookmarkPtr, endOfRecord + nameLength, &bookmarkData,
sizeof( BookmarkData ) );
endOfRecord -= sizeof( BookmarkData );
}
/* Write new bookmark name */
DmStrCopy( bookmarkPtr, offset - nameLength, name );
MemHandleUnlock( GetMetaRecord() );
MemHandleUnlock( handle );
}
