TDC368 UNIX and Network Programming Week 5-6: Named Pipe Asynchronous Events UNIX Signals Camelia Zlatea, PhD Email: czlatea@cs.depaul.edu

Overview Pipe Inter Process Communication (IPC ) Pipes internally are called FIFO files can be read or written only sequentially comparing with regular files FIFO files (or pipes) use only directly addressable blocks (for this reason there is a limit for the maximum size of the pipe PIPE_BUF (defined in <limits.h>) at a given time only one process can access a FIFO file for reading or writing Operations On Pipes: open, read, write, close a read operation always succeeds on pipe (FIFO file). If the pipe is empty then the process sleeps until the pipe is written by another process. Otherwise the read function will return the actual number of bytes read. a write operation on pipe will succeed if there is enough space to write into the FIFO file. Otherwise, the process that called write will sleep until the pipe is read from by another process, thus more space is created if there are processes sleeping on read request and the last writer process closes the pipe, then the sleeping processes are wake-up and return 0 bytes. if there are processes sleeping on write request and the last reader process closes the pipe, then the sleeping processes are sent an error signal.

Unamed Pipe ( see also TDC368_week3_4.ppt) A template to implement communication via unnamed pipes: 1.      create the pipe(s) necessaries 2.      generate the child process(es) 3.      close/duplicate file descriptors to associate correctly the ends of the pipe 4.      close the unneeded file descriptors (ends of the pipe) 5.      execute necessaries operations 6.      close the remaining file descriptors for more accuracy, wait for child process to terminate

Named Pipes Concept: Create a named pipe at the shell level Example: special file of type FIFO an inod is associated with the named pipe named pipe has a directory entry difference between ordinary files and named pipes is in how read and write operations are synchronized when accessing the file. Kernel ensures that a read does not wait on an empty pipe, nor a write wait on a full pipe. In these cases the processes will sleep, and they will be wake-up when the required event take place. can be shared by unrelated processes Create a named pipe at the shell level mknod file_pipe p - argument file_pipe is the name of the pipe argument “p” notifies mknod to create a named pipe file type for “file_pipe” is “p” (see ls -l file_pipe) mkfifo –p file_pipe ( use this on hawk ) Example: mkfifo –p PIPE ls - l > PIPE & cat < PIPE

Named Pipes System call to generate a named pipe - mknod #include <sys/types.h> #include <sys/stat.h> int mknod(const char *path, mode_t, 0); /* for non-privileged users */ UNIX I/O function - mkfifo int mkfifo(const char *path, mode_t mode);

Asynchronous Events Examples of process events: a signal from another process an interrupt from a device completion of a I/O request Signals are events delivered to a process via UNIX. The process has no control over when they arrive. Signals are understood as software version of hardware interrupts. Signals can be generated by: hardware: ex: division by zero, illegal address access kernel: ex: completion of a I/O request issued by the waiting process user processes: ex: communication among processes related to relevant events, child termination notified to parent user actions: ex: pressing the keyboard sequence for: quit, interrupt To find the current mapping of the key sequences for various signals, call shell command: stty -a Example: SIGINT is mapped to "ctrl + c" (or DEL)

Some important signals Signal SigNr Default Meaning SIGALARM 14 EXit Setting an allarm clock SIGCHLD 18 Ignore Child status changed SIGFPF 8 Exit,core Arithmetic exception SIGHUP 1 Exit Hangup SIGINT 2 Exit Interrupt SIGKILL 9 Exit Killed SIGQUIT 3 Exit,core Quit SIGSTOP 23 Stop Stopped (signal) SIGTERM 15 Exit Terminated SIGUSR1 16 Exit User signal 1 SIGUSR2 17 Exit User signal 2

Systems Calls/Commands (Common UNIX signals (pp Systems Calls/Commands (Common UNIX signals (pp.266-270 textbook Stevens) kill system call sends a signal to a process #include <sys/types.h> #include <signal.h> int kill(pid_t pid, int signo); the argument pid determines how the signal is handled and to which process it applies. if pid > 0 then the signal applies to process with ID = pid if pid = 0 then the signal applies to all processes from the Process Group if pid = -1 then the signal applies to all processes with UID = EUID of sender UNIX exploits the power of the superuser in a clever manner. For example to execute command “df” (display disk free blocks) the process need to red bloc 0, where this information resides. Superuser is able to read bloc 0, but not a non-privileged user. In this case executable “df” has setuid bit set on. This bit is part of the protectiin mode word, whose protection part uses only 9bits (the other being left for other purposes). Thus, when a user calls “df” , the effective EUID of process “df” becomes equal with UID of the superuser. if pid < -1 then the signal applies to all processes in the process group with GID = |pid| ; the argument signo - the signal number. kill command: %kill [-signal] pid1 pid2 …. kill -l list all signals known by kill

More about kill kill –0 pid --- test to see of process pid is still in the system kill(pid, 0); --- test to see of process pid is still in the system

Unix System Calls to handle signals Signal system call is used to install signal handlers. /* legacy UNIX API */ #include <signal.h> void (*signal(int signo, void (*handler)(int)))(int); void (*sigset (int sig_no, void (*handler)(int)))(int); The second parameter of the signal system call is a pointer to a function that returns void and takes a single integer as its argument, and the return value of signal itself is a pointer to a function that returns void and takes a single integer argument. The second parameter to signal is a pointer to the function to call whenever the signal is delivered. The return value is the previous signal handler that was installed before the new one was added.

Calling prototype for signal() and sigset() signal() and sigset() take two arguments, an integer sig and a pointer to a function, catcher() that returns nothing, to be called when sig occurs if invocation of signal() is successful it returns a pointer to the previous disposition of catcher() function if invocation of sigset() is successful and sig is not blocked it returns a pointer to the previous disposition of catcher() if invocation of sigset() is successful and sig is blocked it returns SIG HOLD (int) at the end of prototype indicate that catcher() takes an integer (sig number) as argument

Signal management A process can associate a signal catching function with every signal by either signal() or sigset() system calls Upon the receipt of a signal for which a catcher() is installed the system calls catcher() to process the signal the catcher() must be reinstalled in order to catch other signals; however, race conditions may occur in this way ONLY when using signal() system call

Signal Acceptance Signals can be generated by outside events. When a process receives a signal then the following actions can be taken: ignore the signal terminate the process (the default action SIG_DFL) process the signal - take a particular action

Signal Acceptance Ignore the signal #include <stdio.h> Program that ignores control-C. When an INT signal (control-C) is Received, the process ignores it (SIG_IGN is the handler) #include <stdio.h> #include <sys/types.h> #include <signal.h> int main (void) { signal (SIGINT, SIG_IGN); while(1) { printf("Hello\n"); }

Signal Acceptance 2. Terminate the process (the default action SIG_DFL) Default action (see manual pages man signal) is the action executed if nothing else #include <iostream.h> #include <signal.h> int main() { signal(SIGINT, SIG_DFL); /* catch signal SIGINT=2 */ pause(); /* wait for a signal interruption */ }

Terminate the process (the default action SIG_DFL) Default action (see manual pages man signal) is the action executed if nothing else is specified related to a particular signal: exit - executes all actions associated with exit system call #include <unistd.h> void _exit(int status); When terminating a process the following actions are performed: all open file descriptors are closed child notifies termination to his parent by signaling SIGCHLD if parent is waiting for the child to terminate, then status information is returned to it. all children of the terminating process will have their PPID set to 1 (init process adopts them) if terminating process is a group leader, then al the group members will be sent SIGHUP or SIGCONT signals core - generate a file - core image and then exit stop - suspend the execution of the process (SIGSTOP cannot be caught or ignored) ignore - the signal has no effect on the process

Signal Acceptance 3. Handle the signal - Take a particular action The target process executes the action associated with the signal. Processing the signal depends also on the state of the process and level of priority. Signals can be caught by specifying a signal catching routine. The signals SIGKILL and SIGSTOP are never caught and they always terminate a process. #include <stdio.h> #include <sys/types.h> #include <signal.h> void action (int sig){ signal (SIGINT, action); printf ("control-C won't stop this process!\n"); } int main (void){ signal (SIGINT, action); while(1) { printf("Hello\n"); }

Handle the signal - Take a particular action (con’t) The action taken when a signal is generated depends on: ·        signal handler ·        process signal mask Process signal mask (data structure part of the process table managed by the kernel) shows which signals are being ignored, which are being caught, which are being temporarily blocked and which are in the process of being delivered. A blocked signal is not the same as an ignored signal. Its action is delayed until the process unblocks the pending signal.

Signal Handling Example #include <stdio.h> #include <signal.h> /* signal handler function */ void action(int sig_no) { signal(sig_no, action); fprintf(stderr,"Catch signal: %d\n", sig_no); } int main() { signal(SIGINT, action); signal(SIGALRM, SIG_DFL); signal(SIGTERM, SIG_IGN); pause(); /* wait for a signal interruption */

Delay execution Pause system calll #include <unistd.h> pause system call suspends the calling process until a signal (which is not ignored) will be received by invoking pause the process will no longer use CPU , while waiting for the event; thus busy waiting is avoided] #include <unistd.h> unsigned pause();

Alarm Handling Alarm system function #include <unistd.h> Sets a timer for the caller process and generates SIGALRM (signal number 14) after the specified number of seconds have passed. #include <unistd.h> unsigned alarm(unsigned nosec);

Alarm Handling Example, alarm system calls cannot be stacked: // when this system call is invoked // the previous pending // alarm signal is canceled; // the timer is set to 20sec alarm(0); // this system call reset the timer, // any pending alarm system call is canceled int main(void) { alarm(20); while (1) fprintf(stderr,"Hello\n"); }

Simulating sleep by using alarm and pause // // Simulating sleep by using alarm and pause #include <stdio.h> #include <signal.h> #include <unistd.h>   void wakeup() { }; unsigned int sleep ( unsigned int timer ) { if (sigset(SIGALRM, wakeup)==-1) { perror("sigset"); return 1; } (void)alarm( timer ); (void)pause(); return 0;

Example of Handling Time-out Situations #include <stdio.h> #include <unistd.h> #include <signal.h> int main(void) { char buf[256]; int n; signal(SIGALRM, timeout); alarm(30); // set timer while ((n=read(0,buf,sizeof(buf))<0) ; alarm(0); // reset timer exit(0); } void timeout() { fprintf(stderr,"Timeout error\n"); exit(0); }

Example: A parent forks 10 children processes, each child sleep a random number of seconds . Parent process waits for child processes to terminate. Once a child process has terminated, then the parent will terminate all the remaining child processes, by signaling SIGTERM to each of them. #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <sys/wait.h> #include <signal.h> #include <stdlib.h> int main() { pid_t p, q; int i, n, status; for (i=0; i<10 ; i++) { if ((p=fork())<0) { fprintf(stderr, "cannot fork\n"); exit(1); } if (pid == 0) break; }

Example: variant 1 if (p==0) /* child code */ { n = (int)(getpid()%256); srand((unsigned)pid); sleep(rand() %5); } else /* parent code */ { if ((q=waitpid(0,&status,0))>0) { kill(0,SIGTERM); while ((q=wait(&status)) && q !=-1) { if (q!=-1) { if (WIFSIGNALED(status)) fprintf(stderr, "Child with PID = %d has received signal %04X\n",q,WTERMSIG(status); } exit(0);

Example:variant 2 if (p==0) /* child code */ { signal(SIGTERM, action); n = (int)(getpid()%256); srand((unsigned)pid); sleep(rand() %5); } else /* parent code */ { if ((q=waitpid(0,&status,0))>0) { kill(0,SIGTERM); while ((q=wait(&status)) && q !=-1) { if (q!=-1) { if (WIFSIGNALED(status)) fprintf(stderr, "Child with PID = %d has received signal %04X\n",q,WTERMSIG(status); } exit(0); void action() { pid_t pid; pid=getpid(); fprintf(stderr, "Child with PID = %d is terminating with SIGTERM\n",pid); kill(pid, SIGTERM); /* raise(SIGTERM); */ }

Solutions for Concurrency and I/O Non-determinism Use nonblocking I/O use fcntl() to set O_NONBLOCK Use alarm and signal handler to interrupt slow system calls. Use multiple processes/threads. Use functions that support checking of multiple input sources at the same time.

Non blocking I/O use fcntl() to set O_NONBLOCK: #include <sys/types.h> #include <fcntl.h> int flags; int pipe_fd[2]; …. flags = fcntl(pipe_fd,F_GETFL,0); fcntl(pipe_fd,F_SETFL,flags | O_NONBLOCK); Now calls to read() (and other system calls) will return an error and set errno to EWOULDBLOCK.

while (! done) { if ( (n=read(STDIN_FILENO,…)<0)) if (errno != EWOULDBLOCK) /* ERROR */ else write(pipe_fd[1],…) if ( (n=read(pipe_fd[0],…)<0)) else write(STDOUT_FILENO,…) }

The problem with nonblocking I/O Using blocking I/O allows the Operating System to put the process to sleep when nothing is happening (no input). Once input arrives the OS will wake up the process and read() (or write() … ) will return. With nonblocking I/O the process will “busy-wait”, using inefficiently the CPU time

Time-out handling with alarms Using alarms Time-out handling with alarms signal(SIGALRM, sig_alrm); alarm(MAX_TIME); read(STDIN_FILENO,…); ... read(fd_pipe,…); Issues: How to assess the impact on response time ? How to choose the value for MAX_TIME?

Using sigset() sigset() makes use of a signal mask of type sigset t (array of long integers) where signals to be blocked are recorded when sigset() is called the system add the sig value to the process's current signal mask before executing the catcher. when catcher() finishes the system restores the signal mask; hence, unlike signal(), sigset() installed catcher() remain installed after the call. when successful, sigset() returns either SIG HOLD, indicating that signal was previously blocked, or the disposition previously associated with the signal.

Example using sigset() /* Catching signals with sigset() */ #include <stdio.h> #include <signal.h> #include <unistd.h> #include <stdlib.h> extern int errno; int main(void) { int i; void SigCatcher(int); if (sigset(SIGINT, SigCatcher) == SIG_ERR) { perror(''Sigset cannot set SIGINT''); exit(SIGINT); } if (sigset(SIGQUIT, SigCatcher) == SIG_ERR) perror(''Sigset cannot set SIGQUIT''); exit(SIGQUIT);

Example using sigset() for (i = 0; ; ++i) /* loop forever */ { printf(''i = %d``n'', i); sleep(1); } void SigCatcher( int signum) printf(''\nSignal %d received.\n'', signum); if (signum == SIGQUIT) exit(1);

Manipulating signal mask a call to int sighold( int sig ); will add sig to the calling process signal mask; a call to int sigrelse( int sig ); will remove sig from the calling process signal mask; a call to int sigpause( int sig ); will remove sig from the signal mask and will suspend process until sig is received a call to int sigignore( int sig ); will cause sig to be ignored (achievable by signal(sig, SIG_IGN))

Example: Demonstration of sighold() and sigset() /* Execute with a.out &; then type ''%kill ­USR1 pid'' and ''%kill ­USR2 pid'' */ #include <stdio.h> #include <signal.h> #include <unistd.h> void SigCatcher( int n ) { printf(''Received signal %d will release SIGUSR1 \n'', n); sigrelse(SIGUSR1); printf(''SIGUSR1 released! \n''); } int main(void) sighold(SIGUSR1); /* block signals SIGUSR1 */ sigset (SIGUSR2, SigCatcher); /* catch signals SIGUSR2 */ printf(''Waiting for signals\n''); pause (); printf (''Done\n''); exit(0);

Using sigpause() system call /* Pausing with sigpause() */ /* Run with a.out &; then type ''kill ­USR1 pid */ /* Try to kill process by ''kill ­INT pid'' after ''Beginning ...'' */ #include <stdio.h> #include <signal.h> #include <unistd.h> void main(void) { void SigCatcher(int); sigset(SIGUSR1, SigCatcher); while ( 1 ) /* repeat forever */ } printf(''Waiting for signal %d \n'', SIGUSR1); sigpause (SIGUSR1); void SigCatcher(int n) { sighold(SIGINT); sighold(SIGTERM); printf(''Beginning important stuff`\n''); sleep(10); printf(''Ending important stuff`\n''); sigrelse(SIGTERM); sigrelse(SIGINT); }

Observations When SIGUSR1 is received the signal catching function is executed; during this time SIGINT and SIGTERM are blocked; A set of messages indicating the beginning and the end of an important section of code are displayed SIGINT and SIGTERM are then released; hence typing ''kill ­INT pid'' will terminate the process.