Problem $3$: $(8$ pts$)$ SIGNALS and THREADS

Read the C$-$based pseudo$-$code that executes on an OUTDATED Linux version. Assume that each thread inherits the signal handlers set by the main process just before the call to pthread$\_$create, and that that the particular thread is impervious to the changes of signal handlers from other threads or the main process once pthread$\_$create has been invoked $($this is not true for most of the modern OSs but here we work on a fictitious problem$).$ For the sake of this problem only, assume that terminating signals that are sent to one thread alone only terminate the thread that handles these.

Also, assume that for signals that need to be handled only once, the algorithm that is used by the OS to select which thread will handle the signal is the following: find the first thread that is not blocking or ignoring the signal selected randomly, but first start from the thread that is now on the processor. Use these assumptions above to answer the questions below the pseudo$-$code presented. Remember, for some of the questions you may need to explore numerous scenarios.

#include

#include

#include

#include

#include

atomiclock$=0$;

typedef struct data $\{$

char name$[10]$;

$\}$ data;

void sig$\_$func$($int sig$)\{$

write$(1,$Caught signal no $=\%$d

$,$ sig$)$;

signal$($sig$,$ sig$\_$func$)$;

$\}$

void sig$\_$func$2($int sig$)\{$

write$(1,$Caught signal no $=\%$d

$,$ sig$)$;

$\}$

void func$($data $*$p$)\{$

int x;

snprintf$($p$->$name,$10,\%$d$,($int$)$pthread$\_$self$())$; $//$ could also do itoa$()$;

x $=($int$)$pthead$\_$self$()/(($getpid$()*(-1+$ lock$++))$;

sleep$(10)$; $//$ sleep to catch the signals

$\}$

int main$()\{/*$ A$0*/$

pthread$\_$t tid$1,$ tid$2,$ tid$3$;

data $*$ptr;

int pid;

signal $($SIGINT$,$ SIG$\_$IGN$)$;

pthread$\_$create$($&tid$1,0,($void$*)$func$,$ ptr$)$;

signal$($SIGSEGV$,$ sig$\_$func$)$;

signal$($SIGSTOP$,$ sig$\_$func$)$;

pthread$\_$create$($&tid$2,0,($void$*)$func$,$ ptr$)$;

signal$($SIGFPE$,$ sig$\_$func$)$;

signal$($SIGINT$,$ sig$\_$func$2)$;

pthread$\_$create$($&tid$3,0,($void$*)$func$,$ ptr$)$;

$/*$ A $*/$

pid $=$ getpid$()$;

sleep$(10)$; $//$Leave time for initializations and executing func for all threads $/*$ B $*/$

pthread$\_$kill$($tid$1,$ SIGSEGV$)$; $//$ Line A

pthread$\_$kill$($tid$2,$ SIGSTOP$)$; $//$ Line B

pthread$\_$kill$($tid$2,$ SIGSEGV$)$; $//$ Line C

pthread$\_$kill$($tid$1,$ SIGINT$)$; $//$ Line D

pthread$\_$kill$($tid$3,$ SIGINT$)$; $//$ Line E

sleep$(20)$;

pthread$\_$join$($tid$1,$NULL$)$;

pthread$\_$join$($tid$2,$NULL$)$;

pthread$\_$join$($tid$3,$NULL$)$;

$\}$

Part $1$: $(2$ pts$)$

Q$1$: Which of the three threads is the first to execute func? Why?

Q$2$: Assume that thread tid$3$ executes func first $($ignore lines after $/*$A$*/).$ If there is action, who triggers it and who is the recipient? How is it handled?

Part $2$: $(3$ pts$)$

Once all threads are created, move on to part $/*$ B $*/.$ For every line in question, ignore all the rest of the lines and describe what happens in main $($e$.$g$.,$ when asked about line C$,$ ignore lines: A$,$ B$,$ D$,$ E$)$: what signal if any, how and by who it gets handled. Are there more than one possibilities?

Q$1$: Line B: Execute $3$ times in a row:

Q$2$: Line D: Execute $3$ times in a row:

Part $3$: $(3$ pts$)$

Ignore lines after $/*$ B $*/.$ Assume that another user opened a terminal to send to process pid the following signals $3$ times each. How do you IMAGINE $($do not run this because the above program is pseudo$-$code$)$ the delivered signal is handled by pid every time? Is there more than one possibility? If so which and why? If not, why not? Q$1$: kill $($pid$,2)$;

Q$2$: kill $($pid$,11)$;

Q$3$: kill $($pid$,3)$;

Solution: