System Control Flow & Processes - University of …...Control Flow Processors do only one thing:...

transcript

CSE 351, Summer 2019L18: Processes

System Control Flow & ProcessesCSE 351 Summer 2019

Instructor:

Sam Wolfson

Teaching Assistants:

Daniel Hsu

Rehaan Bhimani

Corbin Modica

Administrivia

❖ Homework 4, due Wed 8/7 (Structs, Caches)

❖ Lab 4, due Monday (8/12)

Roadmap

car *c = malloc(sizeof(car));

c->miles = 100;

c->gals = 17;

float mpg = get_mpg(c);

free(c);

Car c = new Car();

c.setMiles(100);

c.setGals(17);

float mpg =

c.getMPG();

get_mpg:

pushq %rbp

movq %rsp, %rbp

popq %rbp

Java:C:

Assembly language:

Machine code:

0111010000011000

100011010000010000000010

1000100111000010

110000011111101000011111

Computer system:

Memory & dataIntegers & floatsx86 assemblyProcedures & stacksExecutablesArrays & structsMemory & cachesProcessesVirtual memoryMemory allocationJava vs. C

Leading Up to Processes

❖ System Control Flow

▪ Control flow

▪ Exceptional control flow

▪ Asynchronous exceptions (interrupts)

▪ Synchronous exceptions (traps & faults)

Control Flow

❖ So far: we’ve seen how the flow of control changes as a single program executes

❖ Reality: multiple programs running concurrently

▪ How does control flow across the many components of the system?

▪ In particular: More programs running than CPUs

❖ Exceptional control flow is basic mechanism used for:

▪ Transferring control between processes and OS

▪ Handling I/O and virtual memory within the OS

▪ Implementing multi-process apps like shells and web servers

▪ Implementing concurrency5

Control Flow

❖ Processors do only one thing:

▪ From startup to shutdown, a CPU simply reads and executes (interprets) a sequence of instructions, one at a time

▪ This sequence is the CPU’s control flow (or flow of control)

<startup>instr1

instr2

instr3

…instrn

Physical control flow

Altering the Control Flow

❖ Up to now, two ways to change control flow:▪ Jumps (conditional and unconditional)

▪ Call and return

▪ Both react to changes in program state

❖ Processor also needs to react to changes in system state▪ Unix/Linux user hits “Ctrl-C” at the keyboard

▪ User clicks on a different application’s window on the screen

▪ Data arrives from a disk or a network adapter

▪ Instruction divides by zero

▪ System timer expires

❖ Can jumps and procedure calls achieve this?▪ No – the system needs mechanisms for “exceptional” control flow!

Java Digression

❖ Java has exceptions, but they’re something different▪ e.g., NullPointerException, OhHeckSomethingHappenedException, …

▪ throw statements

▪ try/catch statements (“throw to youngest matching catch on the call-stack, or exit-with-stack-trace if none”)

❖ Java exceptions are for reacting to (unexpected) program state▪ Can be implemented with stack operations and conditional jumps

▪ A mechanism for “many call-stack returns at once”

▪ Requires additions to the calling convention, but we already have the CPU features we need

❖ System-state changes on previous slide are mostly of a different sort (asynchronous/external except for divide-by-zero) and implemented very differently

This is extra (non-testable)

material

Exceptional Control Flow

❖ Exists at all levels of a computer system

❖ Low level mechanisms▪ Exceptions

• Change in processor’s control flow in response to a system event (i.e. change in system state, user-generated interrupt)

• Implemented using a combination of hardware and OS software

❖ Higher level mechanisms▪ Process context switch

• Implemented by OS software and hardware timer

▪ Signals

• Implemented by OS software

• We won’t cover these – see CSE451 and CSE/EE474

Exceptions

❖ An exception is transfer of control to the operating system (OS) kernel in response to some event (i.e. change in processor state)

▪ Kernel is the memory-resident part of the OS

▪ Examples: division by 0, page fault, I/O request completes, Ctrl-C

❖ How does the system know where to jump to in the OS?10

User Code OS Kernel Code

exceptionexception processing by exception handler, then:• return to current_instr,• return to next_instr, OR• abort

current_instrnext_instr

Exception Table

❖ A jump table for exceptions (also called Interrupt Vector Table)▪ Each type of event has a unique

exception number 𝑘

▪ 𝑘 = index into exception table(a.k.a interrupt vector)

▪ Handler 𝑘 is called each timeexception 𝑘 occurs

ExceptionTable

code for exception handler 0

code for exception handler 1

code forexception handler 2

code for exception handler n-1

Exception numbers

Exception Table (Excerpt)

Exception Number Description Exception Class

0 Divide error Fault

13 General protection fault Fault

14 Page fault Fault

18 Machine check Abort

32-255 OS-defined Interrupt or trap

Leading Up to Processes

❖ System Control Flow

▪ Control flow

▪ Exceptional control flow

▪ Asynchronous exceptions (interrupts)

▪ Synchronous exceptions (traps & faults)

Asynchronous Exceptions (Interrupts)

❖ Caused by events external to the processor▪ Indicated by setting the processor’s interrupt pin(s) (wire into CPU)

▪ After interrupt handler runs, the handler returns to “next” instruction

❖ Examples:▪ I/O interrupts

• Hitting Ctrl-C on the keyboard

• Clicking a mouse button or tapping a touchscreen

• Arrival of a packet from a network

• Arrival of data from a disk

▪ Timer interrupt

• Every few ms, an external timer chip triggers an interrupt

• Used by the OS kernel to take back control from user programs

Synchronous Exceptions

❖ Caused by events that occur as a result of executing an instruction:▪ Traps

• Intentional: transfer control to OS to perform some function

• Examples: system calls (e.g., file I/O), breakpoint traps, special instructions

• Returns control to “next” instruction

▪ Faults

• Unintentional but possibly recoverable

• Examples: page faults, segment protection faults, integer divide-by-zero exceptions

• Either re-executes faulting (“current”) instruction or aborts

▪ Aborts

• Unintentional and unrecoverable

• Examples: parity error, machine check (hardware failure detected)

• Aborts current program

System Calls

❖ Each system call has a unique ID number

❖ Examples for Linux on x86-64:

Number Name Description

0 read Read file

1 write Write file

2 open Open file

3 close Close file

4 stat Get info about file

57 fork Create process

59 execve Execute a program

60 _exit Terminate process

62 kill Send signal to process

Traps Example: Opening File

❖ User calls open(filename, options)

❖ Calls __open function, which invokes system call instruction syscall

00000000000e5d70 <__open>:

e5d79: b8 02 00 00 00 mov $0x2,%eax # open is syscall 2

e5d7e: 0f 05 syscall # return value in %rax

e5d80: 48 3d 01 f0 ff ff cmp $0xfffffffffffff001,%rax

e5dfa: c3 retq

User code OS Kernel code

Exception

Open file

Returns

syscallcmp

%rax contains syscall number

Other arguments in %rdi, %rsi, %rdx, %r10, %r8, %r9

Return value in %rax

Negative value is an error corresponding to negative errno

Fault Example: Page Fault

❖ User writes to memory location

❖ That portion (page) of user’s memory is currently on disk

❖ Page fault handler must load page into physical memory

❖ Returns to faulting instruction: mov is executed again!

▪ Successful on second try18

int a[1000];

int main ()

a[500] = 13;

80483b7: c7 05 10 9d 04 08 0d movl $0xd,0x8049d10

User code OS Kernel code

exception: page fault

Create page and load into memoryreturns

movlhandle_page_fault:

Fault Example: Invalid Memory Reference

❖ Page fault handler detects invalid address

❖ Sends SIGSEGV signal to user process

❖ User process exits with Segmentation fault19

int a[1000];

int main()

a[5000] = 13;

80483b7: c7 05 60 e3 04 08 0d movl $0xd,0x804e360

User Process OS

exception: page fault

detect invalid address

signal process

handle_page_fault:

Summary

❖ Exceptions

▪ Events that require non-standard control flow

▪ Generated externally (interrupts) or internally (traps and faults)

▪ After an exception is handled, one of three things may happen:• Re-execute the current instruction

• Resume execution with the next instruction

• Abort the process that caused the exception

Processes

❖ Processes and context switching

❖ Creating new processes▪ fork(), exec*(), and wait()

❖ Zombies

Process 1

What is a process?

Registers %rip

Memory

Chrome.exe

It’s an illusion!

What is a process?

❖ Another abstraction in our computer system

▪ Provided by the OS

▪ OS uses a data structure to represent each process

▪ Maintains the interface between the program and the underlying hardware (CPU + memory)

❖ What do processes have to do with exceptional control flow?

▪ Exceptional control flow is the mechanism the OS uses to enable multiple processes to run on the same system

❖ What is the difference between:

▪ A processor? A program? A process?

Processes

❖ A process is an instance of a running program

▪ One of the most profound ideas in computer science

▪ Not the same as “program” or “processor”

❖ Process provides each program with two key abstractions:

▪ Logical control flow• Each program seems to have exclusive use of the CPU

• Provided by kernel mechanism called context switching

▪ Private address space• Each program seems to have exclusive use of main memory

• Provided by kernel mechanism called virtual memory

Registers

Memory

CodeData

What is a process?

Computer

Disk/Applications/

Chrome.exe Slack.exe PowerPoint.exe

Process 2

Process 3

Process 4Process 1

“Memory”

“CPU”Registers

“Memory”

“CPU”Registers

“Memory”

“CPU”Registers

“Memory”

“CPU”Registers

It’s an illusion!

What is a process?

Computer

Disk/Applications/

Chrome.exe Slack.exe PowerPoint.exe

Process 1

“Memory”

“CPU”Registers

Process 2

“Memory”

“CPU”Registers

Process 3

“Memory”

“CPU”Registers

Process 4

“Memory”

“CPU”Registers

OperatingSystem

It’s an illusion!

Multiprocessing: The Illusion

❖ Computer runs many processes simultaneously

▪ Applications for one or more users• Web browsers, email clients, editors, …

▪ Background tasks• Monitoring network & I/O devices

Registers

Memory

CodeData

Registers

Memory

CodeData …

Registers

Memory

CodeData

Multiprocessing: The Reality

❖ Single processor executes multiple processes concurrently▪ Process executions interleaved, CPU runs one at a time

▪ Address spaces managed by virtual memory system (later in course)

▪ Execution context (register values, stack, …) for other processes saved in memory 28

Registers

Memory

Saved registers

Multiprocessing

❖ Context switch1) Save current registers in memory

Registers

Memory

Saved registers

Multiprocessing

2) Schedule next process for execution

Registers

Memory

Saved registers

Multiprocessing

Registers

Memory

Saved registers

2) Schedule next process for execution

3) Load saved registers and switch address space

Multiprocessing: The (Modern) Reality

❖ Multicore processors▪ Multiple CPUs (“cores”) on single chip

▪ Share main memory (and some of the caches)

▪ Each can execute a separate process

• Kernel schedules processes to cores

• Still constantly swapping processes

Registers

Memory

Saved registers

Registers

Concurrent Processes

❖ Each process is a logical control flow

❖ Two processes run concurrently (are concurrent) if their instruction executions (flows) overlap in time

▪ Otherwise, they are sequential

❖ Example: (running on single core)

▪ Concurrent: A & B, A & C

▪ Sequential: B & C

Process A Process B Process C

Assume only one CPU

User’s View of Concurrency

❖ Control flows for concurrent processes are physically disjoint in time

▪ CPU only executes instructions for one process at a time

❖ However, the user can think of concurrent processes as executing at the same time, in parallel

Assume only one CPU

Process A Process B Process C

User View

Context Switching

❖ Processes are managed by a shared chunk of OS code called the kernel▪ The kernel is not a separate process, but rather runs as part of a user

process

❖ In x86-64 Linux:▪ Same address in each process

refers to same shared memory location

Assume only one CPU

Context Switching

❖ Processes are managed by a shared chunk of OS code called the kernel▪ The kernel is not a separate process, but rather runs as part of a user

process

❖ Context switch passes control flow from one process to another and is performed using kernel code

Process A Process B

user code

kernel code

user code

kernel code

user code

context switch

Assume only one CPU

Processes

❖ Processes and context switching

❖ Creating new processes▪ fork() , exec*(), and wait()

❖ Zombies

Process 2

“Memory”

CodeData

“CPU”

Registers

Creating New Processes & Programs

Chrome.exe

Process 1

“Memory”

CodeData

“CPU”

Registers

fork()

exec*()

Creating New Processes & Programs

❖ fork-exec model (Linux):▪ fork() creates a copy of the current process

▪ exec*() replaces the current process’ code and address space with the code for a different program• Family: execv, execl, execve, execle, execvp, execlp

▪ fork() and execve() are system calls

❖ Other system calls for process management:▪ getpid()

▪ exit()

▪ wait(), waitpid()

fork: Creating New Processes

❖ pid_t fork(void)

▪ Creates a new “child” process that is identical to the calling “parent” process, including all state (memory, registers, etc.)

▪ Returns 0 to the child process

▪ Returns child’s process ID (PID) to the parent process

❖ Child is almost identical to parent:▪ Child gets an identical

(but separate) copy of the parent’s virtual address space

▪ Child has a different PID than the parent

❖ fork is unique (and often confusing) because it is called oncebut returns “twice”

pid_t pid = fork();

if (pid == 0) {

printf("hello from child\n");

} else {

printf("hello from parent\n");

Understanding fork

Process X (parent)

pid_t pid = fork();

if (pid == 0) {

} else {

Process Y (child)

pid_t pid = fork();

if (pid == 0) {

} else {

Understanding fork

pid_t pid = fork();

if (pid == 0) {

} else {

pid_t pid = fork();

if (pid == 0) {

} else {

pid = Y pid = 0

Process X (parent)

pid_t pid = fork();

if (pid == 0) {

} else {

Process Y (child)

pid_t pid = fork();

if (pid == 0) {

} else {

Understanding fork

pid_t pid = fork();

if (pid == 0) {

} else {

pid_t pid = fork();

if (pid == 0) {

} else {

pid = Y pid = 0

Process X (parent)

pid_t pid = fork();

if (pid == 0) {

} else {

Process Y (child)

pid_t pid = fork();

if (pid == 0) {

} else {

hello from parent hello from child

Which one appears first?

Fork Example

❖ Both processes continue/start execution after fork▪ Child starts at instruction after the call to fork (storing into pid)

❖ Can’t predict execution order of parent and child

❖ Both processes start with x=1▪ Subsequent changes to x are independent

❖ Shared open files: stdout is the same in both parent and child

void fork1() {

int x = 1;

pid_t pid = fork();

if (pid == 0)

printf("Child has x = %d\n", ++x);

printf("Parent has x = %d\n", --x);

printf("Bye from process %d with x = %d\n", getpid(), x);

Modeling fork with Process Graphs

❖ A process graph is a useful tool for capturing the partial ordering of statements in a concurrent program▪ Each vertex is the execution of a statement

▪ a→ b means a happens before b

▪ Edges can be labeled with current value of variables

▪ printf vertices can be labeled with output

▪ Each graph begins with a vertex with no inedges

❖ Any topological sort of the graph corresponds to a feasible total ordering▪ Total ordering of vertices where all edges point from left to right

Fork Example: Possible Output

void fork1() {

int x = 1;

pid_t pid = fork();

if (pid == 0)

printf("Child has x = %d\n", ++x);

printf("Parent has x = %d\n", --x);

printf("Bye from process %d with x = %d\n", getpid(), x);

printf--x printffork

printf printf++x

Parent

Fork-Exec

❖ fork-exec model:▪ fork() creates a copy of the current process

▪ exec*() replaces the current process’ code and address space with the code for a different program• Whole family of exec calls – see exec(3) and execve(2)

// Example arguments: path="/usr/bin/ls",

// argv[0]="/usr/bin/ls", argv[1]="-ahl", argv[2]=NULL

void fork_exec(char *path, char *argv[]) {

pid_t pid = fork();

if (pid != 0) {

printf("Parent: created a child %d\n", pid);

} else {

printf("Child: about to exec a new program\n");

execv(path, argv);

printf("This line printed by parent only!\n");

Note: the return values of fork and exec* should be checked for errors

Exec-ing a new program

Code: /usr/bin/bash

Code: /usr/bin/ls

fork()

exec*()

Very high-level diagram of what happens when you run the command “ls” in a Linux shell:❖ This is the loading part of CALL!

parent child child

execve Example

"/usr/bin/ls"

"lab4"

"USER=jhsia"

"PWD=/homes/iws/jhsia"

myargv[argc] = NULL

myargv[2]

myargv[1]

myargv[0]

envp[n] = NULL

envp[n-1]

envp[0]environ

myargv

if ((pid = fork()) == 0) { /* Child runs program */

if (execve(myargv[0], myargv, environ) < 0) {

printf("%s: Command not found.\n", myargv[0]);

exit(1);

Execute "/usr/bin/ls –l lab4" in child process using current environment:

(argc == 3)

Run the printenv command in a Linux shell to see your own environment variables

This is extra (non-testable)

material

Structure of the Stack when a new program starts

Null-terminatedenvironment variable strings

Null-terminatedcommand-line arg strings

envp[n] == NULL

envp[n-1]

...envp[0]

argv[argc] = NULL

argv[argc-1]

...argv[0]

Future stack frame formain

environ

(global var)

Bottom of stack

Top of stack

(in %rsi)

(in %rdx)

Stack frame for libc_start_main

(in %rdi)This is extra

(non-testable) material

exit: Ending a process

❖ void exit(int status)

▪ Explicitly exits a process• Status code: 0 is used for a normal exit, nonzero for abnormal exit

❖ The return statement from main() also ends a process in C

▪ The return value is the status code

Summary

❖ Processes

▪ At any given time, system has multiple active processes

▪ On a one-CPU system, only one can execute at a time, but each process appears to have total control of the processor

▪ OS periodically “context switches” between active processes• Implemented using exceptional control flow

❖ Process management▪ fork: one call, two returns

▪ execve: one call, usually no return

▪ wait or waitpid: synchronization

▪ exit: one call, no return

Detailed examples:

❖ Consecutive forks

Example: Two consecutive forks

void fork2() {

printf("L0\n");

fork();

printf("L1\n");

fork();

printf("Bye\n");

printf printf fork

printf

printffork

printf fork

printf

Feasible output:

Infeasible output:

Example: Three consecutive forks

❖ Both parent and child can continue forking

void fork3() {

printf("L0\n");

fork();

printf("L1\n");

fork();

printf("L2\n");

fork();

printf("Bye\n");

} L1 L2

System Control Flow & Processes - University of …...Control Flow Processors do only one thing:...

Documents