Is Linux timer a process - c

Question

I'm trying to understand timers in linux to use it in my application, I've collected code from multiple sources and made the following program
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
#define CLOCKID CLOCK_REALTIME
#define SIG SIGUSR1
timer_t timerid;
void *print_message_function( void *ptr );
static void handler(int sig, siginfo_t *si, void *uc)
{
pthread_mutex_lock( &mutex1 );
printf("Caught signal %d from timer\n", sig);
//it will be working like this in real application
// 1. check the front of the queue, if timeout then detete it from queue
pthread_mutex_unlock( &mutex1 );
}
int main(int argc, char *argv[])
{
struct sigevent sev;
struct itimerspec its;
long long freq_nanosecs;
sigset_t mask;
struct sigaction sa;
printf("Establishing handler for signal %d\n", SIG);
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = handler;
sigemptyset(&sa.sa_mask);
sigaction(SIG, &sa, NULL);
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = SIG;
sev.sigev_value.sival_ptr = &timerid;
timer_create(CLOCKID, &sev, &timerid);
/* Start the timer */
its.it_value.tv_sec = 1;
its.it_value.tv_nsec = 0;
its.it_interval.tv_sec = its.it_value.tv_sec;
its.it_interval.tv_nsec = its.it_value.tv_nsec;
timer_settime(timerid, 0, &its, NULL);
pthread_t thread1, thread2;
char *message1 = "Thread 1";
int iret1 ;
/* Create independent threads each of which will execute function */
iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);
pthread_join( thread1, NULL);
printf("Thread 1 returns: %d\n",iret1);
exit(0);
}
void *print_message_function( void *ptr )
{
char *message;
message = (char *) ptr;
int i;
for(i=0;; i++){
pthread_mutex_lock( &mutex1 );
printf("%s \n", message);
//it will be working like this in real application
// 1. check if a response received from the network
// 2. if received then delete from queue
pthread_mutex_unlock( &mutex1 );
usleep(50022);
}
pause();
}
I'm trying to proctect the critical section which is in this case is the printf, the printf here is just an example, in my application it's actually a queue, so the thread will be working on the printf all the time and when the timer is ready it has to lock the mutex and then print, is the above the right way to do it?
In the real application, the thread will be waiting for a response and when the response is received by other application then I'll access the queue, the timer will always be checking the queue on a certain interval (e.g every 2 seconds) for timedout message and delete it if any found.

Answer 1

No, that is not the right way to do it. It is only allowed to call async-signal-safe functions from a singla handler. Otherwise the behavior is undefined:
«A signal handler function must be very careful, since processing
elsewhere may be interrupted at some arbitrary point in the execution
of the program. POSIX has the concept of “safe function”. If a signal
interrupts the execution of an unsafe function, and handler calls an
unsafe function, then the behavior of the program is undefined.»
For a bit more details, see man 7 signal.
If you are writing for Linux, consider using signalfd. Other operating systems have similar alternatives. For a long story, see «How Not To Write a Signal Handler».
Hope it helps. Good Luck!