Professional Documents
Culture Documents
Ch.1 - Introduction
An OS is a program that acts as an intermediary between a user of a computer and the computer hardware Goals: Execute user programs, make the comp. system easy to use, utilize hardware efficiently Computer system: Hardware OS Applications Users ( = 'uses') OS is: Resource allocator: decides between conflicting requests for efficient and fair resource use Control program: controls execution of programs to prevent errors and improper use of computer Kernel: the one program running at all times on the computer Bootstrap program: loaded at power-up or reboot Stored in ROM or EPROM (known as firmware), Initializes all aspects of system, loads OS kernel and starts execution I/O and CPU can execute concurrently Device controllers inform CPU that it is finished w/ operation by causing an interrupt Interrupt transfers control to the interrupt service routine generally, through the interrupt vector, which contains the addresses of all the service routines Incoming interrupts are disabled while another interrupt is being processed Trap is a software generated interrupt caused by error or user request OS determines which type of interrupt has occurred by polling or the vectored interrupt system System call: request to the operating system to allow user to wait for I/O completion Device-status table: contains entry for each I/O device indicating its type, address, and state OS indexes into the I/O device table to determine device status and to modify the table entry to include interrupt Storage structure: Main memory random access, volatile Secondary storage extension of main memory That provides large non-volatile storage Disk divided into tracks which are subdivided into sectors. Disk controller determines logical interaction between the device and the computer. Caching copying information into faster storage system Multiprocessor Systems: Increased throughput, economy of scale, increased reliability Can be asymmetric or symmetric Clustered systems Linked multiprocessor systems Multiprogramming Provides efficiency via job scheduling When OS has to wait (ex: for I/O), switches to another job Timesharing CPU switches jobs so frequently that each user can interact with each job while it is running (interactive computing) Dual-mode operation allows OS to protect itself and other system components User mode and kernel mode Some instructions are only executable in kernel mode, these are privileged Single-threaded processes have one program counter, multi-threaded processes have one PC per thread Protection mechanism for controlling access of processes or users to resources defined by the OS Security defense of a system against attacks User IDs (UID), one per user, and Group IDs, determine which users and groups of users have which privileges
Ch.2 OS Structures
User Interface (UI) Can be Command-Line (CLI) or Graphics User Interface (GUI) or Batch These allow for the user to interact with the system services via system calls (typically written in C/C++) Other system services that a helpful to the user include: program execution, I/O operations, file-system manipulation, communications, and error detection Services that exist to ensure efficient OS operation are: resource allocation, accounting, protection and security Most system calls are accessed by Application Program Interface (API) such as Win32, POSIX, Java Usually there is a number associated with each system call System call interface maintains a table indexed according to these numbers Parameters may need to be passed to the OS during a system call, may be done by: Passing in registers, address of parameter stored in a block, pushed onto the stack by the program and popped off by the OS Block and stack methods do not limit the number or length of parameters being passed Process control system calls include: end, abort, load, execute, create/terminate process, wait, allocate/free memory File management system calls include: create/delete file, open/close file, read, write, get/set attributes Device management system calls: request/release device, read, write, logically attach/detach devices Information maintenance system calls: get/set time, get/set system data, get/set process/file/device attributes Communications system calls: create/delete communication connection, send/receive, transfer status information OS Layered approach: The operating system is divided into a number of layers (levels), each built on top of lower layers. The bottom layer (layer 0), is the hardware; the highest (layer N) is the user interface With modularity, layers are selected such that each uses functions (operations) and services of only lowerlevel layers Virtual machine: uses layered approach, treats hardware and the OS kernel as though they were all hardware. Host creates the illusion that a process has its own processor and own virtual memory Each guest provided with a 'virtual' copy of the underlying computer Application failures can generate core dump file capturing memory of the process Operating system failure can generate crash dump file containing kernel memory
Ch.3 Processes
Process contains a program counter, stack, and data section. Text section: program code itself Stack: temporary data (function parameters, return addresses, local variables) Data section: global variables Heap: contains memory dynamically allocated during run-time Process Control Block (PCB): contains information associated with each process: process state, PC, CPU registers, scheduling information, accounting information, I/O status information Types of processes: I/O Bound: spends more time doing I/O than computations, many short CPU bursts CPU Bound: spends more time doing computations, few very long CPU bursts When CPU switches to another process, the system must save the state of the old process (to PCB) and load the saved state (from PCB) for the new process via a context switch Time of a context switch is dependent on hardware Parent processes create children processes (form a tree) PID allows for process management Parents and children can share all/some/none resources Parents can execute concurrently with children or wait until children terminate fork() system call creates new process exec() system call used after a fork to replace the processes' memory space with a new program Cooperating processes need interprocess communication (IPC): shared memory or message passing Message passing may be blocking or non-blocking Blocking is considered synchronous Blocking send has the sender block until the message is received Blocking receive has the receiver block until a message is available Non-blocking is considered asynchronous Non-blocking send has the sender send the message and continue Non-blocking receive has the receiver receive a valid message or null
Ch.4 Threads
Threads are fundamental unit of CPU utilization that forms the basis of multi-threaded computer systems Process creation is heavy-weight while thread creation is light-weight Can simplify code and increase efficiency Kernels are generally multi-threaded Multi-threading models include: Many-to-One, One-to-One, Many-to-Many Many-to-One: Many user-level threads mapped to single kernel thread One-to-One: Each user-level thread maps to kernel thread Many-to-Many: Many user-level threads mapped to many kernel threads Thread library provides programmer with API for creating and managing threads Issues include: thread cancellation, signal handling (synchronous/asynchronous), handling thread-specific data, and scheduler activations. Cancellation: Asynchronous cancellation terminates the target thread immediately Deferred cancellation allows the target thread to periodically check if it should be canceled Signal handler processes signals generated by a particular event, delivered to a process, handled Scheduler activations provide upcalls a communication mechanism from the kernel to the thread library. Allows application to maintain the correct number of kernel threads
Modern machines provide atomic hardware instructions: Atomic = non-interruptable Solution using Locks:
do { acquire lock critical section release lock remainder section } while (TRUE);
Solution using Swap: Shared bool variable lock initialized to FALSE; Each process has local bool variable key
void Swap (boolean *a, boolean *b){ boolean temp = *a; *a = *b; *b = temp: } do { key = TRUE; while ( key == TRUE) Swap (&lock, &key ); // critical section lock = FALSE; // remainder section } while (TRUE);
Semaphore: Synchronization tool that does not require busy waiting Standard operations: wait() and signal() these are the only operations that can access semaphore S Can have counting (unrestricted range) and binary (0 or 1) semaphores Deadlock: Two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes (most OSes do not prevent or deal with deadlocks) Can cause starvation and priority inversion (lower priority process holds lock needed by higher-priority process)
Ch.7 Deadlocks
Deadlock Characteristics: deadlock can occur if these conditions hold simultaneously Mutual Exclusion: only one process at a time can use a resource Hold and Wait: process holding one resource is waiting to acquire resource held by another process No Preemption: a resource can be released only be the process holding it after the process completed its task Circular Wait: set of waiting processes such that Pn-1 is waiting for resource from Pn, and Pn is waiting for P0 Dining Philosophers in deadlock
Effective Access Time: EAT = (1 + ) + (2 + )(1 ) = time unit, = hit ratio Valid and invalid bits can be used to protect memory Valid if the associated page is in the process' logical address space, so it is a legal page Can have multilevel page tables (paged page tables) Hashed Page Tables: virtual page number hashed into page table Page table has chain of elements hashing to the same location Each element has (1) virtual page number, (2) value of mapped page frame, (3) a pointer to the next element Search through the chain for virtual page number Segment table maps two-dimensional physical addresses Entries protected with valid bits and r/w/x privileges
Segmentation example
Second chance algorithm uses a reference bit If 1, decrement and leave in memory If 0, replace next page Fixed page allocation: Proportional allocation Allocate according to size of process si = size of process Pi, S = si, m = total number of frames, ai allocation for Pi ai = (si/S)*m Global replacement: process selects a replacement frame from set of all frames One process can take frame from another Process execution time can vary greatly Greater throughput Local replacement: each process selects from only its own set of allocated frames More consistent performance Possible under-utilization of memory Page-fault rate is very high if a process does not have enough pages Thrashing: a process is busy swapping pages in and out minimal work is actually being performed Memory-mapped file I/O allows file I/O to be treated as routine memory access by mapping a disk block to a page in memory I/O Interlock: Pages must sometimes be locked into memory
SCAN
Ch.14 Protection
Principle of least privilege: programs, users, systems should be given just enough privileges to perform their tasks Access-right = <obj-name, rights-set> w/ rights-set is subset of all valid operations performable on the object Domain: set of access-rights UNIX system consists of 2 domains: user, supervisor MULTICS domain implementation (domain rings) if j<i Di Dj Access matrix: rows represent domains, columns represent objects Access(i,j) is the set of operations that a process executing in Domaini can invoke on Objectj Can be expanded to dynamic protection Access matrix design separates mechanism from policy Mechanism: OS provides access-matrix and rules ensures matrix is only manipulated by authorized users Policy: User dictates policy who can access what object and in what mode Solaris 10 uses role-based access control (RBAC) to implement least privilege Revocation of access rights Access list: delete access rights from access list simple, immediate Capability list: required to locate capability in system before capability can be revoked reacquisition, backpointers, indirection, keys Language-Based Protection: allows high-level description of policies for the allocation and use of resources Can provide software for protection enforcement when hardware-supported checking is unavailable
Ch.15 Security
System secure when resources used and accessed as intended under all circumstances Attacks can be accidental or malicious Easier to protect against accidental than malicious misuse Security violation categories: Breach of confidentiality unauthorized reading of data Breach of integrity unauthorized modification of data Breach of availability unauthorized destruction of data Theft of service unauthorized use of resources Denial of service prevention of legitimate use Methods of violation: Masquerading pretending to be an authorized user Man-in-the-middle attack - Asymmetric Man-in-the-middle intruder sits in data flow, masquerading as sender to Cryptography receiver and vice versa Session hijacking intercept and already established session to bypass authentication Effective security must occur at four levels: physical, human, operating system, network Program threats: trojan horse (spyware, pop-up, etc.), trap door, logic bomb, stack and buffer overflow Viruses: code fragment embedded in legitimate program; self-replicating Specific to CPU architecture, OS, applications Virus dropper: inserts virus onto the system Windows is the target for most attacks most common, everyone is administrator Worms: use spawn mechanism standalone program Port scanning: automated attempt to connect to a range of ports on one or a range of IP addresses Frequently launched from zombie systems to decrease traceability Denial of service: overload targeted computer preventing it from doing useful work Cryptography: means to constrain potential senders and/or receivers based on keys Allows for confirmation of source, receipt by specified destination, trust relationship Encryption: [K of keys], [M of messages], [C of ciphertexts], function E:K to encrypt, function D:K to decrypt Can have symmetric and asymmetric (distributes public encryption key, holds private decipher key) encryption Asymmetric is much more compute intensive not used for bulk data transaction Keys can be stored on a key ring