Storing control information alongside allocated memory. Is it portable?

Question

Very briefly, we are trying to write some allocation routines (of type unsigned char) where each allocated block has some control information associated with it. We are not trying to write a full fledged memory manager but have some specific requirement

A sample of our control structure

typedef struct _control_data
{
   u8 is_segment;
   :
   :
   :
   struct _control_data* next;
}control_data;

When the user calls alloc for size 40, we will allocate

  unsigned char* data_ptr = (unsigned char*)malloc(sizeof(control_data) + size);
  return(&data_ptr[sizeof(control_data]);

Later the user will pass the pointer returned during alloc and we want to access the control information.

void do_some_processing(unsigned char* data_ptr)
   {
      struct control_data* c_ptr = (data_ptr - sizeof(control_data));
      c_ptr->is_segment = TRUE;
      c_ptr->next       = NULL;
   }

Is the above access legal and portable?

Is it guaranteed that the user will only access the area you allocate for him using `unsigned char`? If not, your code may not be portable due to alignment issues. — D Krueger, Oct 07 '13 at 17:07
If sizeof(control_data) % sizeof(void *) == 0 you should be ok. — Charlie Burns, Oct 07 '13 at 17:14

score 1 · Accepted Answer · edited May 23 '17 at 12:05

Yes, it should be fine and is a common technique.

A few points:

Don't cast the return value of malloc() in C.
Use pointer arithmetic to your advantage:

void * my_alloc(size_t size)
{
    control_data *cd = malloc(size + sizeof *cd);
    if(cd != NULL)
      return cd + 1;
    return NULL;
}

The + 1 will do exactly the right thing, but is way simpler. Also there's no point in making the allocation "typed"; let it return void * and leave it up to the caller to use an unsigned char * pointer to store the returned value.

UPDATE: As pointed out in a comment, this ignores alignment (which feels safe since you say the non-control data is an array of unsigned char) which might be a problem in the general case.

One other consideration (not clear to me from the OP's question): if the user of the allocated space has alignment constraints, you may have to round up your control-data area size a bit to meet those. (E.g., when using MMX/SSE for instance.) — torek, Oct 07 '13 at 17:01

Storing control information alongside allocated memory. Is it portable?

1 Answers1