Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 03 Annotated
03 - OS Concepts and Structure
Outline
Concept Overview
Processes
Address Space
Files
Announcements
Reading: MOS 1.5, 1.7
Concept Overview
Most systems have 2 execution modes:
- user mode (non-privileged)
- kernel mode (privileged)
User mode execution restricts allowed actions and
instructions.
For example, in ARM:
- Move to/from system register
- Read/Write protected memory
- Enabling/Disabling interrupts
Can only be done in privileged mode.
User applications and general libs run in user-mode.
Libraries (e.g. libc) can provide a common user-mode
interface for system calls.
The OS manages processes.
An address space is a range of valid memory
addresses for a given process.
Address space contains:
- Readable and writeable by the process
- Text: program code
- Data: initialized global vars
- BSS: uninitialized global vars
- Heap: dynamically allocated vars
- Stack: local vars
A process is a program in execution.
Each process has associated with it:
The OS represents a process as a struct
containing the associated state information, which
is stored in an array called the process table.
- an address space
- current registers
- resources:
- open files
- outstanding alarms/timers
- related processes
- etc.
A program is a sequence of instructions
(e.g. executable files ELF, EXE)
(see )
man -s 2 syscalls
- File system service
- Process management service
User-mode code must make a system call (syscall)
to the kernel to access devices on its behalf.
System calls can be grouped together to provide
services. For example:
Processes
Address Space
Files
System Calls
Kernel
Make sure to join the Discord!
PA 1 is due Friday.
Start today if you haven't started yet!
1)
2)
3)
4)
5)
6)
Applications & System Software
Non-privileged
Instructions
Privileged
Instructions
I/O Devices
Libraries
OS Kernel
User
Library calls
System calls
Machine inst.
software
hardware
stack
heap
bss
data
text
Program Memory
0xFFFFFFFF
0x00000000
Each process has its own address
space, controlled by the OS.
The file system is an OS abstraction for
interacting with storage devices.
UNIX example:
File paths:
Storage devices can be mounted in the file system
From PA 1: /dev/sda0 -> /
From PA 1: /mnt/shared -> /home/rtsang1/shared
Special Files and Pseudofiles
Pipes
Input/Output
System Calls
Example: "Hello World"
In UNIX, "everything is a file".
A pipe is a pseudofile for allowing multiple
processes to communicate via FIFO channel
managed by the kernel.
All computers have physical devices for receiving
input and generating output.
Kernel manages I/O devices with I/O subsystem
Kernel requires device drivers to support hardware
User-mode applications use system calls (syscalls)
to issue service requests.
Syscall mechanism is OS and hardware specific.
- Less portable across platforms
Syscalls are wrapped in system and standard
libraries (e.g. libc) to mitigate this.
- Usually 1 function per syscall
- libc based on C POSIX standard
- libc different implementation per platform
Portable, since all functions are from C stdlib.
printf internals are different based on OS.
3 ways of writing "Hello World" of increasing
platform dependence.
printf(char *str, ...);
write(int fd, char *buf, size_t len);
write is an OS-specific POSIX-compliant library
function, not the actual syscall.
It makes a CPU-dependent syscall.
Syscall interface is completely platform
dependent.
It is necessary for certain actions, like creating
a new process or interfacing with hardware.
The kernel is the portion of the OS that
executes in privileged mode.
It manages everything that requires privileged-
mode operations (processes, interrupts, scheduling,
I/O, etc.) and possibly more.
3 types of kernel architecture:
In a monolithic kernel, the entire OS executes in
privileged mode as one giant executable.
Examples:
- Most UNIX variants
- Linux
- Most BSD variants
In a microkernel, the minimum necessary functions
are included in the kernel, all other functionality
provided as user-mode modules.
A hybrid kernel is a mixed approach.
Only moves modules out of kernel if doing so does not
negatively affect performance.
Improves reliability while prioritizing performance.
- Kernel functions can call every other function
- Performant
- A single bug will crash the entire kernel
- Very complex
- Modules cannot interfere with one another
- More resilience against module bugs
- More communication overhead between modules
- Monolithic kernel
- Microkernel
- Hybrid kernel
A device driver implements initialization and
communication logic for a specific device.
The I/O subsystem provides a uniform file-like
API for accessing I/O devices.
(e.g. keyboard, monitor, mouse, printer, etc.)
- Must be created in advance
- Processes see it as just another file
Example:
Example:
This shows output lines of `ls -l` only
if the line contains "D".
`|` pipes stdout of first process to
stdin of next process.
Special files make I/O devices look like files:
(macOS example)
Symbolic Links point to and act like other files.
Named/Anonymous FIFOs (sockets/pipes) are
used for inter-process communication.
Block special files model devices with
randomly addressable blocks (e.g. disks)
Character special files model devices that
use character streams (e.g. serial ports)
/home/rtsang1/.bashrc
../.bashrc
Absolute ( / ):
Relative (Documents):
(Every process has a current working directory)
/
|-- home
| `-- rtsang1
| |-- .bash_history
| |-- .bashrc
| |-- Documents
| |-- Downloads
| |-- .local
| `-- .profile
`-- tmp
`-- dir
`-- test
A file is essentially a byte array.
The OS provides syscalls to interact with files.
(e.g. open, close, read, write files)
Hierarchical file systems have directories.
A directory is a special file that lists other files.
The OS also provides syscalls for these.
/
tmp
home
rtsang1
.local
Documents
dir
Downloads
.bashrc
test
brw-r----- 1 root operator 1, 0 Jan 5 23:20 /dev/disk0
crw-rw-rw- 1 root wheel 4, 48 Jan 5 23:20 /dev/ttys0
printf(char *str, ...);
write(int fd, char *buf, size_t len);
syscall(int number, ...);
Kernels
Monolithic Kernel
Microkernel
Hybrid Kernel
shell
shell
fs
fs
disk
disk
proc
proc
ipc
ipc
tty
tty
net
net
clock
clock
sys
sys
make
make
other
other
user
mode
kernel
mode
kernel
mode
processes
user
programs
servers
drivers
interrupts, drivers,
scheduling, etc.
interrupts, drivers,
scheduling, etc.
user
mode
Examples:
- Mach
- MINIX
- L4
Examples:
- Windows
- XNU (Darwin)
- DragonFly BSD
ls -l | grep -e "D"