Process Creation
As in life, parent processes create children processes. The pstree command can show the genealogy of a system:% pstree -A init-+-acpid |-crond |-klogd |-ntpd |-90*[ssh-agent] |-sshd-+-8*[sshd---sshd---bash] | |-sshd---sshd---csh---bash---pine | |-sshd---sshd---csh---bash | |-sshd---sshd---csh---vim | |-sshd---sshd---bash---screen | |-sshd---sshd---csh---pstree | `-sshd---sshd---tcsh---pico |-sshd---csh---sftp-server |-syslogd `-xfsThere are two implementation questions:
- Should the child be a duplicate of the parent or a new process?
- Should the parent wait for the child to complete or not?
- open files
- open terminals
- environment variables
- resource limits
- user/group IDs
- Copy-on-write - allows parent and child to read same physical pages
- Lightweight processes (aka threads) - allow them to share many per-process kernel and data structures
- vfork() - blocks the parent until child either exits or exec()s
Process Control Block
Once you have more than one process running, you will need to keep track of them. Operating systems use the process control block for that (we'll use that term even though each system may call it something different). PCB is an in-memory record that captures all the state, or context, of the process. Let us look at a real example, from V7 Unix circa 1979:
/*
* One structure allocated per active
* process. It contains all data needed
* about the process while the
* process may be swapped out.
* Other per process data (user.h)
* is swapped with the process.
*/
struct proc {
char p_stat;
char p_flag;
char p_pri; /* priority, negative is high */
char p_time; /* resident time for scheduling */
char p_cpu; /* cpu usage for scheduling */
char p_nice; /* nice for cpu usage */
short p_sig; /* signals pending to this process */
short p_uid; /* user id, used to direct tty signals */
short p_pgrp; /* name of process group leader */
short p_pid; /* unique process id */
short p_ppid; /* process id of parent */
short p_addr; /* address of swappable image */
short p_size; /* size of swappable image (clicks) */
caddr_t p_wchan; /* event process is awaiting */
struct text *p_textp; /* pointer to text structure */
struct proc *p_link; /* linked list of running processes */
int p_clktim; /* time to alarm clock signal */
};
extern struct proc proc[]; /* the proc table itself */
/*
* The user structure.
* One allocated per process.
* Contains all per process data
* that doesn't need to be referenced
* while the process is swapped.
* The user block is USIZE*64 bytes
* long; resides at virtual kernel
* loc 140000; contains the system
* stack per user; is cross referenced
* with the proc structure for the
* same process.
*/
struct user
{
label_t u_rsav; /* save info when exchanging stacks */
int u_fper; /* FP error register */
int u_fpsaved; /* FP regs saved for this proc */
struct {
int u_fpsr; /* FP status register */
double u_fpregs[6]; /* FP registers */
} u_fps;
char u_segflg; /* IO flag: 0:user D; 1:system; 2:user I */
char u_error; /* return error code */
short u_uid; /* effective user id */
short u_gid; /* effective group id */
short u_ruid; /* real user id */
short u_rgid; /* real group id */
struct proc *u_procp; /* pointer to proc structure */
int *u_ap; /* pointer to arglist */
union { /* syscall return values */
struct {
int r_val1;
int r_val2;
};
off_t r_off;
time_t r_time;
} u_r;
caddr_t u_base; /* base address for IO */
unsigned int u_count; /* bytes remaining for IO */
off_t u_offset; /* offset in file for IO */
struct inode *u_cdir; /* pointer to inode of current directory */
struct inode *u_rdir; /* root directory of current process */
char u_dbuf[DIRSIZ]; /* current pathname component */
caddr_t u_dirp; /* pathname pointer */
struct direct u_dent; /* current directory entry */
struct inode *u_pdir; /* inode of parent directory of dirp */
int u_uisa[16]; /* prototype of segmentation addresses */
int u_uisd[16]; /* prototype of segmentation descriptors */
struct file *u_ofile[NOFILE]; /* pointers to file structures of open files */
char u_pofile[NOFILE]; /* per-process flags of open files */
int u_arg[5]; /* arguments to current system call */
unsigned u_tsize; /* text size (clicks) */
unsigned u_dsize; /* data size (clicks) */
unsigned u_ssize; /* stack size (clicks) */
label_t u_qsav; /* label variable for quits and interrupts */
label_t u_ssav; /* label variable for swapping */
int u_signal[NSIG]; /* disposition of signals */
time_t u_utime; /* this process user time */
time_t u_stime; /* this process system time */
time_t u_cutime; /* sum of childs' utimes */
time_t u_cstime; /* sum of childs' stimes */
int *u_ar0; /* address of users saved R0 */
struct { /* profile arguments */
short *pr_base; /* buffer base */
unsigned pr_size; /* buffer size */
unsigned pr_off; /* pc offset */
unsigned pr_scale; /* pc scaling */
} u_prof;
char u_intflg; /* catch intr from sys */
char u_sep; /* flag for I and D separation */
struct tty *u_ttyp; /* controlling tty pointer */
dev_t u_ttyd; /* controlling tty dev */
struct { /* header of executable file */
int ux_mag; /* magic number */
unsigned ux_tsize; /* text size */
unsigned ux_dsize; /* data size */
unsigned ux_bsize; /* bss size */
unsigned ux_ssize; /* symbol table size */
unsigned ux_entloc; /* entry location */
unsigned ux_unused;
unsigned ux_relflg;
} u_exdata;
char u_comm[DIRSIZ];
time_t u_start;
char u_acflag;
short u_fpflag; /* unused now, will be later */
short u_cmask; /* mask for file creation */
int u_stack[1];
/* kernel stack per user
* extends from u + USIZE*64
* backward not to reach here
*/
};
That's quite a mouthful. Don't worry, in kos_start, my PCB was a little bit simpler:
typedef struct {
int reg [NumTotalRegs];
} PCB;
Context Switching
Switching among processes involves saving the context of the process into its PCB and placing it on some queue, depending on the cause of the context switch. Processes pre-empted due to time-slicing, may end up back on the "ready" queue, while processes that blocked on an I/O device will end up on that device's queue. Here's a general state diagram for a process:
Waiting processes may reside in one of several queues:
- A ready queue (could be multi-level, depending on the scheduler)
- A lock queue
- A device queue
- Swapped-out queue (for "medium-term" scheduler)
- Job queue (for "long-term" scheduler)
- Hardware instruction for storing and loading sets of registers
- Multiple sets of registers, as in Sun UltraSPARC
- Lightweight processes (aka threads) can make context switching unnecessary
Process Termination
Processes are terminated either when they exit() or when they receive a signal (some of which can be handled by the process, while others cannot). The operating system deallocates resources used by the terminate process - most notably, the open files are closed on the process's behalf - but keeps around a record of it, usually in the form of its PCB, until the parent collects its status via wait().- Zombies - child dies and parent does not wait
- Orphans - parent dies, so child gets adopted by init