C: memory issue with pthread_create and struct parameter

It seems like I do have a memory leak, can somebody tell me what I am doing wrong?

I commented out some code so that it is a little bit more readable:

int main(int argc, char *argv[])
{
    pthread_t *tid = malloc(sizeof(pthread_t) * num);
    for (int i = 0; i < num; i++)
    {
        parameters *p = malloc(sizeof(parameters));
        p-> something = i;
        
        pthread_create(&tid[i], NULL, (void *)threadFunc, p);
    }
    // some heavy main logic
    for (int i = 0; i < num; i++)
    {
        pthread_cancel(tid[i]);
        pthread_join(tid[i], NULL);
    }
    free(tid);
    // End stuff
}
    
void *threadFunc(parameters *params)
{
    // take over params
    free(params);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    while (1)
    {
        // do magic
    }
}

There is no memory loss in the example provided.

Using the code from the OP and adjusted it with a few assumptions to make it compile. It does not show any memory loss using valgrind.

• Commands used to compile & memory check

$ gcc <source-goes-here> -lptread

$ valgrind --trace-children=yes --child-silent-after-fork=yes --leak-check=full --show-leak-kinds=all -s <compiled-program-here>

• Modified code to compile (with assumptions)

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// assumptions here:
typedef struct s_parameters { int something; int anotherthing[100][2]; }  parameters;
// end assumption

// added forward definition of function
void *threadFunc(parameters *);

int main(int argc, char *argv[])
{

// assumptions here:
int num=5;
parameters *p=NULL;
// end assumptions

    pthread_t *tid = malloc(sizeof(pthread_t) * num);
    for (int i = 0; i < num; i++)
    {
        parameters *p = malloc(sizeof(parameters));
        p-> something = i;

        pthread_create(&tid[i], NULL, (void *)threadFunc, p);
    }
    // some heavy main logic
    for (int i = 0; i < num; i++)
    {
        pthread_cancel(tid[i]);
        pthread_join(tid[i], NULL);
    }
    free(tid);
    // End stuff
}

void *threadFunc(parameters *params)
{
    // take over params
    free(params);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    while (1)
    {
        // do magic
    }
}

• valgrind output:

 HEAP SUMMARY:
     in use at exit: 0 bytes in 0 blocks
   total heap usage: 16 allocs, 16 frees, 7,130 bytes allocated

 All heap blocks were freed -- no leaks are possible

 ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Good luck