Problem of allocating memory for a global struct and free it

Question

I am using a embedded board with FreeRTOS.

In a task, I defined two structs and use pvPortMalloc to allocate memory. (One struct is a member in the other)

Besides, I pass the address of struct to some functions.

However, there are some issues about freeing the memory using vPortFree.

The following is my code (test_task.c):

/* Struct definition */
typedef struct __attribute__((packed)) {

        uint8_t  num_parameter;
        uint32_t member1;
        uint8_t  member2;
        uint8_t  *parameter;

}struct_member;

typedef struct __attribute__((packed)) {

        uint16_t num_member; 
        uint32_t class;
        struct_member *member;

}struct_master;

I define a global struct and an array below.

uint8_t       *arr;
struct_master master:

Function definition:

void decode_func(struct_master *master, uint8_t *arr) 
{
   master->member = pvPortMalloc(master->num_member);

   for(int i = 0; i < scr->num_command; ++i){
      master->member[i].parameter = pvPortMalloc(master->member[i].num_parameter);
      do_something();
   }  
}

The operation task is shown in the following.

At the end of task, I would like to free memory:

void test_task()
{
  decode_func( &master, arr);
  do_operation(); 


  vPortFree(master.member);
  for (int i = 0; i < master.num_member; ++i)
      vPortFree(master.member[i].parameter);

  hTest_task = NULL;
  vTaskDelete(NULL);    
}

It is ok to free master.member.

However, when the program tried free master.member[i].parameter, it seems that freeing had been executed before and software just reset automatically.

Does anyone know why it happened like that?

Answer 1

At the very first glance, the way you allocate for members is wrong in the decode_func.

I assume that master->num_member indicates the number of struct members that master should contain.

master->member = pvPortMalloc(master->num_member);

should be corrected to,

master->member = pvPortMalloc(master->num_member * sizeof(struct_member));

Again, in the same function the loop seems a bit suspicious as well.

   for(int i = 0; i < scr->num_command; ++i){
      master->member[i].parameter = pvPortMalloc(master->member[i].num_parameter);
      do_something();
   } 

I'm not sure what src->num_command indicates, but naturally I reckon the loop should execute until i < master->num_member. I assume your loop should be updated as follows as well,

   for(int i = 0; i < master->num_member; ++i){
      master->member[i].parameter = pvPortMalloc(master->member[i].num_parameter * sizeof(uint8_t));
      do_something();
   } 

While doing the freeing of memory, make sure you free the contained members first before freeing the container structure. Therefore you should first free all the parameters and then the member, so change that order in test_task function as well.

Also make sure that before doing vTaskDelete(NULL); you must deallocate all the resources consumed by test_task, otherwise there will be a resource leak. vTaskDelete(NULL) will simply mark the TCB of that particular task as ready to be deleted so that at some time later the idle task will purge the TCB related resources.