Process

Process Concept

• Process – a program in execution • Textbook uses the terms job and process almost

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

• Process life-cycle

Process =? Program

• More to a process than just a program:– Program is static, with the potential for exection– process is a program in execution and have a state – One program can be executed several times and thus has

several processes

main () {

…;

}

A() {

…

}

main () {

…;

}

A() {

…

}

Heap

Stack

Amain

Program Process

Process Description: Process Control Block (PCB)

• Information associated with each process– Process state– Program counter– CPU registers– CPU scheduling information– Memory-management information– Accounting information– I/O status information

• A process is named using its process ID (PID)• Data is stored in a process control block (PCB)

Ready Queue And Various I/O Device Queues

CPU Switch From Process to Process

Process Creation• A process is created by another process, which, in turn create other

processes, forming a tree of processes

• Parent and child process• In Linux, using “ps –f”, the PPID field is the parent• The fist process is Init

• After creating a child, the parent may either wait for it to finish or continue currently

• Some system, the children inherit the privileges of the parents• Unix: children of the shell inherit the Process User ID and thus execute with

the user’s privileges

Linux Process Tree

Unix Process: ps -f

Process Creation• Address space

– Child duplicate of parent

– Child has a program loaded into it

• UNIX examples– The fork() system call in Unix creates a new process. After a

successful fork() call, two copies of the original code will be running. In the original process (the parent) the return value of fork() will be the process ID of the child. In the new child process the return value of fork() will be 0

– exec system call used after a fork() to replace the process’ memory space with a new program

Process Creation: Unix

• In Unix, processes are created using fork()• Creates and initializes a PCB and creates a new

address space• Initializes the address space with a copy of the

entire contents of the address space of the parent• Initializes the kernel resources to point to the

resources used by parent (e.g., open files)• Places the PCB on the ready queue• Fork returns twice: Returns the child’s PID to the

parent, “0” to the child

Creating Processes in UNIX• Every process in UNIX has a unique identifier PID. The UNIX ps

command lists each process associated with the user executing the command

• Whenever a (parent) process calls a fork(), a child process is created with its own descriptor, including its own copies of the parent’s program text, data, and stack segments

• The child and parent processes execute in their own separate address spaces

• This means that even though they have access to the same information, when the child is created, both the child and its parent each reference its own copy of the information

Process Creation: Unix

• How do we actually start a new program?• int exec(char *prog, char *argv[])• Stops the current process• Loads the program “prog” into the process’

address space• Initializes hardware context and args for the

new program• Places the PCB onto the ready queue

#include <stdio.h>

#include <stdlib.h>

main()

{

int pid;

int rv;

pid=fork();

switch(pid){

case -1:

printf("Error -- Something went wrong with fork()\n");

exit(1); // parent exits

case 0:

printf("CHILD: This is the child process!\n");

printf("CHILD: My PID is %d\n", getpid());

printf("CHILD: My parent's PID is %d\n", getppid());

printf("CHILD: Enter my exit status: ");

scanf(" %d", &rv);

printf("CHILD: I'm outta here!\n");

exit(rv);

default:

printf("PARENT: This is the parent process!\n");

printf("PARENT: My PID is %d\n", getpid());

printf("PARENT: My child's PID is %d\n", pid);

printf("PARENT: I'm now waiting for my child to exit()...\n");

wait(&rv);

printf("PARENT: I'm outta here!\n");

}

}

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

main()

{

int pid;

pid=fork();

switch(pid){

case -1:

printf("Error -- Something went wrong with fork()\n");

exit(1); // parent exits

case 0:

execl("/bin/date","date",0); // this is the code the child runs

default:

wait(NULL);

printf("PARENT: I'm outta here!\n");

}

}

System Calls

System Calls• “system call” == “a function call that invokes the operating

system services”• These OS services typically written in a high-level language (C or C+

+), are isolated from the user programs.• OS provides service to user program via system calls.

System Call Interface

• System calls Mostly accessed by programs via a high-level Application Program Interface (API)

• Three most common APIs are Win32 API for Windows, POSIX API for POSIX-based systems (including virtually all versions of UNIX, Linux, and Mac OS X), and Java API for the Java virtual machine (JVM)

• Behind the scenes, functions that make up an API typically invoke system calls. Why would an application programmer prefer programming according to an API rather than invoking actual system calls?

System Calls vs. Library Routines

• A system call is just what its name implies – a request for the OS do something on behalf of the user’s program– E.g., read is a system call which asks the OS to fill a

buffer with data stored on a disk drive (or other device). It would be chaotic if everyone were able to access devices whenever they pleased!

• A library routine does not usually need the OS to perform its work– E.g., the sin function, which computes the sine of an

angle

Invoke the OS

• Hardware interrupt: Interrupts signal to the CPU that a hardware device has an event that needs attention, e.g. disk I/O complete, network packet arrived, keyboard input arrived, etc.

• Software trap: Interrupts also signal errors or requests for OS intervention (a system call), often called an “exception” or “trap”

• Explicit system call: application requests service

Example of System Calls

Example of System Calls• Suppose you have just compiled a program, producing, say for a Unix system, an

executable file a.out. To run it, you type a.out – The shell reads the command you type– The shell then makes a system call, execve() ,asking the OS to run a.out. The OS is now

running– The OS looks in its disk directory, to determine where on disk the file a.out is – The OS checks its memory-allocation table (this is just an array in the OS) to find an

unused region or regions of memory large enough for a.out as well as for stack space and the heap (used for calls to calloc() and malloc())

– The OS will then load a.out into those regions of memory, and will update its memory-allocation table accordingly

– The OS will check a certain section of the a.out file, in which the linker previously recorded a.out's entry point, i.e. the instruction in a.out at which execution is to begin

– The OS is now ready to initiate execution of a.out– The a.out program is now running!

System Call Implementation

• Typically, a number associated with each system call– System-call interface maintains a table indexed according to these numbers

• The system call interface invokes intended system call in OS kernel and returns status of the system call and any return values

• The caller need know nothing about how the system call is implemented– Just needs to obey API and understand what OS will do as a result call

– Most details of OS interface hidden from programmer by API • Managed by run-time support library (set of functions built into libraries included

with compiler)

Standard C Library Example• C program invoking printf() library call, which calls write() system call