Segmentation fault on Dining Philosophers in C with Pthreads - c

Question

I have this segmentation fault problem in the exercise of the dining philosophers with one thread per philosopher which I can't manage. Each threads think for a random period of time and same with eat. Each philosopher can eat with two forks, he has to pick both forks to eat. To avoid deadlock I made a sort for the picking forks. The philosophers with odd number pick the right fork first. I used a global semaphore which I initialize with the function init at the start of main. Is there someone who can help me please? I tried to put some fprintf(stderr,"HERE\n") but because of concurrency I can't find the problem. Here is the code
'''
//global array of semaphore
pthread_mutex_t *mtx;
//intialize array of semaphore
void init(pthread_mutex_t *mtx){
mtx=malloc(N*sizeof(pthread_mutex_t));
if(!mtx){
perror("malloc fallita\n");
exit(EXIT_FAILURE);
}
for(int i=0;i<N;i++){
if(pthread_mutex_init(&mtx[i],NULL) != 0){
perror("init fallita\n");
exit(EXIT_FAILURE);
}
}
}
void eat(unsigned int *seed){
long r = rand_r(seed) % 800000;
struct timespec t={0,r};
nanosleep(&t,NULL);
}
void think(unsigned int *seed){
long r = rand_r(seed) % 1000000;
struct timespec t={0,r};
nanosleep(&t,NULL);
}
void *filosofo(void *arg){
unsigned int id = *((unsigned int*)arg);
unsigned int seed=id;
int left = id % N;
int right = id-1;
while(1){
think(&seed);
if(id % 2){ //il filosofo di indice dispari prende prima la forchetta di destra
pthread_mutex_lock(&mtx[right]);
pthread_mutex_lock(&mtx[left]);
eat(&seed);
pthread_mutex_unlock(&mtx[left]);
pthread_mutex_unlock(&mtx[right]);
}else{ //il filosofo di indice pari prende prima la forchetta a sinista
pthread_mutex_lock(&mtx[left]);
pthread_mutex_lock(&mtx[right]);
eat(&seed);
pthread_mutex_unlock(&mtx[right]);
pthread_mutex_unlock(&mtx[left]);
}
}
pthread_exit(NULL);
}
int main(void){
init(mtx);
//array of N philosophers
pthread_t *th;
th = malloc(N*sizeof(pthread_t));
if(!th){
perror("Malloc fallita\n");
exit(EXIT_FAILURE);
}
for(unsigned int i=0;i<N;i++){
if(pthread_create(&th[i],NULL,filosofo,(void*)(intptr_t)i) != 0){
perror("create fallita\n");
exit(EXIT_FAILURE);
}
}
for(unsigned int i=0;i<N;i++){
if(pthread_join(th[i],NULL) == -1){
perror("join fallita\n");
}
}
free(th);
free(mtx);
return 0;
}
'''

Answer 1

You need to make init take a pointer to a pointer to a mutex to initialize. Currently, the global mtx isn't changed.
Here's roughly how:
void init(pthread_mutex_t **mtx){ // pointer to pointer
*mtx=malloc(N*sizeof(pthread_mutex_t)); // dereference
if(!*mtx){
perror("malloc fallita\n");
exit(EXIT_FAILURE);
}
for(int i=0;i<N;i++){
if(pthread_mutex_init(&(*mtx)[i],NULL) != 0){ // pointer acrobatics
perror("init fallita\n");
exit(EXIT_FAILURE);
}
}
}
and then pass a pointer to the global mtx in main:
int main(void){
init(&mtx);
I suggest naming your global mutex and your local mutex in init differently so this doesn't confuse you again.
Also, right here you're passing the value of i as a void *, instead of passing its address:
if(pthread_create(&th[i],NULL,filosofo,(void*)(intptr_t)i) != 0){
If you do this (which I actually recommend to avoid race conditions), then you should change filosofo to take input in the same way:
unsigned int id = (unsigned int)arg;