Kernel Design & Implementation

The Problems Kernel code is notoriously complex: Concurrency control Device drivers Interrupts Low-level hardware details Functionality is every increasing Debugging is slow Must reboot after every change

Yet More Problems How to develop a new operating system? How to maintain an operating system Fixing bugs Improving technology Adding new features Maintaining backward compatibility Operation across different hardware platforms

Kernel Types Simple monitor/library: e.g. DOS Monolithic piece of software: e.g. UNIX Micro-kernels: e.g. Mach Virtual Machines (VM): e.g. IBM CMS/VM Layered OS: e.g. Windows NT Extensible kernels: SPIN

Simple Monitor/Library Applications + OS co-exist in supervisor mode Share the same memory space Applications have direct access to devices Operating system has limited functionality No meaningful user accounting or security Operating system relies on application to solve problems: e.g. overlaying, EMS

Example: DOS DOS * No virtual memory * No protection I/O * One application at a time * Direct I/O I/O Frame buffer Application DOS interrupt vector Hardware vector (to the BIOS)

Simple Monitor/Library in Balance Advantages: Performance No context switching Direct I/O access No VM overhead Flexibility Applications can change OS behavior Disadvantages No safety or security No VM No multiprogramming OS cannot protect or manage I/O effectively

TSR Terminate-and-Stay-Resident: On a timer interrupt: Application overwrites OS vector for timer interrupt Timer interrupts invoke an application routine Application “exits” (not really) On a timer interrupt: TSR application is invoked TSR application runs TSR application calls OS timer interrupt routine TSR application returns to the “current application”

TSR cont’d More TSR applications could be added New TSR overwrites old TSR timer interrupt entry On a timer interrupt: Newest TSR is invoked, runs, then passes control to the next TSR application… All the way to oldest TSR application which finally invokes the OS TSR programs are thus chained through the interrupt vector

Expanded Memory System (EMS) To overcome limits of 1M addressing without having to do overlaying Uses special hardware to allow remap a memory address range (16K) to a different range of physical pages Programmer tells system which physical range to remap Mimicks virtual memory, but all are physical addresses!!!

EMS Additional physical memory Addressable memory (1M) Unit of remapping in EMS is 4 pages (16K) Up to 64K units of 16Kbytes each No virtual addressing, EMS != virtual memory

Monolothic Kernels Kernel is one big piece of software Runs in supervisor mode while applications run in user mode Mostly modular design, but interfaces may not be well defined

Example: UNIX Kernel consists of major modules naming basic file system process implementation and scheduling memory and paging network protocol support There is no clear layering or separation of functions: Modules can call each other in different ways

UNIX File system Process Memory Network Devices

Micro-Kernels To control the complexity of the OS A small kernel that does: Fast interprocess communications/RPC Device control Basic process implementation (e.g. context switching) Basic memory management implementation (e.g. mapping memory pages, handling TLB/page tables) Interrupt processing support OS is implemented by user-level processes

Micro-Kernels Applications Process Scheduler Memory Mgr. Network Protocol File System Micro-Kernel

Implementing Fork Parent process sends an RPC to the process manager (through the micro-kernel) Process manager sends an RPC to the memory manager (through the micro-kernel) Memory manager allocates memory, calls micro-kernel to map the pages/and/or do copy-on-write Memory manager replies to process manager, which creates process Process manager replies to parent process

Sending a Network Message Application program sends an RPC containing the message to the network manager Network manager forms the necessary packets (e.g. TCP/IP), opens the network device (through micro-kernel), and sends packets through device Network manager replies to application program (or perhaps it replies immediately in case if it is a non-blocking operation)

Observations In a monolithic kernel, process module would call memory module, etc. Therefore: A micro-kernel replaces inter-module procedure calls with remote procedure calls No shared memory between OS processes Extra data copying

Micro-Kernels in Balance Advantages Development and maintenance of OS processes are easier Change one OS process without changing the rest Easy to add more functionality (e.g. DOS personality) Disadvantages Performance Cost of RPC becomes very important

Compatibility with Legacy Code Applications Process Scheduler Memory Mgr. Network Protocol File System UNIX Server 3. reply 1. Trap 2. Message 4. return Micro-Kernel