nikto_b/hmmmm_avr_generic
1
0
Fork 0
Code Issues Pull Requests Actions 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->rawCells);
free(devMem->memreadCellAddrs); free(devMem->memreadCellAddrs);
free(devMem->memwriteCellAddrs); free(devMem->memwriteCellAddrs);
free(devMem->memwriteCellSegments);
free(devMem->memwriteValues[0]);
free(devMem->memwriteValues);
free(devMem->cells); free(devMem->cells);
free(devMem->smartAddrReadHandlers); free(devMem->smartAddrReadHandlers);
free(devMem->smartAddrWriteHandlers); free(devMem->smartAddrWriteHandlers);
@@ -54,7 +57,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL; 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) if (devMem == NULL)
{ {
sprintf(errbuf, "unable to allocate dev memory struct"); 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) if (rawCells == NULL)
{ {
sprintf(errbuf, "unable to allocate raw memory buf"); 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; ((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) if(devMem->memsegShifts == NULL)
{ {
@@ -94,7 +97,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL; return NULL;
} }
void** cells = malloc(devSpec->memSpecsCount * sizeof(void*)); void** cells = calloc(devSpec->memSpecsCount, sizeof(void*));
if (cells == NULL) 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++) 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) if(cellNames == NULL)
{ {
@@ -127,7 +130,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
cellNames[i] = devSpec->memSpecs[i]->name; 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) if (memreadCellAddrs == NULL)
{ {
sprintf(errbuf, "unable to allocate read interception addrs"); sprintf(errbuf, "unable to allocate read interception addrs");
@@ -138,7 +141,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
free(cellNames); free(cellNames);
return NULL; 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) if (memwriteCellAddrs == NULL)
{ {
@@ -152,38 +155,96 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
return NULL; return NULL;
} }
uint64_t smartAddrReadMask = 0; uint8_t* memwriteCellSegments = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint8_t));
uint64_t smartAddrWriteMask = 0;
mem_h_read_handler* smartAddrReadHandlers = malloc(sizeof(mem_h_read_handler) * memTotalSize);
if(memwriteCellSegments == NULL)
if (smartAddrReadHandlers == NULL)
{ {
sprintf(errbuf, "unable to allocate read interception handlers"); sprintf(errbuf, "unable to allocate write interception addrs");
free(memwriteCellAddrs);
free(devMem->memsegShifts); free(devMem->memsegShifts);
free(devMem); free(devMem);
free(rawCells); free(rawCells);
free(memreadCellAddrs); free(memreadCellAddrs);
free(cells); free(cells);
free(cellNames); free(cellNames);
free(memwriteCellAddrs);
return NULL; 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) if (smartAddrWriteHandlers == NULL)
{ {
sprintf(errbuf, "unable to allocate write interception handlers"); sprintf(errbuf, "unable to allocate write interception handlers");
free(smartAddrReadHandlers); free(smartAddrReadHandlers);
free(memwriteCellAddrs);
free(devMem->memsegShifts); free(devMem->memsegShifts);
free(devMem); free(devMem);
free(rawCells); free(rawCells);
free(memreadCellAddrs); free(memreadCellAddrs);
free(cells); free(cells);
free(cellNames); free(cellNames);
free(memwriteCellAddrs);
free(memwriteCellSegments);
free(memwriteValues);
free(memwriteValuesContainers);
return NULL; return NULL;
} }
@@ -254,6 +315,8 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
devMem->rawCells = rawCells; devMem->rawCells = rawCells;
devMem->memreadCellAddrs = memreadCellAddrs; devMem->memreadCellAddrs = memreadCellAddrs;
devMem->memwriteCellAddrs = memwriteCellAddrs; devMem->memwriteCellAddrs = memwriteCellAddrs;
devMem->memwriteCellSegments = memwriteCellSegments;
devMem->memwriteValues = memwriteValues;
devMem->memreadLen = 0; devMem->memreadLen = 0;
devMem->memwriteLen = 0; devMem->memwriteLen = 0;
devMem->smartAddrReadMask = smartAddrReadMask; 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* 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) if (devInfo == NULL)
{ {
sprintf(errbuf, "unable to allocate dev info"); 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; return NULL;
//TODO //TODO
device_specs_t* specs = malloc(sizeof(device_specs_t)); device_specs_t* specs = calloc(1, sizeof(device_specs_t));
if (specs == NULL) if (specs == NULL)
{ {
return NULL; return NULL;
@@ -551,7 +614,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
specs->memSpecsCount = 4; 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) if (specs->memSpecs == NULL)
{ {
sprintf(errbuf, "unable to allocate default mem segment specs"); 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->executableSegmentsCount = 1;
specs->executableSegments = malloc(sizeof(uint8_t) * 1); specs->executableSegments = calloc(1, sizeof(uint8_t));
if (specs->executableSegments == NULL) if (specs->executableSegments == NULL)
{ {
sprintf(errbuf, "unable to allocate default executable segments"); 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++) 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) if (specs->memSpecs[i] == NULL)
{ {
sprintf(errbuf, "unable to allocate default mem seg spec %u", i); 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* 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) if (pubDevContext == NULL)
{ {
sprintf(errbuf, "unable to allocate public context"); sprintf(errbuf, "unable to allocate public context");