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 A main 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 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 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 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

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