Linux Processes

Travis WilleyJeff Mihalik

What is a process?

• A process is a program in execution

• A process includes:– program counter– stack– data section

A Process In Memory

• Stack:– Local variables declared inside

functions– Function Parameters

• Heap:– Dynamically allocated memory

• Data:– Global variables, etc.

• Text:– Program Instructions

Process State

• As a process executes, it changes state– TASK_RUNNING: Task is either running or on a runqueue

waiting to run.

– TASK_INTERRUPTIBLE: The process is waiting for some event to occur. Becomes running when event occurs.

– TASK_UNINTERRUPTIBLE: Identical to TASK_INTERRUPTIBLE except it does not wake up and become runnable if it receives a signal. Used rarely.

– TASK_ZOMBIE: The task has been terminated, but its parent has not yet issued a wait4() system call. The task's process descriptor must remain in case the parent wants to access it. If parent calls wait4(), descriptor is deallocated.

– TASK_STOPPED: Process execution has stopped; the task is not running nor is it eligible to run.

Family Hierarchy

• All processes are born from a parent, and all have 0 or more children.

• If the parent of a process dies, it becomes an orphan. The process is then adopted by the init process (PID 1).

• When a process dies, but is still in the queue, it is a zombie process.

Process Control Block (PCB)

• Information from various process is stored here,

also known as the task_struct:

– Process state

– Program counter

– CPU registers

– CPU scheduling information

– Memory-management information

– Accounting information

– I/O status information

PCB diagram

pt_regs

• Registers are actually stored in a struct

called pt_regs.

• This is an architecture-specific data

structure.

CPU Switch From Process to Process

Context Switch

• When CPU switches to another process,

the system must save the state of the old

process and load the saved state for the

new process

• Context-switch time is overhead; the

system does no useful work while switching

• Time dependent on hardware support

Process Creation

• Parent process create children processes, which, in turn

create other processes, forming a tree of processes

• Resource sharing

– Parent and children share all resources

– Children share subset of parent’s resources

– Parent and child share no resources

• Execution

– Parent and children execute concurrently

– Parent waits until children terminate

Process Creation (Cont.)

• Address space

– Child duplicate of parent

– Child has a program loaded into it

• UNIX examples

– fork system call creates new process

– exec system call used after a fork to replace

the process’ memory space with a new

program

Process Creation

Copy-on-Write• Copy-on-write is a technique that prevents copying all the data

when a new process is born. Parent and child processes share

a single copy of the data. If any of the data is written to, it is

marked and then a duplicate is made; each process receives its

own unique copy.

• Linux implements fork() via the clone() system call. The bulk of

the work is done in do_fork(), which calls copy_process(), then

the process starts running.

copy_process()• Calls dup_task_struct(), which creates a new kernel stack, thread_info structure, and task_struct for

the new process.

• Checks that new child will not exceed the resource limits on number of processes for the current

user.

• The child's state is set to TASK_UNINTERRUPTIBLE, to ensure that it does not yet run.

• Calls copy_flags() to update the flags member of the task_struct. The PF_SUPERPRIV flag, which

denotes whether a task used super-user privileges, is cleared. The PF_FORKNOEXEC flag, which

denotes a process that has not called exec(), is set.

• Now the child needs to differentiate itself from its parent. Various members of the process

descriptor are cleared or set to initial values. Members of the process descriptor that are not

inherited are primarily statistically information. The bulk of the data in the process descriptor is

shared.

copy_process() (cont'd)• Next, it calls get_pid() to assign an available PID to the new task

• Depending on the flags passed to clone(), copy_process() then either duplicates

or shares open files, filesystem information, signal handlers, process address

space, and namespace. These resources are typically shared between threads in

a given process; otherwise they are unique and copied here.

• The remaining timeslice between the parent and child is split between the two.

• Finally, copy_process() cleans up and returns to the caller a pointer to the new

child

C Program Forking Separate Processint main(){pid_t pid;

/* fork another process */

pid = fork();

if (pid < 0) { /* error occurred */

fprintf(stderr, "Fork Failed");

exit(-1);

}

else if (pid == 0) { /* child process */

execlp("/bin/ls", "ls", NULL);

}

else { /* parent process */

/* parent will wait for the child to complete */

wait (NULL);

printf ("Child Complete");

exit(0);

}}

A tree of processes on a typical Solaris

Process Termination• Process executes last statement and asks the operating system to delete it

(exit)

– Output data from child to parent (via wait)

– Process’ resources are deallocated by operating system

• Parent may terminate execution of children processes (abort)

– Child has exceeded allocated resources

– Task assigned to child is no longer required

– If parent is exiting

• Some operating system do not allow child to continue if its parent

terminates

– All children terminated - cascading termination

EXAM!

• What are the five states a process can be

in?

• Label the ps -ef columns.

• What happens to a Linux process when its

parents die?

References

• www.wikipedia.org

• CS430 Class slides

• Love, Robert. Linux Kernel Development.

Second edition.