Transcript CS345 Operating Systems Φροντιστήριο Άσκησης 1 1

CS345
Operating Systems
Φροντιστήριο Άσκησης 1
1
Processes
2
The fork() System Call (1)
• A process calling fork() spawns a child
process.
• The child is almost an identical clone of the
parent:
–
–
–
–
Program Text (segment .text)
Stack (ss)
#include <sys/types.h>
#include <unistd.h>
PCB (eg. registers)
Data (segment .data) pid_t fork(void);
3
The fork() System Call (2)
• The fork() is one of the those system calls,
which is called once, but returns twice!
• After fork() both the parent and the child are
executing the same program.
Consider a piece of program
• On error, fork() returns -1 ...
pid_t pid = fork();
PID=28
PID=28
PID=34
fork()
printf(“PID: %d\n”, pid);
...
The parent will print:
PID: 34
p1
p1
c1
And the child will always print:
PID: 0
• After fork() the execution order is not
guaranteed.
4
The exec()System Call (1)
• The exec() call replaces a current process’ image with a new one
(i.e. loads a new program within current process).
• The new image is either regular executable binary file or a shell script.
• There’s no a syscall under the name exec(). By exec() we usually
refer to a family of calls:
–
–
–
–
–
–
int
int
int
int
int
int
execl(char *path, char *arg, ...);
execv(char *path, char *argv[]);
execle(char *path, char *arg, ..., char *envp[]);
execve(char *path, char *argv[], char *envp[]);
execlp(char *file, char *arg, ...);
execvp(char *file, char *argv[]);
• Here's what l, v, e, and p mean:
–
–
–
–
l means an argument list,
v means an argument vector,
e means an environment vector, and
p means a search path.
5
The exec()System Call (2)
• Upon success, exec() never returns to the caller. If it does return, it
means the call failed. Typical reasons are: non-existent file (bad path)
or bad permissions.
• Arguments passed via exec() appear in the argv[] of the main()
function.
• For more info: man 3 exec;
PID=28
PID=28
exec()
p1
Legend:
p1
Old Program
New Program
6
fork() and exec() Combined
• Often after doing fork() we want to load
a new program into the child. E.g.: a shell.
tcsh
tcsh
PID=28
PID=28
p1
p1
tcsh
fork()
PID=34
c1
tcsh
ls
PID=34
PID=34
exec(ls)
c1
c1
7
The System wait() Call
• Forces the parent to suspend execution, i.e.
wait for its children or a specific child to die
(terminate is more appropriate terminology,
but a bit less common).
8
The System wait() Call (2)
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
• The wait() causes the parent to wait for any child process.
• The waitpid() waits for the child with specific PID.
• The return value is:
– PID of the exited process, if no error
– (-1) if an error has happened
9
The exit() System Call
#include <stdlib.h>
void exit(int status);
• This call gracefully terminates process execution. Gracefully
means it does clean up and release of resources, and puts the
process into the zombie state.
• By calling wait(), the parent cleans up all its zombie children.
• exit() specifies a return value from the program, which a
parent process might want to examine as well as status of the
dead process.
10
The pause() system call
#include <unistd.h>
int pause(void);
• Used to suspend process until a signal
arrives
• Signal action can be the execution of a
handler function or process termination
• only returns (-1) when a signal was caught
and the signal-catching function returned
11
Process states
• Zombie: has completed execution, still has
an entry in the process table
• Orphan: parent has finished or terminated
while this process is still running
• Daemon: runs as a background process, not
under the direct control of an interactive
user
12
Zombie process
13
Signals
14
Process interaction with signals
• Unix supports a signal facility, looks like a
software version of the interrupt subsystem
of a normal CPU
• Process can send a signal to another
• Kernel can send signal to a process (like an
interrupt)
• Process can handle or ignore a given call
• Handle a signal by binding a function to the
15
arrival of a designated signal
Sending a signal: kill() system call
16
Handling signals: signal()
17
Assignment 1 tips
1. First experiment with fork() and getpid(),
getppid()
2. Use simple printf statements to distinguish
parent from child (through pid)
3. Send simple signal to child
4. Create signal handlers
1.
2.
3.
4.
For 1st time called ( “starting – pid’)
For all other times called (“process – pid”)
To handle Ctrl-C
For termination of child process
5. Create logic for alternating execution
18