Pass large amount of data through Posix queue - c

Question

I am trying to pass a large amount of data between threads in C (Raspberry with Debian).
I want to create 32 queues. I need to pass messages of 105 bytes each one. I want to pass 105 bytes each 4 ms to anothe thread for about 20 seconds (30 seconds top).
What I found with posix queues is that I cannot modify mq_msgsize parameter. I can modify mq_maxmsg but if I try to modify the other, queue does not work. It just work with 1024 bytes.
I think I have not understood mq_maxmsg and mq_msgsize parameters. I thought that mq_maxmsg is the number of messages I can store in the queue and mq_msgsize the size of each parameter.
In mq_send function I should pass the buffer I have with a value of 105 bytes.
In mq_receive function I should read 105 bytes each time.
Is this right?
If I try this, send/received does not work. Only with 1024.
This is how I am declaring the queues (I have 32 right now, but all of them are created equally):
#define Q_MOTOR_SIZE 1024
struct mq_attr mq_motor_attr;
mq_motor_attr.mq_flags = 0;
mq_motor_attr.mq_maxmsg = 10000;
mq_motor_attr.mq_msgsize = Q_MOTOR_SIZE; #I tried to change this value by 105
mq_motor_attr.mq_curmsgs = 0;
PR_mq_motor[0] = mq_open(MOTOR_0_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);
PR_mq_motor[1] = mq_open(MOTOR_1_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);
...
PR_mq_motor[31] = mq_open(MOTOR_31_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);
Every time I send a bunch of frames (105 bytes), should I send 1024 or it should work with 105 as packet size?
mq_send(PR_mq_motor[motor_counter], PR_queue_buffer, 1024, 0);
vs
mq_send(PR_mq_motor[motor_counter], PR_queue_buffer, 105, 0);
Same happens in the recevie part. If I try to read 105 instead of 1024, it crashes somewhere during the operation.
What should I do here? In case something needs to be modified on the raspi configuration, it is not a problem.
As #Shawn suggested. I implemented a linked list in order to have the 32 queues I wanted in the beggining.
I created some arrays to keep track of all the mutex to control access and the header of each list.
I think push is working fine but I have some kind of issue while popping elements.
As I said, I want to storage buffers of 8 bytes each one so I created the struct with buffers of 10 to be sure.
int16_t LL_M_Push(uint8_t LL_M_motor, uint8_t *LL_M_frame, uint16_t LL_M_size) {
pthread_mutex_lock(&PR_LL_M_lock[LL_M_motor]);
PR_LL_M_node_t *current = PR_LL_M_head[LL_M_motor];
if (current != NULL) {
while (current->next != NULL) {
current = current->next;
}
/* now we can add a new variable */
current->next = malloc(sizeof(PR_LL_M_node_t));
memcpy(current->next->val, LL_M_frame, LL_M_size);
current->next->next = NULL;
} else {
PR_LL_M_head[LL_M_motor] = malloc(sizeof(PR_LL_M_node_t));
memcpy(PR_LL_M_head[LL_M_motor]->val, LL_M_frame, LL_M_size);
PR_LL_M_head[LL_M_motor]->next = NULL;
}
PR_LL_M_counter[LL_M_motor]++;
pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);
return PR_LL_M_counter[LL_M_motor];
}
int16_t LL_M_Pop(uint8_t LL_M_motor, uint8_t *LL_M_element) {
uint8_t *retval;
PR_LL_M_node_t *next_node = NULL;
pthread_mutex_lock(&PR_LL_M_lock[LL_M_motor]);
if ((PR_LL_M_head[LL_M_motor] == NULL) || (PR_LL_M_counter[LL_M_motor] == 0)) {
pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);
return -1;
}
next_node = PR_LL_M_head[LL_M_motor]->next;
retval = PR_LL_M_head[LL_M_motor]->val;
memcpy(LL_M_element, retval, 10);
PR_LL_M_counter[LL_M_motor]--;
free(PR_LL_M_head[LL_M_motor]);
PR_LL_M_head[LL_M_motor] = next_node;
pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);
return PR_LL_M_counter[LL_M_motor];
}
Do you see something wrong here? Do you need something else?