CS 537 Lecture 2 - Processes

Transcription

1 CS 537 Lecture 2 - Processes Michael Swift 1 Basic Structure Kernel is a big program that starts when you boot your program Has full access to physical hardware. User programs, utilities, services see virtual hardware user programs Utilities Services OS Kernel everything hardware 9/10/07 2 1

2 Why Processes? Simplicity + Speed Hundreds of things going on in the system nfsd ls OS gcc emacs wwwlpr nfsd ls www OS emacs lpr How to make things simple? Separate each in an isolated process Decomposition How to speed-up? Overlap I/O bursts of one process with CPU bursts of another 3 The Process The process is the OS s abstraction for execution the unit of execution the unit of scheduling the dynamic (active) execution context compared with program: static, just a bunch of bytes Process is often called a job, task, or sequential process a sequential process is a program in execution defines the instruction-at-a-time execution of a program 4 2

3 A program consists of: What is a program? Code: machine instructions Data: variables stored and manipulated in memory initialized variables (globals) dynamically allocated variables (malloc, new) stack variables (C automatic variables, function arguments) What is added by a process? DLLs: libraries that were not compiled or linked with the program containing code & data, possibly shared with other programs mapped files: memory segments containing variables (mmap()) used frequently in database programs OS resources: open files Whats the relationship between a program and process? A process is a executing program 5 Preparing a Program compiler/ assembler Linker source file Header.o files static libraries (libc, streams ) Code Initialized data BSS Executable file (must follow standard format, such as ELF on Linux, Microsoft PE on Windows) Symbol table Line numbers Ext. refs 6 3

4 Running a program OS creates a process and allocates memory for it The loader: reads and interprets the executable file sets process s memory to contain code & data from executable pushes argc, argv, envp on the stack sets the CPU registers properly & calls start() [Part of CRT0] Program start running at start(), which calls main() we say process is running, and no longer think of program When main() returns, CRT0 calls exit() destroys the process and returns all resources 7 What s in a Process? A process consists of (at least): an address space: set of addresses only available to this running proram the code for the running program the data for the running program an execution stack and stack pointer (SP) traces state of procedure calls made the program counter (PC), indicating the next instruction a set of general-purpose processor registers and their values a set of OS resources open files, network connections, sound channels, The process is a container for all of this state a process is named by a process ID (PID) just an integer 8 4

5 Process!= Program mapped segments Header Code Initialized data BSS Symbol table Line numbers Ext. refs Executable Program is passive Code + data Process is running program stack, regs, program counter SP Process Example: address space We both run Firefox: - Same program - Separate processes DLL s Stack Heap BSS Initialized data PC Code 9 Process states Each process has an execution state, which indicates what it is currently doing ready: waiting to be assigned to CPU could run, but another process has the CPU running: executing on the CPU is the process that currently controls the CPU pop quiz: how many processes can be running simultaneously? waiting: waiting for an event, e.g. I/O cannot make progress until event happens As a process executes, it moves from state to state UNIX: run ps, STAT column shows current state which state is a process is most of the time? 10 5

6 Process state transitions New create Ready I/O done unschedule schedule Waiting Terminated kill Running I/O, page fault, etc. What can cause schedule/unschedule transitions? 11 Process data structures How does the OS represent a process in the kernel? at any time, there are many processes, each in its own particular state the OS data structure that represents each is called the process control block (PCB) PCB contains all info about the process OS keeps all of a process hardware execution state in the PCB when the process isn t running PC SP registers when process is unscheduled, the state is transferred out of the hardware into the PCB 12 6

7 PCB The PCB is a data structure with many, many fields: process ID (PID) execution state program counter, stack pointer, registers memory management info UNIX username of owner scheduling priority accounting info pointers into state queues In linux: defined in task_struct (include/linux/sched.h) over 95 fields!!! 13 Simple Process Control Block process state process number program counter stack pointer registers (general, FP) memory management info username of owner queue pointers for state queues scheduling info (priority, etc.) accounting info 14 7

8 PCBs and Hardware State When a process is running, its hardware state is inside the CPU PC, SP, registers CPU contains current values When the OS stops running a process (puts it in the waiting state), it saves the registers values in the PCB when the OS puts the process in the running state, it loads the hardware registers from the values in that process PCB The act of switching the CPU from one process to another is called a context switch timesharing systems may do 100s or 1000s of switches/s takes about 5 microseconds on today s hardware 15 CPU Switch From Process to Process 8

9 State queues The OS maintains a collection of queues that represent the state of all processes in the system typically one queue for each state e.g., ready, waiting, each PCB is queued onto a state queue according to its current state as a process changes state, its PCB is unlinked from from queue, and linked onto another Job queue set of all processes in the system Ready queue set of all processes residing in main memory, ready and waiting to execute Device queues set of processes waiting for an I/O device 17 Ready queue header head ptr tail ptr State queues firefox pcb emacs pcb ls pcb A Wait queue header head ptr tail ptr cat pcb firefox pcb There may be many wait queues, one for each type of wait (particular device, timer, message, ) 18 9

10 Process creation One process can create another process creator is called the parent created process is called the child UNIX: do ps, look for PPID (parent PID) field what creates the first process, and when? In some systems, parent defines or donates resources and privileges for its children UNIX: child inherits parents userid field, etc. when child is created, parent may either wait for it to finish, or it may continue in parallel, or both! 19 UNIX process creation UNIX process creation through fork() system call creates and initializes a new PCB New PID, set parent in PPID creates a new address space initializes new address space with a copy of the entire contents of the address space of the parent initializes kernel resources of new process with resources of parent (e.g. open files) places new PCB on the ready queue the fork() system call returns twice once into the parent, and once into the child returns the child s PID to the parent returns 0 to the child 20 10

11 fork( ) int main(int argc, char **argv) { char *name = argv[0]; int child_pid = fork(); if (child_pid == 0) { printf( Child of %s is %d\n, name, child_pid); return 0; } else { printf( My child is %d\n, child_pid); return 0; } } 21 output spinlock% gcc -o testparent testparent.c spinlock%./testparent My child is 486 Child of testparent is 0 spinlock%./testparent Child of testparent is 0 My child is

12 Fork and exec So how do we start a new program, instead of just forking the old program? the exec() system call! int exec(char *prog, char ** argv) exec() stops the current process loads program prog into the address space initializes hardware context, args for new program places PCB onto ready queue note: does not create a new process! what does it mean for exec to return? what happens if you exec csh in your shell? what happens if you exec ls in your shell? 23 UNIX shells int main(int argc, char **argv) { while (1) { char *cmd = get_next_command(); int child_pid = fork(); if (child_pid == 0) { manipulate STDIN/STDOUT/STDERR fd s exec(cmd); panic( exec failed! ); } else { wait(child_pid); } } } 24 12

13 Process Termination Process executes last statement and OS decides(exit) Output data from child to parent (via wait) Process resources are deallocated by operating system Parent may terminate execution of child process (abort) Child has exceeded allocated resources Task assigned to child is no longer required If parent is exiting Some OSes don t allow child to continue if parent terminates All children terminated - cascading termination 25 Limited Direct Execution Problem: how does the OS share the CPU between multiple processes, but remain in control Proposal: time sharing switching back and forth between multiple processes, each running for a short time (10ms) How virtualize CPU without adding overhead How maintain control, so a buggy/malicious process cannot take over? Solution: Limited direct execution Let programs run directly on the CPU, but not do everything To start a program, OS jumps to first instruction of program s main function (more or less) Ed Lazowska, Hank Levy, Andrea and 26 13

14 Restricted Operations Problem: some operations shouldn t be available to programs Writing data to a disk: how separate users from each other? Solution: modes Ed Lazowska, Hank Levy, Andrea and 27 Privileged instructions some instructions are restricted to the OS known as protected or privileged instructions e.g., only the OS can: directly access I/O devices (disks, network cards) why? manipulate memory state management Which process can access which memory halt instruction why? 14

15 OS protection So how does the processor know if a protected instruction should be executed? the architecture must support at least two modes of operation: kernel mode and user mode mode is set by status bit in a protected processor register user programs execute in user mode OS executes in kernel mode (OS == kernel) Protected instructions can only be executed in the kernel mode what happens if user mode executes a protected instruction? CPU enters protected mode automatically on interrupts/traps/exceptions E.g. network packet arrives Crossing protection boundaries So how do user programs do something privileged? e.g., how can you write to a disk if you can t do I/O instructions? User programs must call an OS procedure OS defines a sequence of system calls how does the user-mode to kernel-mode transition happen? Why limit set of functions that can be called? There must be a system call operation, which: causes an exception (throws a software interrupt), which vectors to a kernel handler passes a parameter indicating which system call to invoke saves caller s state (regs, mode bit) so they can be restored OS must verify caller s parameters (e.g., pointers) must be a way to return to user mode once done 15

16 A kernel crossing illustrated User process System Call User Mode Mode bit = 1 Resume process Trap Mode bit = 0 Kernel Mode Mode bit = 0 Return Mode bit = 1 Save Caller s state Execute system call Restore state System call details How does the kernel know which system call? In a register Where are the parameters? in a register on the stack in a memory block Limit set of kernel functions System call table <open>: push %ebx <open+1>: mov 0x10(%esp),%edx <open+5>: mov 0xc(%esp),%ecx <open+9>: mov 0x8(%esp),%ebx <open+13>: mov $0x5,%eax <open+18>: int $0x80 <open+20>: pop %ebx <open+21>: cmp $0xfffff001,%eax <open+26>: jae 0x2a189d <open+29> <open+28>: ret # system call handler stub ENTRY(system_call) pushl %eax # save orig_eax SAVE_ALL GET_THREAD_INFO(%ebp) cmpl $(nr_syscalls), %eax jae syscall_badsys syscall_call: call *sys_call_table(,%eax,4) movl %eax,eax(%esp) # store the return value 16

17 Switching between processes When should OS switch between processes, and how does it make it happen? Want to switch when one process is running Implies OS is not running! Solution 1: cooperation Wait for process to make system call into OS E.g. read, write, fork Wait for process to voluntarily give up CPU E.g. yield() Wait for process to do something illegal Divide by zero, dereference zero Problem: what if process is buggy and has infinite loop? Solution 2: Forcibly take control Ed Lazowska, Hank Levy, Andrea and 33 Preemptive Context Switches How can OS get control while a process runs? How does OS ever get control? Traps: exceptions, interrupts (system call = exception) Solution: force an interrupt with a timer OS programs hardware timer to go off every x ms On timer interrupt, OS can decide whether to switch programs or keep running Ed Lazowska, Hank Levy, Andrea and 34 17

18 Saving and Restoring Context How does the OS actually save/restore context for a process? Context = registers describing running code Assembly code to save current registers (stack pointer, frame pointer, GPRs, address space & load new ones) Switch routine: pass old and new PCBs Enter as old process, return as new process Ed Lazowska, Hank Levy, Andrea and 35 Context Switch Code # void swtch(struct context *old, struct context *new); # # Save current register context in old # and then load register context from new..globl swtch swtch: # Save old registers # put old ptr into eax movl 4(%esp), %eax popl 0(%eax) # save the old IP and stack and other registers movl %esp, 4(%eax) movl %ebx, 8(%eax) movl %ecx, 12(%eax) movl %edx, 16(%eax) movl %esi, 20(%eax) movl %edi, 24(%eax) movl %ebp, 28(%eax) pushl 0(%eax) # put new ptr into eax # restore other registers movl 4(%esp), %eax movl 28(%eax), %ebp movl 24(%eax), %edi movl 20(%eax), %esi movl 16(%eax), %edx movl 12(%eax), %ecx movl 8(%eax), %ebx # stack is switched here # return addr put in place # finally return into new ctxt movl 4(%eax),%esp ret Note: do not explicitly switch IP; happens when return from switch function Ed Lazowska, Hank Levy, Andrea and 36 18