1. Lecture 5: Process Creation

2. Review: Linux process memory layout
Stack:
Automatically allocated and deallocated
Local variables, parameters
Heap:
Manually allocated (malloc) and deallocated (free)
Dynamic sized data structures
Static data
Global variables
Text
Program

3. In this lecture
Process context
Process creation

4. Process context: registers
Stack
Heap
Static data
Text (program)
Stack pointer (SP)
As discussed three pages ago, most programs perform file I/O using library code layered on top of kernel code. In this section we discuss just the kernel aspects of file I/O, looking at the abstraction and the high-level aspects of how this abstraction is implemented.
The Unix file abstraction is very simple: files are simply arrays of bytes. Many systems have special system calls to make a file larger. In Unix, you simply write where you’ve never written before, and the file “magically” grows to the new size (within limits). The names of files are equally straightforward—just the names labeling the path that leads to the file within the directory tree. Finally, from the programmer’s point of view, all operations on files appear to be synchronous—when an I/O system call returns, as far as the process is concerned, the I/O has completed. (Things are different from the kernel’s point of view, as discussed later.)
Program counter (PC)

5. Process context: file management
Root directory
Working directory
Opened files

6. Process context: others
Process id
Parent process …

7. Process creation: fork() system call
#include <unistd.h>
pid_t fork(void); //prototype
fork() returns a process id (a small integer)
fork() returns twice!
In the parent – fork returns the id of the child process
In the child – fork returns a 0

8. Parent and child processes
The child process is a copy of the parent process
Same core image
Same context (except process id)
Registers
Files
Others

9. Creating a process: before fork()
Stack
Heap
Static data
Text (program)
Fork()
The only way to create a new process is to use the fork system call. PC
parent process

10. Creating a process: after fork()
Stack
Heap
Static data
Text (program)
fork()
//return p
Stack
Heap
Static data
Text (program)
fork()
//return 0
The only way to create a new process is to use the fork system call. PC PC
parent process
child process
process id = p

11. Example #include <unistd.h> #include <stdio.h>
void main(void) {
pid_t pid = fork();
if (pid > 0)
printf(“I am the parent\n”);
else if (pid == 0)
printf(“I am the child\n”);
else
printf(“ERROR!\n”); }

12. Process hierarchies
UNIX: Parent creates a child process, child can create more processes
Forms a hierarchy
UNIX calls this a "process group”
All processes within a group are logically related
Windows has no concept of process hierarchy
all processes are created equal

13. Death and destruction
All processes usually end at some time during runtime (with the exception of init)
Processes may end either by:
executing a return from the main function
calling the exit(int) function
calling the abort(void) function
When a process exits, the OS delivers a termination status to the parent process.

14. Waiting Parent processes often wait for their child processes to end
Parent processes do that via a wait() call
pid_t wait(int * status);
pid_t waitpid( pid_t pid, int * status,…);

15. Switching programs
fork() creates a new process
This would be almost useless if there was not a way to switch which program is associated with the new process
The exec() system call is used to load a new program into an existing process

16. exec(): Loading a new image
Stack
Heap
Static data
Text (program)
exec(prog, args)
prog’s stack
prog’s heap
prog’s static data
prog’s Text
before
after

17. exec() example: #include <unistd.h> main() {
printf(“executing ls\n”);
execl(“/bin/ls”, “ls”, “l”, (char*)0);
exit(1); }

18. A stripped-down shell while (TRUE) { /* repeat forever */
type_prompt( ); /* display prompt */
read_command (command, parameters) /* input from terminal */
if (fork() != 0) { /* fork off child process */
/* Parent code */
waitpid( -1, &status, 0); /* wait for child to exit */
} else {
/* Child code */
execve (command, parameters, 0); /* execute command */ }

19. More examples How many processes does this piece of code create?
int main() {
fork(); }

20. Bad example (don’t try this!)
#include <unistd.h>
#include <stdio.h>
void main(void) {
while (!fork()) printf("I am the child %d\n“, getpid());
printf("I am the parent %d\n“, getpid()); }
fork bomb!

21. What is the output of this?
int main() {
int i;
for (i=0; i<2; i++) {
fork();
printf(“%d\n”,i); }
return (0);