Segmentation fault after pthread_cancel - c

Question

In my program I have two threads, one calculates some recursive function and other displays "progress dots" as first threads does calculations. There is the code:
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#define test_errno(msg) do{if (errno) {perror(msg); exit(EXIT_FAILURE);}} while(0)
void *progressDotsThread(void* _arg){
for(int i=0;;i++){
printf(".");
fflush(stdout);
sleep(1);
}
}
void *seriesCalculateThread(void* n){
int result;
if((long)n==1) return (void*)(1);
else if((long)n==2) return (void*)(-5);
else{
int nmin1 = (long)seriesCalculateThread( (void*) ( (long)n -1 ));
int nmin2 = (long)seriesCalculateThread( (void*) ( (long)n -2 ));
result = nmin1*((long)n)*nmin2;
return (void*)(result);
}
}
int main(void) {
long n=0;
int result =0;
pthread_t w1,w2;
printf("Give n\n");
scanf ("%d",&n);
if(n<1){
printf("Value must be higher than 0");
}
else{
errno= pthread_create(&w2,NULL,seriesCalculateThread,(void *)n);
test_errno("pthread_create");
errno= pthread_create(&w1,NULL,progressDotsThread,NULL);
test_errno("pthread_create");
if(!pthread_join(w2,(void**)&result)){
errno = pthread_cancel(w1); //<--- Where segmentation fault happens
test_errno("pthread_cancel");
}
printf("%d\n", result);
}
return EXIT_SUCCESS;
}
I pthread_create both of them and then I if(!pthread_join) the one that does calculations and when calculations finish I cancel the one that display dots.
if(!pthread_join(w2,(void**)&result)){
errno = pthread_cancel(w1); //<--- Where segmentation fault happens
test_errno("pthread_cancel");
}
I do that although I get segmentation fault after pthread_cancel(w1) is called and I have no idea why that happens.
I tried compiling it terminal with gcc -g -Wall -pthread psthreadss.c -lpthread and it didn't work as well as in eclipse. I use Ubuntu 18.04 if that's revelant.

Answer 1

and then I if(!pthread_join) the one that does calculations and when calculations finish I cancel the one that display dots.
Your program has a logical bug, and a memory corruption bug.
The logical bug: you are assuming that !pthread_join means that calculations finished. It doesn't mean that. pthread_join returns non-zero status only if you invoked it with incorrect parameters (thread id w2 is not known, has not been started, or has already been joined).
Your code should instead look something like this:
int rc = pthread_join(w2, ...);
assert(rc == 0);
rc = pthread_cancel(w1);
assert (rc == 0);
On to the memory corruption bug: on a 64-bit system (which is what I assume you are using), sizeof(int) == sizeof(result) == 4, but sizeof(void*) == 8.
This code:
int result =0;
...
pthread_join(w1, (void**)&result)
takes an address of 4-byte result, and asks pthread_join to store an 8-byte value in there. Predictable outcome from this is stack corruption.
I don't see how exactly that triggers the SIGSEGV, but once you have undefined behavior in your program, all bets are off.
To fix this, change result type to intptr_t. I expect the crash to disappear after that fix.
You should also try to use Address Sanitizer: gcc -fsanitize=address -g ... before making any changes. There is a high chance it will tell you about stack overflow.