nikto_b/dummy_device_template
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make write via waiting buf

Browse Source
This commit is contained in:
Артур Шевченко
2026-04-12 16:33:44 +03:00
parent 5d6930d2bf
commit ff84fcfbf1
1 changed files with 86 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
src/device.c
View File

@@ -27,6 +27,9 @@ void freeDevMem(device_mem_t* devMem)
free(devMem->rawCells);
free(devMem->memreadCellAddrs);
free(devMem->memwriteCellAddrs);
free(devMem->memwriteCellSegments);
free(devMem->memwriteValues[0]);
free(devMem->memwriteValues);
free(devMem->cells);
free(devMem->smartAddrReadHandlers);
free(devMem->smartAddrWriteHandlers);
@@ -54,7 +57,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
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");
@@ -71,7 +74,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
}
}
void* rawCells = (void*)malloc(memTotalSize);
void* rawCells = (void*)calloc(memTotalSize, sizeof(void*));
if (rawCells == NULL)
{
sprintf(errbuf, "unable to allocate raw memory buf");
@@ -84,7 +87,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)
{
@@ -94,7 +97,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)
{
@@ -107,10 +110,10 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
{
cells[i] = rawCells + devSpec->memSpecs[i]->start;
cells[i] = (void*)((size_t)rawCells + (size_t)devSpec->memSpecs[i]->start);
}
char** cellNames = malloc(sizeof(char*) * devSpec->memSpecsCount);
char** cellNames = calloc(devSpec->memSpecsCount, sizeof(char*));
if(cellNames == NULL)
{
@@ -127,7 +130,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
cellNames[i] = devSpec->memSpecs[i]->name;
}
uint64_t* memreadCellAddrs = malloc(64 * sizeof(uint64_t));
uint64_t* memreadCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
if (memreadCellAddrs == NULL)
{
sprintf(errbuf, "unable to allocate read interception addrs");
@@ -138,7 +141,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)
{
@@ -152,38 +155,96 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL;
}
uint64_t smartAddrReadMask = 0;
uint64_t smartAddrWriteMask = 0;
mem_h_read_handler* smartAddrReadHandlers = malloc(sizeof(mem_h_read_handler) * memTotalSize);
uint8_t* memwriteCellSegments = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint8_t));
if (smartAddrReadHandlers == NULL)
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];
}
uint64_t smartAddrReadMask = 0;
uint64_t smartAddrWriteMask = 0;
mem_h_read_handler* smartAddrReadHandlers = calloc(memTotalSize, sizeof(mem_h_read_handler));
if (smartAddrReadHandlers == 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);
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(cells);
free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
return NULL;
}
@@ -254,6 +315,8 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
devMem->rawCells = rawCells;
devMem->memreadCellAddrs = memreadCellAddrs;
devMem->memwriteCellAddrs = memwriteCellAddrs;
devMem->memwriteCellSegments = memwriteCellSegments;
devMem->memwriteValues = memwriteValues;
devMem->memreadLen = 0;
devMem->memwriteLen = 0;
devMem->smartAddrReadMask = smartAddrReadMask;
@@ -279,7 +342,7 @@ uint8_t makeDeviceTick(device_public_context_t* devContext)
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");
@@ -542,7 +605,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
{
return NULL;
//TODO
device_specs_t* specs = malloc(sizeof(device_specs_t));
device_specs_t* specs = calloc(1, sizeof(device_specs_t));
if (specs == NULL)
{
return NULL;
@@ -551,7 +614,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");
@@ -561,7 +624,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");
@@ -573,7 +636,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);
@@ -622,7 +685,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
device_public_context_t* init(device_specs_t* specs, char* errbuf)
{
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");