ACSC 372 Systems Programming. exec() Functions. Outline

Transcription

1 Outline ACSC 372 Systems Programming Lecture 12: Process & Signals (Chapter 8,10 - Stevens & Rago) exec() Functions (ch. 8.10) System Callsystem() (ch. 8.13) Signals in C (ch. 10.1, ch. 10.2, ch. 10.3) System Call signal() (ch. 10.3) Signals and Processes System Callalarm() (ch ) Inter-Process Signals (kill()) (ch. 10.9) 2 exec() Functions One use of the fork() function is to create a new process (the child) that then causes another program to be executed (an executable file, e.g. ls, sort, uniq, any executable!) by calling one of the exec functions. When a process calls one of the exec functions, that process is completely replaced by the new program, and the new program starts executing at its main function. A child process replaces its process image (its text, data, heap, and stack) with a brand new program from disk (an executable file), differentiating thus itself from its parent. The process ID does not change across an exec, because a new process is NOT created. After an exec, the new program inherits additional properties from the calling process, like PID, PPID, File Descriptors, alarms, etc. (see p. 234). 3 exec() Functions (cnt d) There are 6 different exec functions; we are interested of the following: int execl(char *pathname, char *arg0, char *arg1,..., char *argn, NULL); int execv(char *pathname, char *argv[]); Replace a process (text, data, heap, stack) with that of an executable file that is given in the pathname, where pathname is the relative or absolute path. Defines the end of the arg list (alternative definition (char *)0) int execlp(char *filename, char *arg0, char *arg1,..., char *argn, NULL); int execvp(char *filename, char *argv[]); where in filename, there is no need to define the location of the executable, since the executable file is searched for in the directories specified by the PATH environment variable. (This is useful for use in the case of e.g., sort, uniq, etc). All four return -1 on error, no return on success. The difference ofexecl(list) andexecv(vector) is that execl takes as arguments: arg0=«executable name», arg1=«parameter 1»,., argn=«parameter n», arg(n+1)=null, whereas inexecv we use an array of pointers to the arguments argv[0], argv[1],, argv[n], argv[n+1]=null. The same difference applies to the pair execlp(list,path) / execvp (vector,path). All the above functions are library functions that are based on the system call execve (vector environment). 4

2 Example 1 Use of execl() Write a program that list the contents of the parent directory (..), using the execl function. Example 1 Use of execl() (cnt d) /* File: execl_demo.c */ #include <stdio.h> main() printf("i am process %d and I will execute an 'ls -l..' \n", getpid()); if (execl("/bin/ls", "ls", "-l", "..", NULL) == -1) perror("execl"); Sample Execution $./execl_demo I am process and I will execute an 'ls -l..' total 504 drwxr--r-x 7 com.chc staff 4096 Jan test1 drwx--x--x 44 com.chc staff 4096 Feb 9 14:58 test2 drwx-----x 53 com.chc staff Sep 17 21:50 test Example 2 Use of execvp() Problem Description #include <stdio.h> /* For printf */ Create a child process that will execute the date int main() command. When the child terminates, the parent process continues its execution. int pid, status; char *argv[2]; if ((pid = fork()) == -1) /* Check for error */ perror("fork"); exit(1); else if (pid == 0) /* Child process */ argv[0] = "date"; argv[1] = NULL; printf("i am child process %d and I will replace myself by 'date'\n", getpid()); if (execvp("date", argv) == -1 ) perror("execvp"); exit(1); else /* Parent process */ printf("i am parent process %d\n", getpid()); if (wait(&status)!= pid) /* Wait for child */ perror("wait"); exit(1); printf("child terminated with exit code %d\n", status >> 8); exit(0); Sample Execution $./execvp-example2 I am parent process I am child process and I will replace myself by 'date' Mon Mar 3 19:14:11 EET 2009 Child terminated with exit code 0 7 Example 3 - Implementation of a simple shell using execvp() Write a C program that operates like a simple shell: It takes commands from the keyboard that are executed by a child process, which is created each time. 8

3 Example 3 - (cnt d) Implementation of a simple shell using execvp() /* File: simpleshell.c */ #include <stdio.h> /* For fgets, printf */ void parse(char *buf, char **argv); /* Function prototype */ void execute(char **argv); /* Function prototype */ int main() char buf[1024]; char *argv[64]; while (1) printf("command: "); /* Get input */ buf if (fgets(buf, sizeof(buf), stdin) == NULL) printf("\n"); exit(0); parse(buf, argv); /* Split buf into arguments copied into argv */ execute(argv); return 0; Get user command into Example 3 - (cnt d) Implementation of a simple shell using execvp() // Does not support pipes, redirections void parse(char *buf, char **argv) char *tmp; // used to perform a linear scan of buf tmp = buf; // initialize tmp to the same position with buf while (*tmp!= '\0') if ((*tmp == ' ') (*tmp == '\t') (*tmp == '\n')) *tmp = '\0'; // replace whitespace with NULL *argv++ = buf; // first set *argv=buf then *argv++ buf = ++tmp; // set buf to the next string tmp++; *argv=null; /* End of arguments */ Memory fork() Parent Wait() A child Execvp() tmp e.g. buf= ls a l i Argv[ 0,1,2,3,NULL ] void execute(char **argv) int pid, status; if ((pid = fork()) < 0) /* Create a child */ perror("fork"); exit(1); if (pid == 0) /* Child process */ if (execvp(argv[0], argv) == -1) perror(argv[0]); exit(1); if (wait(&status)!= pid) /* Parent process */ perror("wait"); exit(1); 9 10 System Callsystem() It is convenient to execute a command string from within a program, e.g. Memory system() int main() system("ls -al sort > output.txt"); exit(0); int system(const char *cmdstring); returns -1 on error or 0 ΟΚ A a) fork() B c) waitpid() b) exec() The C program waits until the system() is completed. system() is implemented by calling fork (child), exec (child), and waitpid (parent process waits its child process to terminate). (see example in Fig (p. 247)) Example -system() Find the total number of processes that are created when the program sysexec.c is executed, which uses system() to call the bash script batch.sh. $ cat sysexec.c int main() system("./batch.sh"); exit(0); $cat./batch.sh i=0; while [ $i -lt 1000 ]; do echo -n " $i "; ls -al sort uniq rev > /tmp/file; ((i++)); done 11 12

4 Example -system() (cnt d) The execution of sysexec(14015) creates a new process sh(14016) that does 1000 iterations. In each of the 1000 iterations, 4 processes are created (ls, sort, uniq, rev). Remember that ls, sort, uniq, rev are not built-in shell commands (that is, they are not in the executable file of the shell). Thus each time they are called, a new process is created. Therefore, we have: 4*1000 (ls, sort, uniq, rev) + 1 (sysexec(14015)) + 1 (sh(14016)) = 4002 processes Below, 2 from the 1000 instances are shown using the command pstree. $ pstree -Gp com.chc sshd(4588) bash(4590) a.out(14015) sh(14016) ls(16806) rev(16809) sort(16807) uniq(16808) $ pstree -Gp com.chc sshd(4588) bash(4590) a.out(14015) sh(14016) ls(17669) rev(17672) sort(17670) uniq(17671) Signals Signals (software interrupts): Small messages, which are sent to a specific process, or group of processes. Signals are sent between Process Process (if the appropriate permissions are given, e.g. kill) or from the kernel to a Process (e.g. alarm()) When a process receives a signal, the process execution is interrupted, and the signal is handled. It can ignore the signal (not all) It can handle the signal, by executing a specific part of code that is called signal handler. In this lecture, we will study Signals as part of C programs, whereas in lecture 8 we have seen Signals in shells Signals (cnt d) User Mode Main Memory Signals (cnt d) Kernel Mode Signals Bash Shell Bash Shell Signals Signals Signals Software Interrupts Signals Handling Each Signal in UNIX consists of: a number (e.g., 2) or an equivalent symbolic name (e.g., SIGINT), a default signal handler, which in most cases can be modified/changed and replace the way a program handles a signal. In order to program Signals in C, we need to include the library: Hardware Interrupts 15 16

5 Signals (cnt d) Signals (cnt d) default signal handler See Table 10.1 (p. 292) for other signals SIGHUP (1) terminal line got hung-up SIGINT (2) interrupt (Control^C) SIGKILL (9) kill SIGUSR1 (10) user-defined signal 1 SIGSEGV (11) Segm. Viol. invalid memory reference SIGUSR2 (12) user-defined signal 2 SIGALRM (14) alarm clock SIGTERM (15) software termination signal (like 2) SIGCONT (18) continue after stop SIGSTOP (19) stop (cannot be caught or ignored). SIGTSTP (20) stop signal from keyboard (Control^Z) System Callsignal() void (*signal( int sigcode, void (*func)(int) )) (int) ; Defines the response of a process when a sigcode signal is received. We thus define which function contains the commands of the response. sigcode (int): The integer value (name) of the signal that we want to handle (e.g., SIGINT (2) see previous slide). void (*func)(int): Pointer to the function that will handle the signal. The value of func is a) the constant SIG_IGΝ (ignore), thus the signal is ignored, b) the constant SIG_DFL, thus the signal handling is done by the default signal handler (in case that we have changed the signal handler for a specific signal), or c) the address of a function to be called when the signal occurs (a user-defined function that plays the role of the signal handler). When the signal handler is called, its single integer argument is the number of the signal that activates the signal handler. It Returns: a pointer to the previous signal handler of the sigcode signal (e.g. if we want to temporarily change the signal handler, and afterwards to restore it), or -1 (on error). The sigcode: SIGKILL and SIGSTOP cannot be ignored, neither we can change their signal handler. void cntl_c_handler(int sig) printf("just received signal %d\n", sig); main() signal(sigint, cntl_c_handler); System Callsignal() Example 1 while(1) printf("\n"); sleep(1); Signal number that activates the signal handler Sample execution $./simplesignal Just received signal 2 Just received signal 2 Just received signal

6 System Callsignal() Example 2 An old myth An old myth says that a student used the following code in his program, to be certain that he will never get coredumps when his program is examined. Note that SIGSEGV (segmentation violation) is a signal that is sent by the kernel to state that the process has done an invalid memory reference. #include <stdio.h> void segv_handler(int dummy) fprintf(stderr, "nfs server not responding, still trying\n"); while(1) sleep(1); int main(void) int *iptr; signal(sigsegv, segv_handler); *iptr = 12; printf("value is: %d\n", *iptr); return 0; 21 System Callsignal() Example 3 #include <stdio.h> /* For printf */ /* For SIGINT, SIG_IGN */ main() void (*oldhandler)(int); /* To hold old handler value */ printf("i can be Control-C'ed\n"); sleep(3); oldhandler = signal(sigint, SIG_IGN); /* Ignore ^C */ printf("i am protected from Control-C now\n"); sleep(3); signal(sigint, oldhandler); /* Restore old handler */ printf("i can be Control-C'ed again\n"); sleep(3); printf("bye!\n"); $./critical I can be Control-C'ed ^C $./critical I can be Control-C'ed I am protected from Control-C now ^CI can be Control-C'ed again Bye! $./critical I can be Control-C'ed I am protected from Control-C now I can be Control-C'ed again ^C 22 $ #include <stdio.h> void mysignalh(int sig) if (sig == SIGUSR1) printf("\nreceived SIGUSR1(%d) signal\n,sig); if (sig == SIGUSR2) printf("\nreceived SIGUSR2(%d) signal\n,sig); main() signal(sigusr1, mysignalh); signal(sigusr2, mysignalh); System Call signal() Example 4 while(1) sleep(1); bash-3.1$./a.out & [1] bash-3.1$ kill -USR bash-3.1$ received SIGUSR1(10) signal bash-3.1$ kill -USR received SIGUSR2(12) signal bash-3.1$ bash-3.1$ kill -KILL bash-3.1$ [1]+ Killed./a.out bash-3.1$ Signals and Processes If we declare a signal handler and thenfork, this signal handler also applies for the child process. void signal_handler(int sig) printf("a signal %d was received by %d \n", sig, getpid()); int main(void) pid_t pid; /* Install signal handler */ signal(sigint, signal_handler); if ( (pid = fork()) < 0) perror("fork error"); else if (pid == 0) while (1) printf("\n"); sleep(1); else printf("parent has finished\n"); exit(0); Note that we have an orphan process In order to verify that the child process receives the signal, we can send the signal from the shell: $kill We then see that the signal is received by the child (4256) parent has finished A signal 2 was received by

7 Signals and Processes: Avoid Zombies asynchronously using Signals In lecture 11 (last example) we have seen how to avoid having zombies in a synchronous way. That is, we execute wait() until the child process returns its exit code. This however stopped the execution of the parent process (at wait()) until the child s response (that is, the parent is in the blocking wait state). Now we will see an alternative, and better way of avoiding zombies asynchronously. We make use of the signal SIGCHLD, that is sent by the child to its parent process, when the child process terminates. 25 void signal_handler(int sig) int pid; int status; printf( #%d: A signal %d was received \n", getpid(), sig); pid = wait(&status); printf( #%d: Exit Code %d %d\n", getpid(), pid, status>>8); Signals and Processes: Example Avoid Zombies asynchronously using Signals int main() int pid; signal(sigchld, signal_handler); /* Install signal handler */ pid = fork(); if (pid == -1) /* Check for error */ perror("fork"); exit(1); else if (pid == 0) /* The child process */ printf( #%d (child): Exit!\n, getpid()); exit(37); /* Exit with a silly number */ else /* The parent process */ while (1) /* Never terminate */ sleep(1000); Putwait() inside the signal_handle, so as the child can return its exit code, independent with how busy its parent process is. This way limits the zombie processes. Sample Execution $./chldsignal #19246 (child): Exit! #19245: A signal 17 was received #19245: Exit Code System Call alarm() unsigned int alarm(unsigned int count); Returns 0 or number of seconds until previously set alarm. Instructs the kernel to send, after count seconds, the signal SIGALRM to the calling process. The default signal handler prints the message Alarm clock, and terminates the process. The counter is kept in the kernel. If the function is called with count equal to 0, the previous alarm clock is cancelled. The number of seconds left for that previous alarm clock is returned as the value of the function. Observations: The alarm is NOT inherited by the child process. The alarm is reset each time SIGALRM is sent to the process; thus we need to re-set the alarm clock, if we want to receive the signal again (see example). System Callalarm() Example // signal, alarm // fork, getpid #include <time.h> // time_t, time void signal_handler(int sig) time_t rawtime; time ( &rawtime ); /* compute the current time */ printf("#%d: The kernel sent a SIGALRM(%d) on: %s", getpid(), sig, ctime (&rawtime)); alarm(1); /* we re-install the alarm here */ int main() int pid; /* Install signal handler first, and then set the alarm clock */ signal(sigalrm, signal_handler); alarm(1); pid = fork(); if (pid == -1) perror("fork"); exit(1); else if (pid == 0) /* The child process */ while (1) printf("#%d\n", getpid()); sleep(3); else while (1) printf("#%d\n", getpid()); sleep(3); Alarm signal handler Sample Execution #6020 (child) #6019 (parent) #6019: The kernel sent a SIGALRM(14) on: Tue Mar 3 23:58: #6019 #6019: The kernel sent a SIGALRM(14) on: Tue Mar 3 23:58: #6019 #6019: The kernel sent a SIGALRM(14) on: Tue Mar 3 23:59: #6019 #6020 Only the parent receives the alarm 27 28

8 Inter-Process Signals System Callkill() Until now we have seen how we can send signals from the kernel (e.g. SIGALRM) and also from the shell (e.g. SIGINT) to a process. What if we want to send signals between processes? Use of the System Callkill int kill(int pid, int sigcode); Returns -1 on error, or 0 if OK Sends the sigcode signal to the process with process ID pid A process needs permission to send a signal to another process. The superuser can send a signal to any process. For inter-process signals sending, we can use the non-reserved signals SIGUSR1, SIGUSR2. 29 Inter-Process Signals Example System Callkill() /* File: pulse.c */ #include <stdio.h> /* For printf */ /* For SIGTERM, SIGSTOP, SIGCONT */ main() int pid1, pid2; if ((pid1 = fork()) == -1) perror("fork"); exit(1); if (pid1 > 0) /* parent */ if ((pid2 = fork()) == -1) perror("fork"); exit(1); if (pid1 == 0) /* First child */ while (1) /* Infinite loop */ printf("process 1 is alive\n"); sleep(1); if (pid2 == 0) /* Second child */ while (1) /* Infinite loop */ printf("\n"); sleep(1); sleep(2); kill(pid1, SIGSTOP); /* Suspend first child */ sleep(2); kill(pid1, SIGCONT); /* Resume first child */ sleep(2); kill(pid1, SIGTERM); /* Terminate first child */ kill(pid2, SIGTERM); /* Terminate second child */ Problem Create two child processes that each execute an infinite loop. We then suspend the 1 st child process, we resume it, and finally we terminate both child processes. $./a.exe Process 1 is alive Process 1 is alive Process 1 is alive Process 1 is alive 30