CS 423 Operating System Design: The Kernel Abstraction Professor - - PowerPoint PPT Presentation

▶
cs 423 operating system design the kernel abstraction
SMART_READER_LITE
LIVE PREVIEW

CS 423 Operating System Design: The Kernel Abstraction Professor - - PowerPoint PPT Presentation

Sep 24, 2022 318 likes •824 views

CS 423 Operating System Design: The Kernel Abstraction Professor Adam Bates CS423: Operating Systems Design Goals for Today Learning Objectives: (Learn how to use the vSphere console) Understand the Kernel/Process Abstraction

slide-1
SLIDE 1

CS423: Operating Systems Design

Professor Adam Bates

CS 423
 Operating System Design:
 The Kernel Abstraction

slide-2
SLIDE 2

CS 423: Operating Systems Design 2

  • Learning Objectives:
  • (Learn how to use the vSphere console)
  • Understand the Kernel/Process Abstraction
  • Gain a working knowledge of Mode/Context switches
  • Announcements:
  • C4 weekly summaries! Due Jan 25. Week 3 is out.
  • HW0 is available on Compass! Due Jan 25
  • MP0 is available on Compass! Due Jan 28
  • TA Office Hours change:
  • 0207 @ ????

Goals for Today

Reminder: Please put away devices at the start of class

slide-3
SLIDE 3

CS 423: Operating Systems Design

Piazza Questions

3

Responsible for textbook? I thwarted your C3 restriction… we cool?

slide-4
SLIDE 4

CS423: Operating Systems Design

Overview

4

Process concept

  • A process is the OS abstraction for executing a

program with limited privileges Dual-mode operation: user vs. kernel

  • Kernel-mode: execute with complete privileges
  • User-mode: execute with fewer privileges

Safe control transfer

  • How do we switch from one mode to the other?
slide-5
SLIDE 5

CS423: Operating Systems Design

Process Abstraction

5

Process: an instance of a program that runs with limited rights on the machine

  • Thread: a sequence of instructions within a process
  • Potentially many threads per process (for now,

assume 1:1)

  • Address space: set of rights of a process
  • Memory that the process can access
  • Other permissions the process has (e.g., which

system calls it can make, what files it can access)

slide-6
SLIDE 6

CS 423: Operating Systems Design

Thought Experiment

6

How can we permit a process to execute with

  • nly limited privileges?
slide-7
SLIDE 7

CS423: Operating Systems Design

Thought Experiment

7

How can we implement execution with limited privilege?

  • Execute each program instruction in a simulator
  • If the instruction is permitted, do the instruction
  • Otherwise, stop the process
  • Basic model in Javascript and other interpreted

languages

slide-8
SLIDE 8

CS423: Operating Systems Design

Thought Experiment

8

How can we implement execution with limited privilege?

  • Execute each program instruction in a simulator
  • If the instruction is permitted, do the instruction
  • Otherwise, stop the process
  • Basic model in Javascript and other interpreted

languages Ok… but how do we go faster?

slide-9
SLIDE 9

CS423: Operating Systems Design

Thought Experiment

9

How can we implement execution with limited privilege?

  • Execute each program instruction in a simulator
  • If the instruction is permitted, do the instruction
  • Otherwise, stop the process
  • Basic model in Javascript and other interpreted

languages Ok… but how do we go faster?

  • Run the unprivileged code directly on the CPU!
slide-10
SLIDE 10

CS423: Operating Systems Design

A Model of a CPU

10

New PC

Program Counter CPU Instructions Fetch and Execute

  • pcode

Select PC

Branch Address

slide-11
SLIDE 11

CS423: Operating Systems Design

New PC Handler PC

Program Counter CPU Instructions Fetch and Execute

  • pcode

Select PC

New Mode

Mode Select Mode

Branch Address

A CPU with Dual-Mode Operation

11

slide-12
SLIDE 12

CS423: Operating Systems Design

HW Support for Dual-Mode

12

Privileged instructions

  • Available to kernel
  • Not available to user code

Limits on memory accesses

  • To prevent user code from overwriting the kernel

Timer

  • To regain control from a user program in a loop

Safe way to switch from user mode to kernel mode, and vice versa

slide-13
SLIDE 13

CS423: Operating Systems Design

Privileged Instructions

13

Examples? What should happen if a user program attempts to execute a privileged instruction?

slide-14
SLIDE 14

CS423: Operating Systems Design

User->Kernel Switches

14

How/when do we switch from user to kernel mode?

  • 1. Interrupts
  • Triggered by timer and I/O devices
  • 2. Exceptions
  • Triggered by unexpected program behavior
  • Or malicious behavior!
  • 3. System calls (aka protected procedure call)
  • Request by program for kernel to do some
  • peration on its behalf
  • Only limited # of very carefully coded entry points
slide-15
SLIDE 15

CS 423: Operating Systems Design

Question

15

How does the OS know when a process is in an infinite loop?

slide-16
SLIDE 16

CS423: Operating Systems Design

Hardware Timer

16

Hardware device that periodically interrupts the processor

  • Returns control to the kernel handler
  • Interrupt frequency set by the kernel

Not by user code!

  • Interrupts can be temporarily deferred

Not by user code! Interrupt deferral crucial for implementing mutual exclusion

slide-17
SLIDE 17

CS423: Operating Systems Design

Kernel->User Switches

17

How/when do we switch from kernel to user mode?

  • 1. New process/new thread start
  • Jump to first instruction in program/thread
  • 2. Return from interrupt, exception, system call
  • Resume suspended execution (return to PC)
  • 3. Process/thread context switch
  • Resume some other process (return to PC)
  • 4. User-level upcall (UNIX signal)
  • Asynchronous notification to user program
slide-18
SLIDE 18

CS 423: Operating Systems Design

CPU State

18

What is the CPU’s behavior defined by at any given moment?

slide-19
SLIDE 19

CS 423: Operating Systems Design 19

Program Counter Code Segment Offset Program instructions

What is the CPU’s behavior defined by at any given moment?

CPU State

slide-20
SLIDE 20

CS 423: Operating Systems Design 20

Program Counter Code Segment Offset Data Segment Offset

Operand

Data Operand Current Instruction

OpCode

Program instructions Heap

What is the CPU’s behavior defined by at any given moment?

CPU State

slide-21
SLIDE 21

CS 423: Operating Systems Design 21

Program Counter Code Segment Offset Data Segment Offset

Operand

Data Operand Current Instruction

OpCode

Stack Segment Offset Stack Pointer Program instructions Heap Stack

What is the CPU’s behavior defined by at any given moment?

CPU State

slide-22
SLIDE 22

CS 423: Operating Systems Design 22

Program Counter Code Segment Offset Data Segment Offset

Operand

Data Operand Current Instruction

OpCode

Stack Segment Offset Stack Pointer Registers Program instructions Heap Stack

What is the CPU’s behavior defined by at any given moment?

CPU State

slide-23
SLIDE 23

CS 423: Operating Systems Design 23

Program Counter Code Segment Offset Data Segment Offset

Operand

Data Operand Current Instruction

OpCode

Stack Segment Offset Stack Pointer Registers

What defines the STATE of the CPU?

Program instructions Heap Stack

CPU State

slide-24
SLIDE 24

CS 423: Operating Systems Design

What’s a ‘real’ CPU?

24

Program Counter Program instructions Code Segment Offset Heap Data Segment Offset

Operand

Data Operand Current Instruction

OpCode

Stack Segment Offset Stack Pointer Stack Registers

What’s the STATE of a real CPU?

slide-25
SLIDE 25

CS 423: Operating Systems Design

The Context Switch

25

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Registers

slide-26
SLIDE 26

CS 423: Operating Systems Design

Process Control Block

26

The state for processes that are not running on the CPU are maintained in the Process Control Block (PCB) data structure

Updated during context switch

An alternate PCB diagram

slide-27
SLIDE 27

CS 423: Operating Systems Design

The Context Switch

27

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Registers

slide-28
SLIDE 28

CS 423: Operating Systems Design

The Context Switch

28

Note: In thread context switches, heap is not switched!

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset

Operand OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Registers Registers

slide-29
SLIDE 29

CS 423: Operating Systems Design

The Context Switch

29

Note: In thread context switches, heap is not switched!

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset

Operand OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Global Variables Local Variables

Registers Registers

slide-30
SLIDE 30

CS 423: Operating Systems Design

Thread Context Switch

30

Note: In thread context switches, heap is not switched!

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset

Operand OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Global Variables Local Variables

So who does the context switch, and when???

Registers Registers

slide-31
SLIDE 31

CS 423: Operating Systems Design

Thread Context Switch

31

Note: In thread context switches, heap is not switched!

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset

Operand OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Global Variables Local Variables

Solution 1: An Interrupt

Registers Registers

slide-32
SLIDE 32

CS 423: Operating Systems Design

CTX Switch: Interrupt

32

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Running Thread

Registers Registers

slide-33
SLIDE 33

CS 423: Operating Systems Design

CTX Switch: Interrupt

33

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Save PC on thread stack Jump to Interrupt handler

Interrupt

Registers Registers

slide-34
SLIDE 34

CS 423: Operating Systems Design

CTX Switch: Interrupt

34

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to Interrupt handler Handler

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

Thread Control Block

slide-35
SLIDE 35

CS 423: Operating Systems Design

CTX Switch: Interrupt

35

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Save PC on thread stack Jump to Interrupt handler Handler

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block

Thread Control Block Thread Control Block

Registers Registers

slide-36
SLIDE 36

CS 423: Operating Systems Design

CTX Switch: Interrupt

36

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Save PC on thread stack Jump to Interrupt handler Handler

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block
  • Pop PC from thread stack (return from handler)

Thread Control Block Thread Control Block

Registers Registers

slide-37
SLIDE 37

CS 423: Operating Systems Design

CTX Switch: Interrupt

37

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Save PC on thread stack Jump to Interrupt handler Handler

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block
  • Pop PC from thread stack (return from handler)

Thread Control Block Thread Control Block

Where does it return?

Registers Registers

slide-38
SLIDE 38

CS 423: Operating Systems Design

CTX Switch: Interrupt

38

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Stack

Save PC on thread stack Jump to Interrupt handler Handler

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block
  • Pop PC from thread stack (return from handler)

Thread Control Block Thread Control Block

Where does it return?

Registers Registers

slide-39
SLIDE 39

CS 423: Operating Systems Design

CTX Switch: Interrupt

39

What are some examples of context switches due to interrupts?

  • Clock Interrupt: Task exceeds its time slice
  • I/O Interrupt: Waiting processes may be preempted
  • Memory Fault: CPU attempts to access a virtual

memory address that is not in main memory. OS may resume execution of another process while retrieving the block, then moves process to ready state.

slide-40
SLIDE 40

CS 423: Operating Systems Design

Thread Context Switch

40

Note: In thread context switches, heap is not switched!

Program Counter Program instructions Code Segment Offset Heap Data Segment

Operand

Data Operand

OpCode

Stack Segment Stack Pointer Stack Program Counter Program instructions Code Segment Offset

Operand OpCode

Stack Segment Stack Pointer Stack

Save State (Context) Load State (Context)

Global Variables Local Variables

Registers Registers

Solution 2: Voluntary yield()

slide-41
SLIDE 41

CS 423: Operating Systems Design

CTX Switch: Yield

41

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Running Thread

slide-42
SLIDE 42

CS 423: Operating Systems Design

CTX Switch: Yield

42

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function

yield()

slide-43
SLIDE 43

CS 423: Operating Systems Design

CTX Switch: Yield

43

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

Thread Control Block

slide-44
SLIDE 44

CS 423: Operating Systems Design

CTX Switch: Yield

44

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread

Thread Control Block

slide-45
SLIDE 45

CS 423: Operating Systems Design

CTX Switch: Yield

45

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block

Thread Control Block Thread Control Block

slide-46
SLIDE 46

CS 423: Operating Systems Design 46

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Save thread state in thread control block

(SP, registers, segment pointers, …)

  • Choose next thread
  • Load thread state from control block
  • Pop PC from thread stack (return from handler)

Thread Control Block Thread Control Block

CTX Switch: Yield

slide-47
SLIDE 47

CS 423: Operating Systems Design 47

CTX Switch: Yield

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Choose next thread
  • swapcontext()

Thread Control Block Thread Control Block

slide-48
SLIDE 48

CS 423: Operating Systems Design 48

Scheduler

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • Choose next thread
  • swapcontext()

Thread Control Block Thread Control Block

Where is the Scheduling Policy?

slide-49
SLIDE 49

CS 423: Operating Systems Design 49

Scheduler

Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack Program Counter Program instructions Code Segment Offset Stack Segment Stack Pointer Registers Stack

Save PC on thread stack Jump to yield() function yield()

  • NextThreadID = scheduler()
  • swapcontext()

Thread Control Block Thread Control Block

Where is the Scheduling Policy?

Maintains a sorted queue of ready threads