nikto_b/hmmmm
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Add write-after-cycles, reset handling

Browse Source
This commit is contained in:
root
2026-04-16 15:37:32 +03:00
parent b5a4fdf755
commit c907d45763
20 changed files with 756 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -11,7 +11,7 @@ LIBS_HEADERS=deps/ $(OPENSSL_INCLUDE)
SYSTEM_INCLUDES=-isystem deps/flatcc/include/ -isystem $(PROTO_INC_DIR)/
STATIC_LIBS=crypto
STANDART=c23
OPTIMIZE=-O3
OPTIMIZE=-Og
TARGET=main
FLATCC = deps/flatcc/bin/flatcc

35
devices/avr_generic/inc/instr.h
View File

@@ -20,7 +20,7 @@
#elif OPCODE_WORDSIZE == 4
typedef uint32_t opcode_t;
#else
#error OPCODE_WORDSIZE must be one of 1,2,3,
#error OPCODE_WORDSIZE must be one of 1,2,3,4
#endif
@@ -69,37 +69,4 @@ opcode_t extractOpcode(device_mem_t* devMem, prog_counter_t programCounter);
#define READ_MEM(__tgt, __mem, __segno, __addr, __cell_t) \
{\
uint64_t __globalAddr = __mem->memsegShifts[__segno] + __addr; \
if (__mem->smartAddrReadHandlers[__globalAddr].func != NULL) \
{ \
__tgt = *(__cell_t*)__mem->smartAddrReadHandlers[__globalAddr].func(__mem->smartAddrReadHandlers[__globalAddr].ident, __addr, __mem->rawCells + __mem->memsegShifts[__segno]); \
} \
else \
{ \
__tgt = ((__cell_t*)__mem->cells[__segno])[__addr]; \
} \
__mem->memreadCellAddrs[__mem->memreadLen] = __globalAddr; \
__mem->memreadLen += 1; \
}
#define WRITE_MEM(__mem, __segno, __addr, __cell_t, __val) \
{ \
uint64_t __globalAddr = __mem->memsegShifts[__segno] + __addr; \
if (__mem->smartAddrWriteHandlers[__globalAddr].func != NULL) \
{ \
__cell_t __dat = (__cell_t)(__val); \
__mem->smartAddrWriteHandlers[__globalAddr].func(__mem->smartAddrWriteHandlers[__globalAddr].ident, __addr, __mem->rawCells + __mem->memsegShifts[__segno], (void*)&__dat); \
} \
else \
{ \
((__cell_t*)__mem->cells[__segno])[__addr] = (__cell_t)(__val); \
} \
__mem->memwriteCellAddrs[__mem->memwriteLen] = __globalAddr; \
__mem->memwriteLen += 1; \
}
#endif // ifndef __INSTR_H__

538
devices/avr_generic/src/device.c
View File

@@ -1,8 +1,12 @@
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "device.h"
#include "libhmmmm/mem.h"
#include "mem.h"
#include "mem_seg.h"
#include "runner.h"
#include "instr.h"
#include "addrs.h"
@@ -10,21 +14,26 @@
uint64_t memSegToGlobal(device_specs_t* spec, uint8_t seg, uint64_t localaddr)
{
uint64_t offset = 0;
for (uint8_t i = 0; i < seg; i++)
{
offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
}
return offset + localaddr;
// uint64_t offset = 0;
// for (uint8_t i = 0; i < seg; i++)
// {
// offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
// }
return spec->memSpecs[seg]->start + localaddr;
}
void freeDevMem(device_mem_t* devMem)
{
free(devMem->memsegShifts);
free(devMem->memsegSizes);
free(devMem->rawCells);
free(devMem->memreadCellAddrs);
free(devMem->memwriteCellAddrs);
free(devMem->memwriteCellSegments);
free(devMem->memwriteValues[0]);
free(devMem->memwriteValues);
free(devMem->memwriteWordLengths);
free(devMem->cells);
free(devMem->smartAddrReadHandlers);
free(devMem->smartAddrWriteHandlers);
@@ -46,13 +55,7 @@ void freeDevSpec(void* _specs)
device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
{
if (devSpec->memSpecsCount < MEMDATA_OPSIZE)
{
sprintf(errbuf, "invalid amount of mem specs: %u", devSpec->memSpecsCount);
return NULL;
}
device_mem_t* devMem = (device_mem_t*)malloc(sizeof(device_mem_t));
device_mem_t* devMem = (device_mem_t*)calloc(1, sizeof(device_mem_t));
if (devMem == NULL)
{
sprintf(errbuf, "unable to allocate dev memory struct");
@@ -62,14 +65,14 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
uint64_t memTotalSize = 0;
for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
{
size_t tmp = devSpec->memSpecs[i]->start + devSpec->memSpecs[i]->len * devSpec->memSpecs[i]->wordLen;
size_t tmp = devSpec->memSpecs[i]->start + (devSpec->memSpecs[i]->len * devSpec->memSpecs[i]->wordLen);
if (memTotalSize < tmp)
{
memTotalSize = tmp;
}
}
void* rawCells = (void*)malloc(memTotalSize);
void* rawCells = (void*)calloc(memTotalSize, sizeof(void*));
if (rawCells == NULL)
{
sprintf(errbuf, "unable to allocate raw memory buf %lu bytes", memTotalSize);
@@ -82,7 +85,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
((uint8_t*)rawCells)[i] = 0;
}
devMem->memsegShifts = malloc(devSpec->memSpecsCount * sizeof(uint64_t));
devMem->memsegShifts = calloc(devSpec->memSpecsCount, sizeof(uint64_t));
if(devMem->memsegShifts == NULL)
{
@@ -92,7 +95,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL;
}
void** cells = malloc(devSpec->memSpecsCount * sizeof(void*));
void** cells = calloc(devSpec->memSpecsCount, sizeof(void*));
if (cells == NULL)
{
@@ -103,12 +106,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL;
}
for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
{
cells[i] = rawCells + devSpec->memSpecs[i]->start;
}
char** cellNames = malloc(sizeof(char*) * devSpec->memSpecsCount);
char** cellNames = calloc(devSpec->memSpecsCount, sizeof(char*));
if(cellNames == NULL)
{
@@ -122,10 +120,18 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
for(size_t i = 0; i < devSpec->memSpecsCount; i++)
{
cellNames[i] = devSpec->memSpecs[i]->name;
// cellNames[i] = devSpec->memSpecs[i]->name;
}
uint64_t* memreadCellAddrs = malloc(64 * sizeof(uint64_t));
for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
{
printf("init seg \"%s\": %lu:%lu\n", devSpec->memSpecs[i]->name, devSpec->memSpecs[i]->start, devSpec->memSpecs[i]->len);
cells[i] = &(((uint8_t*)rawCells)[devSpec->memSpecs[i]->start]);
cellNames[i] = devSpec->memSpecs[i]->name;
// cells[i] = (void*)((size_t)rawCells + (size_t)devSpec->memSpecs[i]->start);
}
uint64_t* memreadCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
if (memreadCellAddrs == NULL)
{
sprintf(errbuf, "unable to allocate read interception addrs");
@@ -136,7 +142,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
free(cellNames);
return NULL;
}
uint64_t* memwriteCellAddrs = malloc(64 * sizeof(uint64_t));
uint64_t* memwriteCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
if (memwriteCellAddrs == NULL)
{
@@ -150,44 +156,132 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL;
}
uint64_t smartAddrReadMask = 0;
// memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x16)
// | memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x17)
// | memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x18);
uint64_t smartAddrWriteMask = 0;
// memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x16)
// | memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x17)
// | memSegToGlobal(devSpec, MEMDATA_IO_REGS, 0x18);
mem_h_read_handler* smartAddrReadHandlers = malloc(sizeof(mem_h_read_handler) * memTotalSize);
if (smartAddrReadHandlers == NULL)
uint8_t* memwriteCellSegments = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint8_t));
if(memwriteCellSegments == NULL)
{
sprintf(errbuf, "unable to allocate read interception handlers");
free(memwriteCellAddrs);
sprintf(errbuf, "unable to allocate write interception addrs");
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(cells);
free(cellNames);
free(memwriteCellAddrs);
return NULL;
}
mem_h_write_handler* smartAddrWriteHandlers = malloc(sizeof(mem_h_write_handler) * memTotalSize);
void** memwriteValues = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(void*));
if(memwriteValues == NULL)
{
sprintf(errbuf, "unable to allocate write interception addrs");
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(cells);
free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
return NULL;
}
uint64_t* memwriteValuesContainers = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
if(memwriteValuesContainers == NULL)
{
sprintf(errbuf, "unable to allocate write interception addrs");
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(cells);
free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
return NULL;
}
for(size_t i = 0; i < 64; i++)
{
memwriteValues[i] = &memwriteValuesContainers[i];
}
uint8_t* memwriteWordLengths = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint8_t));
if(memwriteWordLengths == NULL)
{
sprintf(errbuf, "unable to allocate write interception addrs");
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(cells);
free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
return NULL;
}
uint64_t smartAddrReadMask = 0;
uint64_t smartAddrWriteMask = 0;
mem_h_read_handler* smartAddrReadHandlers = calloc(memTotalSize, sizeof(mem_h_read_handler));
if(memwriteCellSegments == NULL)
{
sprintf(errbuf, "unable to allocate read interception handlers");
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(cells);
free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
free(memwriteWordLengths);
return NULL;
}
mem_h_write_handler* smartAddrWriteHandlers = calloc(memTotalSize, sizeof(mem_h_write_handler));
if (smartAddrWriteHandlers == NULL)
{
sprintf(errbuf, "unable to allocate write interception handlers");
free(smartAddrReadHandlers);
free(memwriteCellAddrs);
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
free(memwriteWordLengths);
free(cells);
free(cellNames);
return NULL;
}
uint64_t* memsegSizes = calloc(devSpec->memSpecsCount, sizeof(uint64_t));
if(memsegSizes == NULL)
{
sprintf(errbuf, "unable to allocate write interception handlers");
free(smartAddrWriteHandlers);
free(smartAddrReadHandlers);
free(devMem->memsegShifts);
free(devMem);
free(rawCells);
free(memreadCellAddrs);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
free(memwriteWordLengths);
free(cells);
free(cellNames);
return NULL;
@@ -260,6 +354,9 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
devMem->rawCells = rawCells;
devMem->memreadCellAddrs = memreadCellAddrs;
devMem->memwriteCellAddrs = memwriteCellAddrs;
devMem->memwriteCellSegments = memwriteCellSegments;
devMem->memwriteWordLengths = memwriteWordLengths;
devMem->memwriteValues = memwriteValues;
devMem->memreadLen = 0;
devMem->memwriteLen = 0;
devMem->smartAddrReadMask = smartAddrReadMask;
@@ -267,11 +364,33 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
devMem->smartAddrWriteMask = smartAddrWriteMask;
devMem->smartAddrWriteHandlers = smartAddrWriteHandlers;
devMem->memsegNames = cellNames;
devMem->memsegSizes = memsegSizes;
memseg_metadata_t requiredSegments[] = MEMSEG_DEFINES;
for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
{
devMem->memsegShifts[i] = memSegToGlobal(devSpec, i, 0);
for(uint8_t j = 0; j < sizeof(requiredSegments) / sizeof(memseg_metadata_t); j++)
{
const memseg_metadata_t seg_def = requiredSegments[j];
if(strcmp(seg_def.name, devSpec->memSpecs[i]->name) == 0)
{
const uint8_t seg_id = seg_def.seg_id;
devMem->memsegShifts[seg_id] = memSegToGlobal(devSpec, i, 0);
devMem->memsegSizes[seg_id] = devSpec->memSpecs[i]->len;
printf("set mem segment %d meta: +%lu/%lu \n", seg_id, devMem->memsegShifts[j], devMem->memsegSizes[j]);
}
}
}
// for(uint8_t i = 0; i < devSpec->memSpecsCount; i++)
// {
// devMem->memsegShifts[i] = memSegToGlobal(devSpec, i, 0);
// devMem->memsegSizes[i] = devSpec->memSpecs[i]->len;
// }
setOpcodeSizes((uint8_t*)(devMem->cells[MEMDATA_OPSIZE]));
@@ -282,12 +401,18 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
uint8_t makeDeviceTick(device_public_context_t* devContext)
{
device_info_t* devInfo = (device_info_t*)devContext->deviceInfo;
return makeTick(devInfo->pc, devInfo->instr, devInfo->deviceMem);
prog_counter_t _pc;
READ_MEM(_pc, devInfo->deviceMem, MEMSEG_PC_SEG_NUM, MEMSEG_PC_ADDR, prog_counter_t)
// printf("old PC is %d\n", _pc);
uint8_t ticks = makeTick(&_pc, devInfo->instr, devInfo->deviceMem);
WRITE_MEM(devInfo->deviceMem, MEMSEG_PC_SEG_NUM, MEMSEG_PC_ADDR, prog_counter_t, _pc);
// printf("new PC is %d\n", _pc);
return ticks;
}
device_info_t* initSpecs(device_specs_t* specs, char* errbuf)
{
device_info_t* devInfo = malloc(sizeof(device_info_t));
device_info_t* devInfo = calloc(1, sizeof(device_info_t));
if (devInfo == NULL)
{
sprintf(errbuf, "unable to allocate dev info");
@@ -304,7 +429,7 @@ device_info_t* initSpecs(device_specs_t* specs, char* errbuf)
return NULL;
}
devInfo->pc = (prog_counter_t*)(devMem->rawCells + specs->pcAddr);
devInfo->pc = &((prog_counter_t*)(devMem->cells[MEMSEG_PC_SEG_NUM]))[MEMSEG_PC_ADDR];
*(devInfo->pc) = 0;
devInfo->specs = specs;
@@ -334,12 +459,25 @@ void error(const char* err, char* errbuf)
device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
{
conf_mem_seg_t** segments = devConf->memConf->memSegConfs;
device_specs_t* specs = malloc(sizeof(device_specs_t));
device_specs_t* specs = calloc(1, sizeof(device_specs_t));
if (specs == NULL)
{
error("unable to allocate mem specs struct", errbuf);
return NULL;
}
memseg_metadata_t requiredSegments[] = MEMSEG_DEFINES;
uint8_t* requiredSegmentsFoundMap = (uint8_t*)calloc(sizeof(requiredSegments) / sizeof(memseg_metadata_t), sizeof(uint8_t));
if(requiredSegmentsFoundMap == NULL)
{
error("unable to allocate found map", errbuf);
free(specs);
return NULL;
}
uint8_t specCount = 0;
specs->executableSegmentsCount = 0;
@@ -351,29 +489,39 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
}
specCount++;
}
const uint8_t providedSpecCount = specCount;
if(specCount < sizeof(requiredSegments)/sizeof(memseg_metadata_t))
{
specCount = sizeof(requiredSegments)/sizeof(memseg_metadata_t);
}
specs->memSpecsCount = specCount;
specs->memSpecs = malloc(specCount * sizeof(memseg_spec_t*));
specs->memSpecs = calloc(specCount, sizeof(memseg_spec_t*));
if (specs->memSpecs == NULL)
{
free(specs);
free(requiredSegmentsFoundMap);
error("unable to allocate mem segment specs", errbuf);
return NULL;
}
specs->executableSegments = malloc(sizeof(uint8_t) * specs->executableSegmentsCount);
specs->executableSegments = calloc(specs->executableSegmentsCount, sizeof(uint8_t));
if (specs->executableSegments == NULL)
{
error("unable to allocate mem executable specs", errbuf);
free(specs->memSpecs);
free(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
for (uint8_t i = 0; i < specCount; i++)
{
memseg_spec_t* spec = (memseg_spec_t*)malloc(sizeof(memseg_spec_t));
memseg_spec_t* spec = (memseg_spec_t*)calloc(1, sizeof(memseg_spec_t));
if (spec == NULL)
{
sprintf(errbuf, "unable to allocate spec %d", i);
@@ -385,6 +533,7 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
free(specs->memSpecs);
free(specs->executableSegments);
free(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
spec->name = NULL;
@@ -392,59 +541,64 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
specs->memSpecs[i] = spec;
}
uint8_t foundSegments = 0;
uint8_t executableSegmentsFound = 0;
for (uint8_t i = 0; i < specCount; i++)
for (uint8_t i = 0; i < providedSpecCount; i++)
{
uint8_t specNum = 0xFF;
if (strcmp(segments[i]->name, "reg_gp") == 0)
uint8_t is_error = 0;
uint8_t seek_found = 0;
for(uint8_t j = 0; j < sizeof(requiredSegments) / sizeof(memseg_metadata_t); j++)
{
specNum = MEMDATA_GP_REGS;
}
else if (strcmp(segments[i]->name, "reg_io") == 0)
const memseg_metadata_t seg_def = requiredSegments[j];
if(strcmp(seg_def.name, segments[i]->name) == 0)
{
specNum = MEMDATA_IO_REGS;
}
else if (strcmp(segments[i]->name, "ds") == 0)
printf("found seg \"%s\"\n", seg_def.name);
const uint8_t is_found = requiredSegmentsFoundMap[j];
if(is_found)
{
specNum = MEMDATA_DS;
}
else if (strcmp(segments[i]->name, "ps") == 0)
{
specNum = MEMDATA_PS;
is_error = 1;
sprintf(errbuf, "duplicate segment %s", seg_def.name);
}
else
{
sprintf(errbuf, "invalid segment: %s", segments[i]->name);
for(size_t j = 0; j < specCount; j++)
if(seg_def.is_executable == segments[i]->isExecutable || segments[i]->isExecutable)
{
if(specs->memSpecs[j]->name != NULL)
printf("seg executable req satisfyed (%d)\n", seg_def.is_executable);
requiredSegmentsFoundMap[j] = 1;
specNum = seg_def.seg_id;
seek_found = 1;
}
else
{
free(specs->memSpecs[j]->name);
is_error = 1;
sprintf(errbuf, "segment %s must be executable", seg_def.name);
}
free(specs->memSpecs[j]);
}
free(specs->executableSegments);
free(specs->memSpecs);
free(specs);
break;
}
}
if(seek_found == 0)
{
is_error = 1;
sprintf(errbuf, "unsupported memory segment: %s", segments[i]->name);
}
if(is_error)
{
freeDevSpec(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
specs->memSpecs[specNum]->name = malloc(sizeof(char) * (strlen(segments[i]->name) + 1));
specs->memSpecs[specNum]->name = calloc(strlen(segments[i]->name), sizeof(char));
if(specs->memSpecs[specNum]->name == NULL)
{
sprintf(errbuf, "unable to allocate spec %d name", i);
for(size_t j = 0; j < specCount; j++)
{
if(specs->memSpecs[j]->name != NULL)
{
free(specs->memSpecs[j]->name);
}
free(specs->memSpecs[j]);
}
free(specs->executableSegments);
free(specs->memSpecs);
free(specs);
freeDevSpec(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
@@ -452,48 +606,66 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
specs->memSpecs[specNum]->start = segments[i]->start;
specs->memSpecs[specNum]->len = segments[i]->len;
specs->memSpecs[specNum]->wordLen = segments[i]->wordLen;
printf("set segment %s :%lu->%lu/%d\n", segments[i]->name, segments[i]->start, segments[i]->len, segments[i]->wordLen);
if(segments[i]->isExecutable)
{
specs->executableSegments[executableSegmentsFound] = specNum;
executableSegmentsFound++;
}
foundSegments += 1;
}
for(uint8_t i = 0; i < sizeof(requiredSegments)/sizeof(memseg_metadata_t); i++)
{
if(requiredSegmentsFoundMap[i] == 0)
{
const memseg_metadata_t seg_def = requiredSegments[i];
printf("found segment that not specified: \"%s\"\n", seg_def.name);
specs->memSpecs[seg_def.seg_id]->start = seg_def.default_addr;
specs->memSpecs[seg_def.seg_id]->len = seg_def.default_size;
specs->memSpecs[seg_def.seg_id]->wordLen = seg_def.word_len;
specs->memSpecs[seg_def.seg_id]->name = calloc(strlen(seg_def.name) + 1, sizeof(char));
if(specs->memSpecs[seg_def.seg_id]->name == NULL)
{
sprintf(errbuf, "unable to allocate spec %d name", i);
freeDevSpec(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
strcpy(specs->memSpecs[seg_def.seg_id]->name, seg_def.name);
if(seg_def.is_executable)
{
specs->executableSegments[executableSegmentsFound] = seg_def.seg_id;
executableSegmentsFound++;
}
}
}
if(executableSegmentsFound < specs->executableSegmentsCount)
{
sprintf(errbuf, "Not all executable segments found");
for(size_t j = 0; j < specCount; j++)
{
if(specs->memSpecs[j]->name != NULL)
{
free(specs->memSpecs[j]->name);
}
free(specs->memSpecs[j]);
}
free(specs->executableSegments);
free(specs->memSpecs);
free(specs);
freeDevSpec(specs);
free(requiredSegmentsFoundMap);
return NULL;
}
if (foundSegments < 4)
{
sprintf(errbuf, "invalid amount of segments: must be 4");
for(size_t k = 0; k < specs->memSpecsCount; k++)
{
if(specs->memSpecs[k]->name != NULL)
{
free(specs->memSpecs[k]->name);
}
free(specs->memSpecs[k]);
}
free(specs->executableSegments);
free(specs->memSpecs);
free(specs);
return NULL;
}
printf("set all segments\n");
#ifdef MEMSEG_PC_SEG_NUM
#ifndef MEMSEG_PC_ADDR
specs->pcAddr = memSegToGlobal(specs, MEMSEG_PC_SEG_NUM, 0);
#else
specs->pcAddr = memSegToGlobal(specs, MEMSEG_PC_SEG_NUM, MEMSEG_PC_ADDR);
#endif
#endif
free(requiredSegmentsFoundMap);
printf("parse specs done\n");
return specs;
}
@@ -526,8 +698,9 @@ void fillSmartWriteSpecs(device_specs_t* specs, smart_write_spec_t* smartWriteSp
device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t smartReadSpecsCount, smart_write_spec_t* smartWriteSpecs, uint64_t smartWriteSpecsCount, char* errbuf)
{
device_specs_t* specs = malloc(sizeof(device_specs_t));
return NULL;
//TODO
device_specs_t* specs = calloc(1, sizeof(device_specs_t));
if (specs == NULL)
{
return NULL;
@@ -536,7 +709,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
specs->memSpecsCount = 4;
specs->memSpecs = malloc(specs->memSpecsCount * sizeof(memseg_spec_t*));
specs->memSpecs = calloc(specs->memSpecsCount, sizeof(memseg_spec_t*));
if (specs->memSpecs == NULL)
{
sprintf(errbuf, "unable to allocate default mem segment specs");
@@ -546,7 +719,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
specs->executableSegmentsCount = 1;
specs->executableSegments = malloc(sizeof(uint8_t) * 1);
specs->executableSegments = calloc(1, sizeof(uint8_t));
if (specs->executableSegments == NULL)
{
sprintf(errbuf, "unable to allocate default executable segments");
@@ -558,7 +731,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
for (uint8_t i = 0; i < specs->memSpecsCount; i++)
{
specs->memSpecs[i] = malloc(sizeof(memseg_spec_t));
specs->memSpecs[i] = calloc(1, sizeof(memseg_spec_t));
if (specs->memSpecs[i] == NULL)
{
sprintf(errbuf, "unable to allocate default mem seg spec %u", i);
@@ -614,119 +787,18 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
device_public_context_t* init(device_specs_t* specs, char* errbuf)
{
if (specs->memSpecsCount >= 0xFF - 2)
{
sprintf(errbuf, "Too many mem specifications");
return NULL;
}
device_specs_t* realSpecs = malloc(sizeof(device_specs_t));
if (realSpecs == NULL)
{
sprintf(errbuf, "unable to allocate spec struct");
return NULL;
}
uint8_t specCount = specs->memSpecsCount + 2;
realSpecs->memSpecsCount = specCount;
realSpecs->memSpecs = (memseg_spec_t**)malloc(realSpecs->memSpecsCount * sizeof(memseg_spec_t*));
if (realSpecs->memSpecs == NULL)
{
sprintf(errbuf, "unable to allocate mem specs");
free(realSpecs);
return NULL;
}
realSpecs->executableSegments = malloc(sizeof(uint8_t) * specs->executableSegmentsCount);
if (realSpecs->executableSegments == NULL)
{
sprintf(errbuf, "unable to allocate executable segments");
free(realSpecs->memSpecs);
free(realSpecs);
return NULL;
}
for (uint8_t i = 0; i < specs->executableSegmentsCount; i++)
{
realSpecs->executableSegments[i] = specs->executableSegments[i];
}
realSpecs->executableSegmentsCount = specs->executableSegmentsCount;
realSpecs->smartReadSpecs = specs->smartReadSpecs;
realSpecs->smartReadSpecsCount = specs->smartReadSpecsCount;
realSpecs->smartWriteSpecs = specs->smartWriteSpecs;
realSpecs->smartWriteSpecsCount = specs->smartWriteSpecsCount;
uint64_t maxAddr = 0;
for (uint8_t i = 0; i < specCount; i++)
{
memseg_spec_t *segSpec = (memseg_spec_t*)malloc(sizeof(memseg_spec_t));
realSpecs->memSpecs[i] = segSpec;
if (segSpec == NULL)
{
sprintf(errbuf, "unable to allocate mem spec segment %u", i);
for (uint8_t j = 0; j < i; j++)
{
free(realSpecs->memSpecs[j]);
}
free(realSpecs->memSpecs);
free(realSpecs->executableSegments);
free(realSpecs);
return NULL;
}
if (i < specCount - 2)
{
realSpecs->memSpecs[i]->name = specs->memSpecs[i]->name;
realSpecs->memSpecs[i]->len = specs->memSpecs[i]->len;
realSpecs->memSpecs[i]->start = specs->memSpecs[i]->start;
realSpecs->memSpecs[i]->wordLen = specs->memSpecs[i]->wordLen;
uint64_t testMaxAddr = realSpecs->memSpecs[i]->start + (realSpecs->memSpecs[i]->len * realSpecs->memSpecs[i]->wordLen);
if (testMaxAddr > maxAddr)
{
maxAddr = testMaxAddr;
}
}
}
uint8_t pcSpecSegNum = specs->memSpecsCount;
realSpecs->memSpecs[MEMDATA_OPSIZE]->len = ((opcode_t)~0);
realSpecs->memSpecs[MEMDATA_OPSIZE]->start = maxAddr + PC_WORDSIZE;
realSpecs->memSpecs[MEMDATA_OPSIZE]->wordLen = 1;
realSpecs->memSpecs[MEMDATA_OPSIZE]->name = NULL;
realSpecs->memSpecs[specCount - 2]->len = 1;
realSpecs->memSpecs[specCount - 2]->start = maxAddr;
realSpecs->memSpecs[specCount - 2]->wordLen = PC_WORDSIZE;
realSpecs->memSpecs[specCount - 2]->name = NULL;
realSpecs->pcAddr = memSegToGlobal(realSpecs, pcSpecSegNum, 0);
device_public_context_t* pubDevContext = malloc(sizeof(device_public_context_t));
device_public_context_t* pubDevContext = calloc(1, sizeof(device_public_context_t));
if (pubDevContext == NULL)
{
sprintf(errbuf, "unable to allocate public context");
freeDevSpec(realSpecs);
return NULL;
}
char initErrbuf[200];
device_info_t* devInfo = initSpecs(realSpecs, initErrbuf);
device_info_t* devInfo = initSpecs(specs, initErrbuf);
if (devInfo == NULL)
{
sprintf(errbuf, "unable to init specs: %s", initErrbuf);
freeDevSpec(realSpecs);
free(pubDevContext);
return NULL;
}
@@ -737,6 +809,10 @@ device_public_context_t* init(device_specs_t* specs, char* errbuf)
return pubDevContext;
}
uint8_t pubDeviceType()
{
return DEVICE_TYPE;
}
size_t pubExtractPcounter(device_public_context_t* devContext)
{
@@ -757,8 +833,22 @@ uint8_t pubExtractPcounterSizeWords()
return sizeof(prog_counter_t);
}
uint8_t pubDeviceType()
void reset (device_specs_t* specs, device_public_context_t* devInfo)
{
return EXTENDED_DEVICE_TYPE_INSTR_SIMUL;
for(size_t i = 0; i < specs->memSpecsCount; i++)
{
if(i != MEMDATA_OPSIZE)
{
const memseg_spec_t* spec = specs->memSpecs[i];
for(size_t j = 0; j < spec->len; j++)
{
((uint8_t*)devInfo->deviceMem->cells[i])[j] = 0;
}
}
}
devInfo->deviceMem->memwriteLen = 0;
devInfo->deviceMem->memreadLen = 0;
}

28
inc/config.h
View File

@@ -1,31 +1,7 @@
#ifndef __HMMMM_CONFIG_H__
#define __HMMMM_CONFIG_H__
#include <unistd.h>
#include <stdint.h>
typedef struct {
char* name;
size_t start;
size_t len;
uint8_t wordLen;
uint8_t isExecutable;
} conf_mem_seg_t;
typedef struct {
conf_mem_seg_t** memSegConfs;
} conf_mem_t;
typedef struct {
char** id;
char** clockId;
uint64_t clockDivider;
uint64_t clockMultipler;
conf_mem_t* memConf;
char* libPath;
} conf_dev_t;
#include "pub/libhmmmm/config.h"
void freeMemSegConf(conf_mem_seg_t* memSegConf);
void freeMemConf(conf_mem_t* memConf);
@@ -33,4 +9,4 @@ void freeConf(conf_dev_t* conf);
void freeComposeId(char** id);
uint8_t compareComposeId(char** idA, char** idB);
#endif // ifndef __HMMMM_CONFIG_H__
#endif

1
inc/context.h
View File

@@ -24,6 +24,7 @@ typedef struct {
typedef struct {
uint8_t* resetRequest;
uint8_t* emulState;
uint64_t* clockCounter;
LinkedListEntry** clientsHead;

3
inc/hmmmm.h
View File

@@ -1,6 +1,6 @@
#ifndef __HMMMMM__
#define __HMMMMM__
#include "libhmmmm.h"
#include "pub/libhmmmm/device.h"
#include "config.h"
typedef struct {
@@ -25,6 +25,7 @@ typedef struct {
void (*freeDevMem)(device_mem_t* mem);
void (*fillSmartReadSpecs)(void* specs, smart_read_spec_t* smartReadSpecs, uint64_t smartReadSpecsCount);
void (*fillSmartWriteSpecs)(void* specs, smart_write_spec_t* smartWriteSpecs, uint64_t smartWriteSpecsCount);
void (*reset)(void* specs, device_public_context_t* devInfo);
} device_lib_t;
device_lib_t* loadDeviceLib(const char *libpath, char* errbuf);

14
inc/libhmmmm.h
View File

@@ -1,14 +0,0 @@
#ifndef __LIB_HMMMMM__
#define __LIB_HMMMMM__
#include "libmem.h"
#include "libdevice.h"
#define EXTENDED_DEVICE_TYPE_DUMMY 0
#define EXTENDED_DEVICE_TYPE_INSTR_SIMUL 1
#endif // ifndef __LIB_HMMMMM__

52
inc/libmem.h
View File

@@ -1,52 +0,0 @@
#ifndef __LIBMEM_H__
#define __LIBMEM_H__
#include <stdint.h>
#include <stdlib.h>
#define GET_BIT(n, b) ((n >> b) & 1)
// Internal mem handlers
typedef void* (*mem_h_read_func)(uint64_t ident, uint64_t addr, void* rawCells);
typedef void (*mem_h_write_func)(uint64_t ident, uint64_t addr, void* rawCells, void* data);
typedef struct {
mem_h_read_func func;
uint64_t ident;
} mem_h_read_handler;
typedef struct {
mem_h_write_func func;
uint64_t ident;
} mem_h_write_handler;
typedef struct
{
void* rawCells;
void** cells;
uint64_t smartAddrReadMask;
uint64_t smartAddrWriteMask;
mem_h_read_handler* smartAddrReadHandlers;
mem_h_write_handler* smartAddrWriteHandlers;
char** memsegNames;
uint64_t* memsegShifts;
uint64_t* memreadCellAddrs;
uint64_t* memwriteCellAddrs;
uint8_t memreadLen;
uint8_t memwriteLen;
} device_mem_t;
typedef struct
{
uint64_t start;
uint64_t len;
uint8_t wordLen;
char* name;
} memseg_spec_t;
// External handlers
typedef void* (*ext_h_read_func)(uint64_t addr, void* rawCells, void* devContext);
typedef void (*ext_h_write_func)(uint64_t addr, void* rawCells, void* data, void* devContext);
#endif // ifndef __LIBMEM_H__

29
inc/pub/libhmmmm/config.h Normal file
View File

@@ -0,0 +1,29 @@
#ifndef __HMMMM_PUB_LIB_CONFIG_H__
#define __HMMMM_PUB_LIB_CONFIG_H__
#include <unistd.h>
#include <stdint.h>
typedef struct {
char* name;
size_t start;
size_t len;
uint8_t wordLen;
uint8_t isExecutable;
} conf_mem_seg_t;
typedef struct {
conf_mem_seg_t** memSegConfs;
} conf_mem_t;
typedef struct {
char** id;
char** clockId;
uint64_t clockDivider;
uint64_t clockMultipler;
conf_mem_t* memConf;
char* libPath;
} conf_dev_t;
#endif // ifndef __HMMMM_PUB_LIB_CONFIG_H__

7
inc/libdevice.h → inc/pub/libhmmmm/device.h
View File

@@ -2,10 +2,15 @@
#define __LIBDEVICE_H__
#include <stdint.h>
#include "libmem.h"
#include "mem.h"
#define SMART_ADDR_TYPE_GLOBAL 1
#define SMART_ADDR_TYPE_SEGMENTED 2
#define EXTENDED_DEVICE_TYPE_DUMMY 0
#define EXTENDED_DEVICE_TYPE_INSTR_SIMUL 1
typedef struct
{
uint64_t addr;

96
inc/pub/libhmmmm/mem.h Normal file
View File

@@ -0,0 +1,96 @@
#ifndef __HMMMM_PUB_MEM_H__
#define __HMMMM_PUB_MEM_H__
#include <stdint.h>
#include <stdlib.h>
#define GET_BIT(n, b) ((uint8_t)((n >> b) & 1))
#define MEM_ACCESS_INTERCEPT_BUF_SIZE 64
// Internal mem handlers
typedef void* (*mem_h_read_func)(uint64_t ident, uint64_t addr, void* rawCells);
typedef void (*mem_h_write_func)(uint64_t ident, uint64_t addr, void* rawCells, void* data);
typedef struct {
mem_h_read_func func;
uint64_t ident;
} mem_h_read_handler;
typedef struct {
mem_h_write_func func;
uint64_t ident;
} mem_h_write_handler;
typedef struct
{
void* rawCells;
void** cells;
uint64_t smartAddrReadMask;
uint64_t smartAddrWriteMask;
mem_h_read_handler* smartAddrReadHandlers;
mem_h_write_handler* smartAddrWriteHandlers;
char** memsegNames;
uint64_t* memsegShifts;
uint64_t* memsegSizes;
uint64_t* memreadCellAddrs;
uint8_t* memwriteWordLengths;
uint8_t* memwriteCellSegments;
uint64_t* memwriteCellAddrs;
void** memwriteValues;
uint8_t memreadLen;
uint8_t memwriteLen;
} device_mem_t;
typedef struct
{
uint64_t start;
uint64_t len;
uint8_t wordLen;
char* name;
} memseg_spec_t;
// External handlers
typedef void* (*ext_h_read_func)(uint64_t addr, void* rawCells, void* devContext);
typedef void (*ext_h_write_func)(uint64_t addr, void* rawCells, void* data, void* devContext);
#define READ_MEM(__tgt, __mem, __segno, __addr, __cell_t) \
{\
uint64_t __globalAddr = __mem->memsegShifts[__segno] + __addr; \
if (__mem->smartAddrReadHandlers[__globalAddr].func != NULL) \
{ \
/* __tgt = *(__cell_t*)__mem->smartAddrReadHandlers[__globalAddr].func(__mem->smartAddrReadHandlers[__globalAddr].ident, __addr, __mem->rawCells + __mem->memsegShifts[__segno]);*/ \
__tgt = 0;\
} \
else \
{ \
__tgt = ((__cell_t*)__mem->cells[__segno])[__addr]; \
} \
__mem->memreadCellAddrs[__mem->memreadLen] = __globalAddr; \
__mem->memreadLen += 1; \
}
#define WRITE_MEM(__mem, __segno, __addr, __cell_t, __val) \
{ \
uint64_t __globalAddr = ((uint64_t)(__mem->memsegShifts[__segno]) + (uint64_t)(__addr)); \
if (0 && __mem->smartAddrWriteHandlers[__globalAddr].func != NULL) \
{ \
/*__cell_t __dat = (__cell_t)(__val);*/ \
/*__mem->smartAddrWriteHandlers[__globalAddr].func(__mem->smartAddrWriteHandlers[__globalAddr].ident, __addr, __mem->rawCells + __mem->memsegShifts[__segno], (void*)&__dat);*/ \
} \
else if(0) \
{ \
((__cell_t*)__mem->cells[__segno])[__addr] = (__cell_t)(__val); \
} \
__mem->memwriteCellAddrs[__mem->memwriteLen] = __addr; \
__mem->memwriteCellSegments[__mem->memwriteLen] = __segno; \
__mem->memwriteWordLengths[__mem->memwriteLen] = sizeof(__cell_t); \
*((__cell_t*)__mem->memwriteValues[__mem->memwriteLen]) = (__cell_t)(__val); \
__mem->memwriteLen += 1; \
}
#endif // ifndef __HMMMM_PUB_MEM_H__

41
src/hmmmm.c
View File

@@ -10,6 +10,7 @@ typedef size_t (*_dlib_pubExtractOpcode_t)(device_mem_t* devMem, size_t _program
typedef uint8_t(*_dlib_pubExtractPcounterSizeWords_t)();
typedef device_public_context_t* (*_dlib_dev_init_t)(void* specs, char* errbuf);
typedef void (*_dlib_dev_reset_t)(void* specs, device_public_context_t* devInfo);
typedef uint8_t (*_dlib_makeDeviceTick_t)(device_public_context_t* devInfo);
@@ -98,7 +99,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
void *handle = dlopen(libpath, RTLD_NOW);
if (!handle) {
if (!handle)
{
const char *dlerr = dlerror();
snprintf(errbuf, 1024, "unable to open dl handle: %s", dlerr);
free(dev);
@@ -110,7 +112,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_dev_init_t _dlib_dev_init = (_dlib_dev_init_t)(uintptr_t)dlsym(handle, "init");
const char *dlsym_init_error = dlerror();
if (dlsym_init_error) {
if (dlsym_init_error)
{
snprintf(errbuf, 1024, "unable to find init symbol: %s", dlsym_init_error);
dlclose(handle);
free(dev);
@@ -121,7 +124,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
const char *dlsym_maketick_error = dlerror();
if (dlsym_maketick_error) {
if (dlsym_maketick_error)
{
snprintf(errbuf, 1024, "unable to find makeDeviceTick symbol: %s", dlsym_maketick_error);
dlclose(handle);
free(dev);
@@ -133,7 +137,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_parseSpecsFromConfig_t _dlib_parseSpecsFromConfig = (_dlib_parseSpecsFromConfig_t)(uintptr_t)dlsym(handle, "parseSpecsFromConfig");
const char *_dlib_parseSpecsFromConfig_error = dlerror();
if (_dlib_parseSpecsFromConfig_error) {
if (_dlib_parseSpecsFromConfig_error)
{
snprintf(errbuf, 1024, "unable to find parseSpecsFromConfig symbol: %s", _dlib_parseSpecsFromConfig_error);
dlclose(handle);
free(dev);
@@ -145,7 +150,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_fillSmartReadSpecs_t _dlib_fillSmartReadSpecs = (_dlib_fillSmartReadSpecs_t)(uintptr_t)dlsym(handle, "fillSmartReadSpecs");
const char *_dlib_fillSmartReadSpecs_error = dlerror();
if (_dlib_fillSmartReadSpecs_error) {
if (_dlib_fillSmartReadSpecs_error)
{
snprintf(errbuf, 1024, "unable to find fillSmartReadSpecs symbol: %s", _dlib_fillSmartReadSpecs_error);
dlclose(handle);
free(dev);
@@ -157,7 +163,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_fillSmartWriteSpecs_t _dlib_fillSmartWriteSpecs = (_dlib_fillSmartWriteSpecs_t)(uintptr_t)dlsym(handle, "fillSmartWriteSpecs");
const char *_dlib_fillSmartWriteSpecs_error = dlerror();
if (_dlib_fillSmartWriteSpecs_error) {
if (_dlib_fillSmartWriteSpecs_error)
{
snprintf(errbuf, 1024, "unable to find fillSmartWriteSpecs symbol: %s", _dlib_fillSmartWriteSpecs_error);
dlclose(handle);
free(dev);
@@ -168,7 +175,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_deviceType_t _dlib_deviceType = (_dlib_deviceType_t)(uintptr_t)dlsym(handle, "pubDeviceType");
const char *dlib_deviceType_error = dlerror();
if (dlib_deviceType_error) {
if (dlib_deviceType_error)
{
snprintf(errbuf, 1024, "unable to find pubDeviceType symbol: %s", dlib_deviceType_error);
dlclose(handle);
free(dev);
@@ -181,7 +189,8 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
_dlib_freeSpecs_t _dlib_freeSpecs = (_dlib_freeSpecs_t)(uintptr_t)dlsym(handle, "freeDevSpecs");
const char *dlib_freeSpecs_error = dlerror();
if (dlib_freeSpecs_error) {
if (dlib_freeSpecs_error)
{
snprintf(errbuf, 1024, "unable to find freeSpecs symbol: %s", dlib_freeSpecs_error);
dlclose(handle);
free(dev);
@@ -189,10 +198,23 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
}
_dlib_dev_reset_t _dlib_reset = (_dlib_dev_reset_t)(uintptr_t)dlsym(handle, "reset");
const char *dlib_dev_reset_t_error = dlerror();
if (dlib_dev_reset_t_error)
{
snprintf(errbuf, 1024, "unable to find reset symbol: %s", dlib_dev_reset_t_error);
dlclose(handle);
free(dev);
return NULL;
}
_dlib_freeDevMem_t _dlib_freeDevMem = (_dlib_freeDevMem_t)(uintptr_t)dlsym(handle, "freeDevMem");
const char *dlib_freeDevMem_error = dlerror();
if (dlib_freeDevMem_error) {
if (dlib_freeDevMem_error)
{
snprintf(errbuf, 1024, "unable to find freeDevMem symbol: %s", dlib_freeDevMem_error);
dlclose(handle);
free(dev);
@@ -207,6 +229,7 @@ device_lib_t* loadDeviceLib(const char *libpath, char* errbuf)
dev->fillSmartWriteSpecs = _dlib_fillSmartWriteSpecs;
dev->freeSpecs = _dlib_freeSpecs;
dev->freeDevMem = _dlib_freeDevMem;
dev->reset = _dlib_reset;
uint8_t devType = _dlib_deviceType();

184
src/main.c
View File

@@ -331,9 +331,12 @@ void dispatchMemAccessNotifications(EmulContext* emulContext, DeviceSegStreamReg
// printf("No stream regs\n");
return;
}
StreamReg** dispatchRegs = malloc(sizeof(StreamReg*) * deviceRegs->regCount);
NULL_GUARD(dispatchRegs);
StreamReg* dispatchRegs[1024 * 16];
// StreamReg** dispatchRegs = malloc(sizeof(StreamReg*) * deviceRegs->regCount);
// NULL_GUARD(dispatchRegs);
size_t dispatchRegsCnt = 0;
// uint8_t dispatchedRegMap[1024 * 16] = {0};
for(size_t i = 0; i < addrsLen; i++)
{
@@ -343,8 +346,18 @@ void dispatchMemAccessNotifications(EmulContext* emulContext, DeviceSegStreamReg
StreamReg* reg = &deviceRegs->regs[regIdx];
if(reg->mode == mode)
{
if(reg->startGlobalAddr <= addr && reg->startGlobalAddr + reg->segLen >= addr)
if(reg->startGlobalAddr <= addr && addr <= reg->startGlobalAddr + reg->segLen)
{
// if(dispatchedRegMap[reg->regId] == 1)
// {
// // break;
// }
// else
// {
// dispatchRegs[dispatchRegsCnt] = reg;
// dispatchedRegMap[reg->regId] = 1;
// dispatchRegsCnt++;
// }
uint8_t isDuplicate = 0;
for(size_t j = 0; j < dispatchRegsCnt; j++)
{
@@ -357,6 +370,7 @@ void dispatchMemAccessNotifications(EmulContext* emulContext, DeviceSegStreamReg
if(!isDuplicate)
{
dispatchRegs[dispatchRegsCnt] = reg;
// dispatchedRegMap[reg->regId] = 1;
dispatchRegsCnt++;
}
}
@@ -373,7 +387,7 @@ void dispatchMemAccessNotifications(EmulContext* emulContext, DeviceSegStreamReg
{
dispatchStreamSegment(emulContext, dispatchRegs[i], mem);
}
free(dispatchRegs);
// free(dispatchRegs);
}
@@ -466,9 +480,11 @@ int main(int argc, char** argv)
LinkedListEntry* clientsLinkedListHead = NULL;
uint64_t clockCounter = 0;
uint8_t resetRequest = 0;
uint8_t utilizedFlag = 0;
EmulContext emulContext = {
&resetRequest,
&emulState,
&clockCounter,
&clientsLinkedListHead,
@@ -534,9 +550,11 @@ int main(int argc, char** argv)
ptQueueElem* regQueueTail = regQ->tail;
uint8_t clients_try_timer = 1;
uint16_t clients_try_timer = 1000;
uint64_t lastTickAt = getCurrentUsec();
uint64_t lastTickCountWindowAt = getCurrentUsec();
uint64_t lastTickCounter = 0;
while(1)
{
@@ -552,15 +570,21 @@ int main(int argc, char** argv)
if (clients_try_timer == 0)
{
handleAllClients(&emulContext);
clients_try_timer = 1;
}
else
if(getCurrentUsec() - lastTickCountWindowAt > 1000000)
{
clients_try_timer--;
// uint64_t dtimeUs = getCurrentUsec() - lastTickCountWindowAt;
// lastTickCountWindowAt = getCurrentUsec();
// uint64_t dtick = clockCounter - lastTickCounter;
// lastTickCounter = clockCounter;
// double rate = ((double)dtick) / (((double)dtimeUs) / 1000000);
// printf("clock rate: %f\n", rate);
}
handleAllClients(&emulContext);
clients_try_timer = 1000;
uint8_t readReqIdx = atomic_load(&outBufs.readRequestIdx);
// uint8_t readReqIdx = outBufs.readRequestIdx;
if(readReqIdx == outBufs.currWritingIdx || outBufs.bufs[outBufs.currWritingIdx].size >= outBufs.bufs[outBufs.currWritingIdx].allocatedSize / 2)
{
uint8_t newWriteIdx = outBufs.currWritingIdx + 1;
@@ -572,38 +596,152 @@ int main(int argc, char** argv)
}
while(readReqIdx == newWriteIdx)
{
my_sleep(100000);
my_sleep(100);
readReqIdx = atomic_load(&outBufs.readRequestIdx);
}
atomic_store(&outBufs.currWritingIdx, newWriteIdx);
outBufs.bufs[outBufs.currWritingIdx].size = 0;
}
}
}
else
{
clients_try_timer--;
}
if(resetRequest)
{
for(size_t di = 0; di < emulContext.devicesCount; di++)
{
device_handle_t* dev = (device_handle_t*)emulContext.deviceHandles[di];
dev->lib->reset(dev->specs, dev->ctx);
dev->clockCycleCounter = 0;
dev->clockCycleLimit = 0;
}
clockCounter = 0;
resetRequest = 0;
}
uint64_t now = emulContext.simRateLimit > 0? getCurrentUsec() : 0;
if(emulState == EMUL_STATE_STOP)
// if(emulState == EMUL_STATE_STOP)
// {
// clockCounter = 0;
// }
if(emulState == EMUL_STATE_EXEC && emulContext.devicesCount > 0 && (emulContext.simRateLimit == 0 || (double)(now - lastTickAt) >= 1000000.0 / (double)emulContext.simRateLimit))
{
clockCounter = 0;
// printf("\n\ntick %lu\n", clockCounter);
for(size_t di = 0; di < emulContext.devicesCount; di++)
{
device_handle_t* dev = (device_handle_t*)emulContext.deviceHandles[di];
if (clockCounter % dev->clockDivider == 0)
{
if(dev->clockCycleCounter > 0)
{
dev->clockCycleCounter--;
}
else if(emulState == EMUL_STATE_EXEC && emulContext.devicesCount > 0 && (emulContext.simRateLimit == 0 || now - lastTickAt >= 1000000 / emulContext.simRateLimit))
}
}
for(size_t di = 0; di < emulContext.devicesCount; di++)
{
device_handle_t* dev = (device_handle_t*)emulContext.deviceHandles[di];
device_mem_t* devMem = dev->ctx->deviceMem;
if(dev->clockCycleCounter == 0)
{
if(devMem->memwriteLen > 0)
{
// printf("device %lu has %d writes\n", di, devMem->memwriteLen);
uint64_t globalWriteAddrs[MEM_ACCESS_INTERCEPT_BUF_SIZE] = {0};
for(size_t i = 0; i < devMem->memwriteLen; i++)
{
const uint8_t seg = devMem->memwriteCellSegments[i];
const uint8_t wordLen = devMem->memwriteWordLengths[i];
const uint64_t addr = devMem->memwriteCellAddrs[i];
void* val = devMem->memwriteValues[i];
// const uint64_t segLen = devMem->memsegSizes[seg];
// // device_specs_t* spec = dev->specs;
// // spec
// if(addr >= segLen)
// {
// printf("write out of bounds of segment of len %lu: [%d].%lu\n", segLen, seg, addr);
// emulState = EMUL_STATE_PAUSE;
// }
// else
{
switch(wordLen)
{
case 1:
{
((uint8_t*)(devMem->cells[seg]))[addr] = *((uint8_t*)val);
// printf("[DEV/WRITE] %d -> [%d].%lu\n", *(uint8_t*)val, seg, addr);
break;
}
case 2:
{
((uint16_t*)(devMem->cells[seg]))[addr] = *((uint16_t*)val);
// printf("[DEV/WRITE] %d -> [%d].%lu\n", *(uint16_t*)val, seg, addr);
break;
}
case 4:
{
((uint32_t*)(devMem->cells[seg]))[addr] = *((uint32_t*)val);
// printf("[DEV/WRITE] %d -> [%d].%lu\n", *(uint32_t*)val, seg, addr);
break;
}
case 8:
{
((uint64_t*)(devMem->cells[seg]))[addr] = *((uint64_t*)val);
// printf("[DEV/WRITE] %lu -> [%d].%lu\n", *(uint64_t*)val, seg, addr);
break;
}
default:
{
printf("invalid word size: %d\n", wordLen);
}
}
}
globalWriteAddrs[i] = devMem->memsegShifts[seg] + addr;
}
dispatchMemAccessNotifications(&emulContext, emulContext.deviceStreamRegs[di], devMem, globalWriteAddrs, (size_t)devMem->memwriteLen, STREAM_MODE_WRITE);
devMem->memwriteLen = 0;
}
else
{
// printf("device %lu has no writes\n", di);
}
if(devMem->memreadLen > 0)
{
dispatchMemAccessNotifications(&emulContext, emulContext.deviceStreamRegs[di], devMem, devMem->memreadCellAddrs, (size_t)devMem->memreadLen, STREAM_MODE_READ);
devMem->memreadLen = 0;
}
}
}
for (size_t di = 0; di < emulContext.devicesCount; di++)
{
device_handle_t* dev = (device_handle_t*)emulContext.deviceHandles[di];
if (clockCounter % dev->clockDivider == 0)
{
if(dev->clockCycleCounter == 0)
{
// printf("clock device %lu\n", di);
device_mem_t* devMem = dev->ctx->deviceMem;
devMem->memreadLen = 0;
devMem->memwriteLen = 0;
// device_mem_t* devMem = dev->ctx->deviceMem;
dev->lib->makeDeviceTick(dev->ctx);
dispatchMemAccessNotifications(&emulContext, emulContext.deviceStreamRegs[di], devMem, devMem->memreadCellAddrs, (size_t)devMem->memreadLen, STREAM_MODE_READ);
dispatchMemAccessNotifications(&emulContext, emulContext.deviceStreamRegs[di], devMem, devMem->memwriteCellAddrs, (size_t)devMem->memwriteLen, STREAM_MODE_WRITE);
dev->clockCycleCounter = dev->lib->makeDeviceTick(dev->ctx);
}
}
}
clockCounter++;
@@ -615,7 +753,7 @@ int main(int argc, char** argv)
}
else if(!utilizedFlag)
{
my_sleep(1000);
// my_sleep(1000);
}
}

4
src/proto/dial.c
View File

@@ -41,10 +41,10 @@ void dispatchOutgoingMessage(OutgoingBuffers* outBufs, ws_cli_conn_t clientIdx,
if(p->size + 1 >= p->allocatedSize)
{
// printf("\t>>Reallocating buf %d\n", outBufs->currWritingIdx);
OutgoingMessage* newPtr = realloc(p->ptr, sizeof(OutgoingMessage) * p->allocatedSize * 2);
OutgoingMessage* newPtr = realloc(p->ptr, sizeof(OutgoingMessage) * p->allocatedSize * 5);
NULL_GUARD(newPtr);
p->ptr = newPtr;
p->allocatedSize = p->allocatedSize * 2;
p->allocatedSize = p->allocatedSize * 5;
}
OutgoingMessage* outmsg = &((OutgoingMessage*)p->ptr)[p->size];
outmsg->msg = msg;

7
src/proto/handlers.c
View File

@@ -19,9 +19,9 @@
void handleCloseClient(EmulContext* emulContext, ClientContext* ctx)
{
if (ctx->streamRegIterator > 0) {
// if (ctx->streamRegIterator > 0) {
unregisterClientStreams(emulContext, ctx);
}
// }
}
@@ -45,7 +45,8 @@ void handleRegEvent(EmulContext* emulContext, ClientRegistrationEvent* ev)
{
LinkedListEntry* clientEntry = *emulContext->clientsHead;
while (clientEntry != NULL) {
if (clientEntry->payload == ev->ctx) {
if (clientEntry->payload == ev->ctx)
{
printf("close client %lu\n", ev->ctx->clientId);
handleCloseClient(emulContext, ev->ctx);
removeLinkedListEntry(emulContext->clientsHead, clientEntry);

56
src/proto/handlers/config.c
View File

@@ -143,7 +143,8 @@ static int load_devices_recursive(
char initErrBuf[256];
dev->ctx = dev->lib->init(dev->specs, initErrBuf);
if (!dev->ctx) {
if (!dev->ctx)
{
snprintf(errbuf, 1024, "error while loading device %lu: %s", st->count, initErrBuf);
closeBaseDevice(dev);
free(dev);
@@ -160,9 +161,11 @@ static int load_devices_recursive(
hmmmm_config_MemSegment_vec_t dev_segs =
hmmmm_config_BaseDeviceConfig_mem_segments(base);
size_t nseg = dev_segs ? hmmmm_config_MemSegment_vec_len(dev_segs) : 0;
if (nseg > MAX_SEGMENTS) nseg = MAX_SEGMENTS;
// if (nseg > MAX_SEGMENTS) nseg = MAX_SEGMENTS;
st->seg_counts[idx] = nseg;
for (size_t si = 0; si < nseg; si++) {
for (size_t si = 0; si < nseg; si++)
{
hmmmm_config_MemSegment_table_t seg =
hmmmm_config_MemSegment_vec_at(dev_segs, si);
flatbuffers_string_t sname = hmmmm_config_MemSegment_name(seg);
@@ -172,18 +175,22 @@ static int load_devices_recursive(
// Copy path
st->path_lens[idx] = st->depth;
st->paths[idx] = calloc(st->depth + 1, sizeof(char*));
if (!st->paths[idx]) {
if (!st->paths[idx])
{
snprintf(errbuf, 1024, "alloc path array");
return -1;
}
for (size_t p = 0; p < st->depth; p++) {
for (size_t p = 0; p < st->depth; p++)
{
st->paths[idx][p] = strdup(st->path_stack[p]);
}
st->paths[idx][st->depth] = NULL;
st->count++;
} else if (ctype == hmmmm_config_DeviceConfig_ComposeDeviceConfig) {
}
else if (ctype == hmmmm_config_DeviceConfig_ComposeDeviceConfig)
{
hmmmm_config_ComposeDeviceConfig_table_t child =
(hmmmm_config_ComposeDeviceConfig_table_t)
hmmmm_config_DeviceEntry_config(entry);
@@ -191,7 +198,9 @@ static int load_devices_recursive(
if (load_devices_recursive(child, st, errbuf) != 0) {
return -1;
}
} else {
}
else
{
snprintf(errbuf, 1024, "unknown device config type %u", ctype);
return -1;
}
@@ -472,21 +481,27 @@ static int apply_intercepts(
static void free_old_config(EmulContext* emulContext)
{
if (emulContext->devicesCount == 0) return;
if (emulContext->devicesCount == 0)
{
return;
}
// Free intercept context array (single contiguous allocation)
if (emulContext->interceptCtxs) {
if (emulContext->interceptCtxs)
{
free(emulContext->interceptCtxs);
emulContext->interceptCtxs = NULL;
emulContext->interceptCtxCount = 0;
}
for (size_t i = 0; i < emulContext->devicesCount; i++) {
for (size_t i = 0; i < emulContext->devicesCount; i++)
{
device_handle_t* dev = (device_handle_t*)emulContext->deviceHandles[i];
closeBaseDevice(dev);
free(dev);
if (emulContext->deviceStreamRegs[i]) {
if (emulContext->deviceStreamRegs[i])
{
free(emulContext->deviceStreamRegs[i]->regs);
free(emulContext->deviceStreamRegs[i]);
}
@@ -501,7 +516,8 @@ static void free_old_config(EmulContext* emulContext)
emulContext->devicesCount = 0;
emulContext->simRateLimit = 0;
if (emulContext->deviceIdMappingMsg) {
if (emulContext->deviceIdMappingMsg)
{
free(emulContext->deviceIdMappingMsg);
emulContext->deviceIdMappingMsg = NULL;
emulContext->deviceIdMappingMsgLen = 0;
@@ -701,6 +717,22 @@ void handleConfigCtrlMessage(
// Build DeviceIdMappingNotif and broadcast to all connected clients
size_t msg_len;
printf("fuck!\n");
for(size_t i = 0; i < emulContext->devicesCount; i++)
{
device_handle_t* handl = emulContext->deviceHandles[i];
for(size_t j = 0; j < st.seg_counts[i]; j++)
{
if(st.seg_names[i][j])
{
free(st.seg_names[i][j]);
}
printf("setting device %lu segment %lu name: \"%s\"\n", i, j, handl->ctx->deviceMem->memsegNames[j]);
st.seg_names[i][j] = strdup(handl->ctx->deviceMem->memsegNames[j]);
}
}
uint8_t* out = fb_build_config_device_id_mapping(
nonce, st.paths, st.path_lens, st.seg_names, st.seg_counts, dc, &msg_len);

5
src/proto/handlers/control.c
View File

@@ -60,6 +60,11 @@ void handleIncomingCtrlMessage(
return;
}
if(state_op == EMUL_STATE_OP_RESET)
{
*emulContext->resetRequest = 1;
}
uint8_t new_state = switchNewEmulState(*emulContext->emulState, state_op);
*emulContext->emulState = new_state;
printf("[CTRL/EXEC] state -> %u\n", new_state);

26
src/proto/handlers/mem.c
View File

@@ -2,9 +2,11 @@
#include <stdio.h>
#include <string.h>
#include "base_device.h"
#include "proto/msg.h"
#include "proto/dial.h"
#include "mem_reader.h"
#include "pub/libhmmmm/mem.h"
// #define DEVICE_MEM_SIZE ((size_t)(256 * 1024))
@@ -29,7 +31,7 @@ void handleIncomingMemMessage(
hmmmm_mem_MemClientMessage_payload(msg);
uint32_t dev_id = hmmmm_mem_MemReadRequest_device_id(req);
uint32_t seg_id = hmmmm_mem_MemReadRequest_seg_id(req);
volatile uint32_t seg_id = hmmmm_mem_MemReadRequest_seg_id(req);
uint32_t offset = hmmmm_mem_MemReadRequest_offset(req);
uint32_t length = hmmmm_mem_MemReadRequest_length(req);
@@ -41,14 +43,25 @@ void handleIncomingMemMessage(
return;
}
offset = (uint32_t)(((size_t)offset) + emulContext->devicesMemSegAddrs[dev_id][seg_id]);
// offset = (uint32_t)(((size_t)offset) + emulContext->devicesMemSegAddrs[dev_id][seg_id]);
// if ((size_t)offset + (size_t)length > DEVICE_MEM_SIZE) {
// printf("[MEM/READ] out of bounds\n");
// return;
// }
printf("[MEM/READ] from %d/%d+%d:%d\n", dev_id, seg_id, offset, length);
device_handle_t* handl = emulContext->deviceHandles[dev_id];
const uint8_t* base = handl->ctx->deviceMem->cells[seg_id]; //emulContext->devicesMem[dev_id] + handl->ctx->deviceMem->memsegShifts[seg_id];
for(size_t i = 0; i < length; i++)
{
printf("%02X ", (base + offset)[i]);
}
printf("\n");
const uint8_t* base = emulContext->devicesMem[dev_id];
size_t out_len;
uint8_t* out = fb_build_mem_read_response(
nonce, *emulContext->clockCounter,
@@ -81,7 +94,12 @@ void handleIncomingMemMessage(
// return;
// }
uint8_t* base = emulContext->devicesMem[dev_id];
// device_mem_t* devMem = emulContext->devicesMem[dev_id];
device_handle_t* handl = emulContext->deviceHandles[dev_id];
printf("[MEM/WRITE] from %d/%d+%d:%lu\n", dev_id, seg_id, offset, data_len);
uint8_t* base = handl->ctx->deviceMem->cells[seg_id]; // emulContext->devicesMem[dev_id] + handl->ctx->deviceMem->memsegShifts[seg_id];
memcpy(base + offset, data, data_len);
size_t out_len;

15
src/proto/handlers/stream.c
View File

@@ -40,22 +40,27 @@ void unregisterClientStreams(EmulContext* emulContext, ClientContext* ctx)
for (size_t deviceId = 0; deviceId < emulContext->devicesCount; deviceId++) {
DeviceSegStreamReg* deviceRegs = emulContext->deviceStreamRegs[deviceId];
StreamReg* newRegs = malloc(sizeof(StreamReg) * deviceRegs->regCount);
StreamReg* newRegs = calloc(deviceRegs->allocatedSize, sizeof(StreamReg));
NULL_GUARD(newRegs);
size_t newCount = 0;
for (size_t i = 0; i < deviceRegs->regCount; i++) {
for (size_t i = 0; i < deviceRegs->regCount; i++)
{
StreamReg* reg = &deviceRegs->regs[i];
if (reg->clientContext->clientId != ctx->clientId) {
if (reg->clientContext->clientId != ctx->clientId)
{
newRegs[newCount++] = *reg;
} else {
}
else
{
printf("Removing stream reg [%u] for client %lu\n",
reg->regId, ctx->clientId);
}
}
free(deviceRegs->regs);
StreamReg* oldRegs = deviceRegs->regs;
deviceRegs->regCount = newCount;
deviceRegs->regs = newRegs;
free(oldRegs);
}
}

3
src/proto/handlers/ws.c
View File

@@ -92,7 +92,8 @@ void onWsClose(ws_cli_conn_t client)
with_lock(&ctx->registerMutex)
{
int exitCode = ptQueuePush(ctx->regQueue, ev, errbuf);
if (exitCode) {
if (exitCode)
{
panic("Unable to push to reg queue: %s\n", errbuf);
}
}