Working with the Unix OS

Processes I
Process States
1. Executing in user mode
2. Executing in kernel mode
3. Not executing but ready to run
4. Sleeping (e.g.: I/O wait)
Processes can't be pre-empted while in kernel mode (otherwise mutual exclusion problems)
Kernel Data Structures
- Most fixed size
- Limiting approach but fast and simple
- If expansion beyond limits is needed then failure occurs
- Simple loops usually used to find spare entries
One Special User
- Super user (root)
- uid = 0
- gid = 0
A process is the ordered execution of a set of instructions (a "thread of execution") operating on a specific input.
Most programs when executed constitute a single process. Nonetheless, in many applications, it is efficient – either
in terms of computer hardware utilization or just to allow re-use of existing software – to build programs
consisting of several processes which are largely independent but which exchange intermediate results from time
to time ("co-operating sequential processes").
In 'C', such programs are built using the system calls: fork and usually, though not necessarily: exec
This allows the construction of sophisticated control programs which can be used to dispatch and monitor a whole
set of (utility) processes.
Related Systems Calls: wait, exit
! fork system call
produces a clone (child) process:
int fork() /* create a new process */
/* returns process_id and 0 on success or –1 on failure*/
child process has an almost exact copy of
- parent's code
- parent's user data
- parent's system data (e.g. environment)
void forktest()
{
int pid;
printf ("Start of test\n");
pid = fork();
printf ("Returned %d\n",pid);
}
output: start of test
Returned 0
Returned 93
Some of the parent's system data is NOT inherited:
- process-id, parent process-id
- execution times reset to zero
Also, while file descriptor table (parent-process open file table) is copied exactly, the file pointer open file table) is
shared and if the child closes its FD, the parent's is undisturbed.
exec system calls
94