设计和memory分配缓冲区memory

Question

My application has 3 layers -downlayer, middlelayer and upperlayer. downlayer and upperlayer are decoupled. Data passes either this way upperlayer -> middlelayer -> downlayer, or this way downlayer -> middlelayer->upperlayer.

My code look like this: UpperLayer.c

#include <middlelayer.h>

int upperReaddownData()
{
    DATA_ST* readFromdown_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));
    if(readFromdown_ptr != NULL)
    { 
      int retVal = GetFunction(readFromdown_ptr, UP);
      if (retVal == 0) {
          bool value;
          memcpy(&value, readFromdown_ptr->continousData, sizeof(bool));
              printf("Data read %s\t",
                  value ? "true" : "false");
              printf("\n");
          }
          // I get error here
      free(readFromdown_ptr);
      return 0;
    }
    else {
        return -1;
    }
}

int UpperWritedownData()
{
    bool  random = rand() % 2;
    DATA_ST* dumpTodown_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));
    if (dumpTodown_ptr != NULL) {
        size_t size_data = (size_t)sizeof(bool);
        memcpy(dumpTodown_ptr->continousData, &random, size_data);
        // size of data has to be mentioned while writing to memory
        dumpTodown_ptr->packetSize = size_data;
        int retVal = SetFunction(dumpTodown_ptr, DOWN);
        // i get error here
        free(dumpTodown_ptr);
        return 0;
    }
    else {
        return -1;
    }
}

middlelayer.h

#define UP 0x00
#define DOWN 0x01

#define BUFFER_SIZE 2

typedef struct
{
    size_t packetSize;
    uint8_t continousData[80];
}DATA_ST;

typedef struct
{
    bool isDataAlreadyRead;
    DATA_ST Data;
}PACKET_HEADER_ST;

int Init();
int GetFunction(DATA_ST* packet, uint8_t target);
int SetFunction(DATA_ST* packet, uint8_t target);
int DeInit();

middlelayer.c

   #include<middlelayer.h>

#define COPY_MEMORY(Dst,Src,Size) memcpy(Dst,Src,Size)

static PACKET_HEADER_ST* BUFFER[BUFFER_SIZE];

int Init()
{
    uint8_t instance;
    for (instance = 0; instance < BUFFER_SIZE; instance++) {
        BUFFER[instance] = (PACKET_HEADER_ST*)calloc(1,sizeof(PACKET_HEADER_ST));
        if (BUFFER[instance] != NULL)
        {
            BUFFER[instance]->isDataAlreadyRead = true;
        }
        else 
        {
            return -1;
        }
    }
    return 0;
}

int GetFunction(DATA_ST* packet,uint8_t target)
{
    DATA_ST* currPacket = NULL;
    if (BUFFER[target]->isDataAlreadyRead == false)
    {
        // not getting how to use memcpy properly
        //currPacket = (DATA_ST*)&BUFFER[target]->Data;
        //COPY_MEMORY(packet->continousData, currPacket->continousData, sizeof(BUFFER[target]->Data.packetSize));
        //packet->packetSize = currPacket->packetSize;
        //BUFFER[target]->isDataAlreadyRead = true;
        *packet = BUFFER[target]->Data;
    }
    else
    {
        return -1;
    }
    return 0;
}

int SetFunction(DATA_ST* packet, uint8_t target)
{
    //COPY_MEMORY(BUFFER[target]->Data.continousData, packet->continousData,sizeof(packet->packetSize));
    //BUFFER[target]->Data.packetSize = packet->packetSize;
    //BUFFER[target]->isDataAlreadyRead = false;
    BUFFER[target]->Data = *packet;
    BUFFER[target]->isDataAlreadyRead = false;
    return 0;
}

int DeInit()
{
    uint8_t instance;
    for (instance = 0; instance < BUFFER_SIZE; instance++) {    
        free(BUFFER[instance]);
    }
    return 0;
}

lowerlayer.c

#include<middlelayer.h>

int downReadUpData(void)

{
    DATA_ST* readFromDown_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));
    if (readFromDown_ptr != NULL)
    {
        int retVal = GetFunction(readFromDown_ptr,DOWN);
        if (retVal == 0) {
            bool mybool;
            
            memcpy(&mybool, readFromDown_ptr->continousData,readFromDown_ptr->packetSize);
            // do something with data
            
        }
        // i get error here
        free(readFromDown_ptr); 
        readFromDown_ptr = NULL;
        return retVal;
    }
    else {
        return -1;
    }
}

//send dummy data to Up
int downWriteUpData(void)
{
    static bool race_b = false;
    DATA_ST* dumpToUp_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));
    if (dumpToUp_ptr != NULL) {
        size_t size_data = (size_t)sizeof(bool);
        memcpy(dumpToUp_ptr->continousData, &race_b, size_data);
        // size of data has to be mentioned while writing to memory
        dumpToUp_ptr->packetSize = size_data;
        int retVal = SetFunction(dumpToUp_ptr, UP);
        // i get error here
        free(dumpToUp_ptr);
        dumpToUp_ptr = NULL;
        race_b = !race_b;
        return retVal;
    }
    else {
        return -1;
    }
}

I call UpperWritedownData function, it calls SetFunction, then i call downReadUpData Function and read the data passed by Upper layer.

I want to design the middlelayer like this: you pass the data of any datatype to the middlelayer(uint8_t array can hold any datatype), during Init,the middlelayer is allocated some memory and i have the pointer of BUFFER[Up]->Data or BUFFER[DOWN]->Data and these pointers are constant and should not change throughout the program. Now upper/down layer gives data (SetFunction), i dump it in my preallocated memory, then after some time, down/upper asks the data i copy the data from my preallocated memory and give it.Now I just need to store the recent data hence i have not implemented queues also i am overwriting and once the data is read, i dont care about it and I have to discard it.

What I tried: I tried using memcpy and copy the pointer to BUFFER[x]->Data and I have commented that part of code as you can see.It did not work because memcpy copies the pointer to BUFFER[target]->Data but i wanted to copy just the contents.When I tried to use free(pointer), i get heap corruption error message.I am having trouble in using memory allocation. Kindly provide inputs.

Answer 1

There is a bug in this malloc :

DATA_ST* readFromdown_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));

You define readFromdown_ptr as a pointer to DATA_ST . So you want to make it point to a memory block that can hold a DATA_ST but you only allocate memory for a pointer to DATA_ST because you do sizeof(DATA_ST*) .

Change it to:

DATA_ST* readFromdown_ptr = malloc(sizeof(DATA_ST));

or better.. change it to:

DATA_ST* readFromdown_ptr = malloc(sizeof *readFromdown_ptr);

The same applies to the line:

DATA_ST* dumpToUp_ptr = (DATA_ST*)malloc(sizeof(DATA_ST*));