Structure of Processes Chapter 6 Structure of Processes Process State and Transition Data Structure for Process Layout of System Memory THE DESIGN OF THE UNIX OPERATING SYSTEM Maurice J. bach Prentice Hall

Process image in virtural memory

Process Creation Assign a unique pid to the new process. Allocate space for all the elements of the process image. How much? The process control block is initialized. Inherit info from parent. The appropriate linkages are set: for scheduling, state queues.. Create and initialize other data structures

Process interruption Two kinds of process interruptions: interrupt and trap. Interrupt: Caused by some event external to and asynchronous to the currently running process, such as completion of IO. Trap : Error or exception condition generated within the currently running process. Ex: illegal access to a file, arithmetic exception. Supervisor call: explicit interruption

Unix System V All user processes in the system have as root ancestor a process called init. When a new interactive user logs onto the system, initcreates a user process, subsequently this user process can create child processes and so on. init is created at the boot-time. Process states : User running , kernel running, Ready in memory, sleeping in memory (blocked), Ready swapped (ready-suspended), sleeping swapped (blocked-suspended), created (new), zombie , preempted (used in real-time scheduling).

Cont…. Similar to our 7 state model 2 running states: User and Kernel 􀂄transitions to other states (blocked, ready) must come from kernel running Sleeping states (in memory, or swapped) correspond to our blocking states A preempted state is distinguished from the ready state (but they form 1 queue) Preemption can occur only when a process is about to move from kernel to user mode

Process States and Transitions User Running Preempted Zombie Asleep in Memory Sleep, Swapped Ready to Run, Swapped fork Created Ready to Run in Memory Kernel Running not enough mem (swapping system only) swap out wakeup enough mem sleep reschedule process preempt return to user system call, interrupt interrupt, interrupt return exit

Data Structures for Process Text Stack Data File Descriptor Table Per Process Region Table Kernel Process Table Kernel Region Table A Process U Area

Data Structure for Process (contd.) per process region table Kernel region table u area main memory Kernel process table

State of a Process Process table entry U area Contains general fields of processes that must be always be accessible to the kernel U area further characteristics of the process only need to be accessible to the running process itself

Process table entry State field: user running, kernel running etc. Fields that allow the kernel to locate the process and u area. Requires while context switch Process size : kernel know how much space to allocate for the process. User ID Process ID

Process table entry (contd.) Event descriptor. Used when the process is in the "sleep" state. Scheduling parameters. Allow the kernel to determine the order in which processes move to the states "kernel running" and "user running” A signal field. keeps the signals sent to a process but not yet handled. Various timers: process execution time, resource utilization etc.

U Area A pointer to the process table entry User IDs various Timer: Execution time in user mode Execution Time in kernel mode An error field: keeps error during system call Return value field: result of system call

U Area (contd.) I/O parameters The current directory and current root Amount of data transfer Address of source and target etc. The current directory and current root User file descriptor table Limit fields Restrict process size Restrict size of the file it can write The control terminal field: login terminal associated with the process, if one exists An array indicates how the process wishes to react to signal

Per Process Region Table (Pregion) Each pregion entry points to the kernel region table Starting virtual (absolute) address of the region Permission filed: read-only, read-write, read-execute

Kernel Region table Kernel region table contains the pointer to the page table which keeps the physical memory address

<Processes and Regions> 8K 16K 32K b a d c e 4K Text Data Stack Process A B Per Proc Region Tables (Virtual Addresses) Region <Processes and Regions>

Pages and Page Tables Logical Page Number Physical Page Number 0 177 0 177 1 54 2 209 3 17

Pages and Page Tables (contd.) 8K 32K 64K Text Data Stack 541K 783K 986K 897K 87K 552K 727K 941K empty 137K 852K 764K . 1096K 2001K 433K 333K Per Proc Region Table Page Tables(Physical Addresses) Virtual Addresses <Mapping Virtual Addresses to Physical Address>

Process and Context Switching Clock interrupt: The OS determines if the time slice of the currently running process is over, then switches it to Ready state, and dispatches another from Ready queue. “Process switch” Memory fault: (Page fault) A page fault occurs when the requested program page is not in the main memory. OS (page fault handler) brings in the page requested, resumes faulted process. IO Interrupt : OS determines what IO action occurred and takes appropriate action.

Cont… Process switch: A transition between two memory-resident processes in a multiprogramming environment. Context switch: Changing context from a executing program to an Interrupt Service Routine (ISR). Part of the context that will be modified by the ISR needs to be saved. This required context is saved and restored by hardware as specified by the ISR.

The context of a process The context of the process consists of the contents of its (user) address space and the contents of hardware register and kernel data structure that relate to the process. User-level context 􀂄Process Text (ie: code: read-only) 􀂄Process Data 􀂄User Stack (calls/returns in user mode) 􀂄Shared memory (for IPC) Register level context Program counter,Processor status register,Stack pointer, General purpose register

System-level context 􀂄Process table entry 􀂊the actual entry concerning this process in the Process Table maintained by OS 􀂄Process state, UID, PID, priority, event awaiting, signals sent, pointers to memory holding text, data... 􀂄U (user) area 􀂊additional process info needed by the kernel when executing in the context of this process 􀂄effective UID, timers, limit fields, files in use .􀂄Kernel stack (calls/returns in kernel mode) 􀂄Per Process Region Table (used by memory manager).