COE518 Lecture Notes Week 2 (Sept. 12, 2011)

Transcription

1 C)E 518 Operating Systems Week 2 September 12, /8 COE518 Lecture Notes Week 2 (Sept. 12, 2011) Topics Creating a cloned process with fork() Running a new process with exec...() Textbook sections Stallings (7 th edition): Chapter 3.7 (Unix Process Management) Tanenbaum (3 rd edition): Chapters 1.5.6, (System Calls for Process Management) (The Shell) Creating new processes An multitasking operating system manages, maintains, schedules and removes processes. In process creation, an entry is set up for it in the OS's process table and its memory areas are allocated and initialized as are the initial values of its virtual machine registers. fork(): Cloning a process The fork()system call creates a new process (called the child) that is an exact clone of the process that invoked fork() (called the parent). It returns an integer, but a different integer for the parent and the child. Zero (0) is returned to the child, while the PID (Process ID number) of the child is returned to the parent.. Hence the common idiom: int pid; if ((pid = fork()) == 0) { printf( I am the child ); printf( I am the parent of %d\n, pid);

2 C)E 518 Operating Systems Week 2 September 12, /8 Lab 1 Part B Hint /* * */ int main(int argc, char** argv) { int rc = EXIT_SUCCESS; char* greeting = "Hello"; char* name = "UNKNOWN"; if (*argv[0] == 'b') { greeting = "Bye"; printf(greeting); if (argc >= 2) { name = argv[1]; if (argc > 2) { rc = 2; else { rc = 1; printf(" %s\n", name); return (rc); Lab 1 Part C Hint The following example shows how to prevent a process from continuing until some external condition occurs; in this case the non-existance of a directory. This code is OS independent and relies on the fact that creating a directory is an atomic operation (i.e. a context switch cannot occur during the attempt to create the directory.) /*

3 C)E 518 Operating Systems Week 2 September 12, /8 * */ int main(int argc, char** argv) { int i = 0; printf("hi %s\n", argv[1]); while (system("mkdir junk")!= 0) { usleep(10000l); if (i >= 10) return 1; printf("bye %s\n", argv[1]); system("rmdir junk"); return (EXIT_SUCCESS); What is a process? A process occupies memory and executes machine language instructions from memory. Part of the process's memory is for the program itself and part is for data. The CPU Program Counter (PC) register contains the address of the next instruction to execute. Instructions may modify other CPU registers and data memory locations. A process is started by loading its data and program memory spaces (assigned by the Operating System) by a loader (also an OS component) from externalstorage (such as a disk or the Internet). If the OS can only support a single process, there is not much more to say. But we consider multitasking (also called multiprocessing) OSes here. To each process, the OS assigns a region of memory. Assuming a single CPU (or core), only one process can run at a time (since there is only one real Program Counter). At any instant, the state of a process is defined as the values opf the PC and other CPU registers and the contents of the process's data (in memory). Assuming that no process ever modifies the data area of another process, we can define the state as simply the values in the CPU registers (including the PC). The illusion of various processes running simultaneously is achieved by the multitasking OS by switching between processes.

4 C)E 518 Operating Systems Week 2 September 12, /8 Switching can occur for various reasons including: A process may voluntarily relinquish its need for the CPU (for example, with a sleep() call). A process may be waiting for some external event such as I/O. The OS may force a process to relinquish the CPU because it has consumed too much time. A process may wait for completion of some interprocess communication (IPC). When one process relinquishes control, the next process is selected by the OS scheduler. The context switch then saves the current state of the old process and sets the CPU state (registers) to the values corresponding to the state of the new process. exec(...): overlaying a process with a new program The exec family of system calls replaces the calling process with a new process loaded from the file system. The newly loaded process inherits the PID of the process being replaced and its open file descriptors. If successful, exec does not return. The calling process if replaced by the program specified. If unsucessful, exec sets a error number in a global variable and a description of the problem can be printed with perror(); #include <unistd.h> #include <assert.h> int main(int argc, char *argv[]) { char *newargv[] = {NULL, "hello", "world", NULL; char *newenviron[] = {NULL; assert(argc == 2); /* argv[1] identifies program to exec */ newargv[0] = argv[1]; execve(argv[1], newargv, newenviron); perror("execve"); /* execve() only returns on error */ exit(exit_failure);

5 C)E 518 Operating Systems Week 2 September 12, /8 int main(int argc, char * argv[], char **envp) { int i = 5; pid_t child; printf("child i, child: %d, %d\n", i, child); else { usleep(1); printf("parent i, child: %d, %d\n", i, child); return EXIT_SUCCESS; Questions 1. Consider the following program: int main(int argc, char * argv[], char **envp) { int i = 0; pid_t child; printf("parent pre-fork: i = %d\n", i); printf("child: i = %d\n", i); printf("grandchild: i = %d\n", i); exit(0);

6 C)E 518 Operating Systems Week 2 September 12, /8 printf("child again: i = %d\n", i); else { printf("parent: i = %d\n",i); usleep(200); return EXIT_SUCCESS; Which (if any) of the following could be the output from running this program? Parent pre-fork: i = 0 Child: i = 1 Child again: i = 1 Parent: i = 0 Grandchild: i = 2 Parent pre-fork: i = 0 Parent: i = 0 Child: i = 1 Child again: i = 1 Grandchild: i = 2 Parent pre-fork: i = 0 Grandchild: i = 2 Child: i = 1 Parent: i = 0 Child again: i = 1 2. The following program is executed. What is the output? int main(int argc, char * argv[], char **envp) { int status; int i = 0; pid_t child;

7 C)E 518 Operating Systems Week 2 September 12, /8 printf("parent pre-fork: i = %d\n", i); printf("child: i = %d\n", i); printf("grandchild: i = %d\n", i); exit(0); wait(&status); printf("child again: i = %d\n", i); else { wait(&status); printf("parent: i = %d\n",i); usleep(200); return EXIT_SUCCESS; Answers 1. The first two outputs are possible. (In the second case, the parent continues after the fork before the child even gets a chance for its first printf. The third is impossible. (The grandchild cannot do its printf before the child does its, which happens before the second fork, i..e before the grandchild is even created!) 2. The only possible output is: Parent pre-fork: i = 0 Child: i = 1 Grandchild: i = 2 Child again: i = 1 Parent: i = 0 Why? Because the parent waits for its child to die and the child waits for its child (the grandchild) to die.

8 C)E 518 Operating Systems Week 2 September 12, /8