Nanosleep in signal call

Hi @ll

I have a problem with my code but first a short description:

1. I have one signal call SIGUSR1
2. In the signal I try to use nanosleep and now:

When I put kill -SIGUSR1 pid --> sometimes works fine, sometimes returns me an error with ,,Interrupt system call", sometimes I got error with "Success". Why? What mistake did I make? How to improve that?

My code:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <time.h>

void handler_signal(int signal)
{
   const char *signal_name;
   sigset_t pending; // syngaly oczekujace
   int losowy_czas ;  
   struct timespec ts; 
   int ret; 
   
   
   losowy_czas = rand() % 15 + 5;  
   ts.tv_sec = 0; 
   ts.tv_nsec = losowy_czas * 100000000;
   
   ret = clock_nanosleep(CLOCK_MONOTONIC,0,&ts,NULL); 

   if(ret)
	perror("Blad funkcji clock_nanosleep");   	


   switch(signal)
   {
   	case SIGUSR1:
		signal_name = "SIGUSR1"; 
		break;
	default:
		fprintf(stderr,"Zlapany zly sygnal: %d \n", signal); 
		return; 
  }

  //unsafe I know ! 
  printf("To ja - sygnal ! %s Wylosowany czas %d \n", signal_name,losowy_czas);  

}
int main(int argc, char *argv[])
{
   int i; 
   char *endptr; 
 
   struct sigaction sa; 	
 
  
   srand((unsigned int) time(NULL)); 
   /*     PROCES P    */


   sa.sa_handler = &handler_signal;
   sa.sa_flags = SA_RESTART; 
   
   sigfillset(&sa.sa_mask); 
   
   if(sigaction(SIGUSR1,&sa,NULL) == -1)
   {
	perror("Nie mozna obsluzyc SIGUSR1");	
   }

   
   for(i=0; i<2000; i++)
   {
     printf("Running %i \n", i);
     sleep(1); 
   }  

   return;
}

I believe rand() is not async safe as well - you cannot have interruptible calls in your signal handler. Well make that should not have. It uses global variables which is another problem. Plus you are doing a lot in your signal handler, so also consider blocking SIGUSR1 as the first step in your handler. Multiple signals can mess up your code otherwise - especially the rand() call. New applications should use the POSIX signal API (sigaction(2), sigprocmask(2), etc.) which is what you did and that is good.

Next:

signal_name = "SIGUSR1";

could SEGFAULT, but in any case it is undefined behavior: const *signal_name;

THX for ansewer, mate !

Ok, so: I have to have some random numbers - Can I do that better? (1)
Second - I try to block SIGUSR1 -I will be grateful if you could tell if I do this in the right way.

void handler_signal(int signal)
{
   sigset_t pending; // syngaly oczekujace
   int losowy_czas ;  
   struct timespec ts; 
   int ret; 
   sigset_t mask; 
  
   sigemptyset (&mask);
   sigaddset (&mask, SIGUSR1); // block SIGUSR1
   
   srand((unsigned int) time(NULL));    //transfer RAND here
   losowy_czas = rand() % 15 + 5;  
   ts.tv_sec = 0; 
   ts.tv_nsec = losowy_czas * 100000000;
   
   ret = clock_nanosleep(CLOCK_MONOTONIC,0,&ts,NULL); 

   if(ret)
	perror("Blad funkcji clock_nanosleep");   	


   switch(signal)
   {
   	case SIGUSR1: 
		break;
	default:
		fprintf(stderr,"Zlapany zly sygnal: %d \n", signal); 
		return; 
  }

  //unsafe
  printf("To ja - sygnal !  Wylosowany czas %d \n", losowy_czas);  

}

In the singal will be some read function but first I want to have sure that everything is all right.

I am guessing you do not want signal handling at all, other than cleaning up open files and buffers when your app gets a SIGTERM, for example.

Why? read .

This says you are designing an app that has an associated process that is doing reads.
Consider another standard IPC model instead. They are a much better choice if you must do reads in one process.

Overview:
http://www.tldp.org/LDP/tlk/ipc/ipc.html

Pipes are great, they are very like playing with files.
The GNU C Library: Creating a Pipe

Shared memory among processes is also a great feature. You can atomically set a variable in shared memory, then execute a read into a buffer there.
Use semaphores for traffic control. This one is straightforward to get right.
shm_overview(7) - Linux manual page

Overall, consider getting a copy of 3rd Edition of Stevens & Rago 'Advanced Programming in the UNIX Environment'. Michael Kerrisk has done the same thing purely for Linux - 'The LINUX Programming Interface'

Both of these have great examples of all of IPC, and explain how not to shoot yourself in the foot. Like you seemed to want to do. They fully cover signals as well, if you cannot change your system design, and have to continue into the Dark Side.

Have a good New Year!

Thank you very much ! However I have to do this part of work with signals.. next chapter will be pipe... Anyhow I will trying to clean code just a little bit, remove printf - unsafe method, write code associated with read and we will see.

Thx one more time and Happy 2016 mate !

Its always best to keep it simple.
Most texts you read on signals recommend getting out of the handler ASAP.
A simple way it just use the handler to set a flag.

static int signal;

void call_cleanup(int sig)
{
     signal = sig;
}

int sigs[] = { 1, 2, 3, 15, 0 };
set_signal_handler(sigs, call_cleanup);

for (;;) {
      
    if (signal) break;

    blah(this)
    blah(that);

}

// cleanup code here