3214
Computer Announcements
CS Systems
Systems
Exercise 4 due Sep 30
Project 3 due Oct 14
Lecture 11
Godmar Back
CS 3214 Fall 2011
fork()
Part 3
THREADS AND PROCESSES
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main(int ac, char *av[])
{
pid_t child = fork();
if (child < 0)
perror(fork), exit(-1);
if (child != 0) {
printf ("I'm the parent %d, my child is %d\n",
getpid(), child);
wait(NULL); /* wait for child (join) */
} else {
printf ("I'm the child %d, my parent is %d\n",
getpid(), getppid());
execl("/bin/echo", "echo", "Hello, World", NULL);
}
}
CS 3214 Fall 2011
fork() vs. exec()
fork():
Clone most state of parent, including memory
Inherit some state, e.g. file descriptors
Keeps program, changes process
Called once, returns twice
exec():
Overlays current process with new executable
Keeps process, changes program
Called once, does not return (if successful)
CS 3214 Fall 2011
CS 3214 Fall 2011
exit(3) vs. _exit(2)
exit(3) destroys current processes
OS will free resources associated with it
E.g., closes file descriptors, etc. etc.
Can have atexit() handlers
_exit(2) skips them
th
Exit status is stored and can be retrieved by
parent
Single integer
Convention: exit(EXIT_SUCCESS) signals
successful execution, where EXIT_SUCCESS is
0
CS 3214 Fall 2011
1
If multiple children completed, will take in arbitrary order
Can use macros WIFEXITED and WEXITSTATUS to
get information about exit status
wait() vs waitpid()
Blocks until any child exits
If status != NULL, will contain value child
passed to exit()
Return value is the child pid
Can also tell if child was abnormally
terminated
int waitpid(pid_t pid, int *status, int options)
Can say which child to wait for
CS 3214 Fall 2011
CS 3214 Fall 2011
The fork()/join() paradigm
After fork(), parent & child
execute in parallel
Launch activity that can be done in
parallel & wait for its completion
Or simply: launch another program
and wait for its completion (shell
does that)
Parent
process
executes
Resulting in a process tree
Child
process
executes
Child
process
exits
Parent:
join()
OS notifies
CS 3214 Fall 2011
Unix File Descriptors
Unix provides a file descriptor abstraction
File descriptors are
Small integers that have a local meaning within
one process
Can be obtained from kernel
Several functions create them, e.g. open()
Can refer to various kernel objects (not just files)
Can be passed to a standard set of functions:
read, write, close, lseek, (and more)
Can be inherited when a process forks a child
CS 3214 Fall 2011
Observations on fork/exit/wait
Process can have many children at any point in time
Establishes a parent/child relationship
Parent:
fork()
Unlike a fork in the road, here we
take both roads
Used in many contexts
In Unix, join() is called wait()
Purpose:
void fork10()
{
pid_t pid[N];
int i;
int child_status;
for (i = 0; i < N; i++)
if ((pid[i] = fork()) == 0)
exit(100+i); /* Child */
for (i = 0; i < N; i++) {
pid_t wpid = wait(&child_status);
if (WIFEXITED(child_status))
printf("Child %d terminated with exit status %d\n",
wpid, WEXITSTATUS(child_status));
else
printf("Child %d terminate abnormally\n", wpid);
}
}
Wait Example
int wait(int *status)
Zombies: processes that have exited, but their parent
hasnt waited for them
Reaping a child process call wait() so that can zombies
resources be destroyed
Orphans: processes that are still alive, but whose
parent has already exited (without waiting for them)
Become the child of a dedicated process (init) who will
reap them when they exit
Run Away processes: processes that
(unintentionally) execute an infinite loop and thus dont
call exit() or wait()
CS 3214 Fall 2011
Examples
0-2 are initially assigned
0 stdin
1 stdout
2 stderr
But this assignment is not fixed process can
change it via syscalls
int fd = open(file, O_RDONLY);
int fd = creat(file, 0600);
CS 3214 Fall 2011
2
Implementing I/O Redirection
dup2
#include <stdio.h>
#include <stdlib.h>
// redirect stdout to a file
int
main(int ac, char *av[])
{
int c;
dup and dup2() system call
pipes: pipe(2)
int fd = creat(av[1], 0600);
if (fd == -1)
1)
perror("creat"), exit(-1);
if (dup2(fd, 1) == -1)
perror("dup2"), exit(-1);
while ((c = fgetc(stdin)) != EOF)
fputc(c, stdout);
}
CS 3214 Fall 2011
user view
CS 3214 Fall 2011
kernel view
The Big Picture
0
1
2
3
open(x)
Terminal
Device
Multiple file descriptors may refer to same open file
Within the same process:
4
File
Descriptor
Process 1
Open
File
fd = open(file); fd2 = dup(fd);
x
open(x) close(4)
0
1
Reference Counting
File
Descriptor
2
3
dup2(3,0)
Across anchestor processes:
fd = open(file); fork();
But can also open a file multiple times:
fd = open(file); fd2 = open(file);
In this case, fd and fd2 have different read/write offsets
In both cases, closing fd does not affect fd2
Reference Counting at 2 Levels:
Kernel keeps track of how many processes refer to a file
descriptor fork() and dup() may add refs
And keeps track of how many file descriptors refer to open file
close(fd) removes reference in current process only!
Process 2
CS 3214 Fall 2011
CS 3214 Fall 2011
Practical Implications
Number of simultaneously open file
descriptors per process is limited
1024 on current Linux, for instance
Must make sure fds are closed
make sure fds are closed
Else open() may fail
Number space is reused
double-close error may inadvertently close a
new file descriptor assigned the same number
CS 3214 Fall 2011
IPC via pipes
write()
read()
Fixed Capacity Buffer
A bounded buffer providing a stream of bytes flowing through
Properties
Writer() can put data in pipe as long as there is space
If pipe() is full, writer blocks until reader reads()
Reader() drains pipe()
If pipe() is empty, readers blocks until writer writes
Classic abstraction
Decouples reader & writer
Safe no race conditions
Automatically controls relative progress if writer produces data
faster than reader can read it, it blocks and OS will likely make
CPU time available to reader() to catch up. And vice versa.
CS 3214 Fall 2011
3
int main()
{
int pipe_ends[2];
if (pipe(pipe_ends) == -1)
perror("pipe"), exit(-1);
int child = fork();
if (child == -1)
perror("fork"), exit(-1);
if (child == 0) {
char msg[] = { "Hi" };
pipe
Note: there is no race condition in
this code. No matter what the
scheduling order is, the message sent
by the child will reach the parent.
close(pipe_ends[0]);
write(pipe_ends[1], msg, sizeof msg);
} else {
char bread, pipe_buf[128];
close(pipe_ends[1]);
printf("Child said "); fflush(stdout);
while ((bread = read(pipe_ends[0], pipe_buf, sizeof pipe_buf)) > 0)
write(1, pipe_buf, bread);
}
}
CS 3214 Fall 2011
4