Operating Systems Concepts

Resource Management & Abstraction

• The OS manages hardware resources, including the CPU, RAM, and storage
• Abstraction simplifies hardware complexities, aiding program interaction with resources without detailed knowledge

Benefits of Abstraction

• Programs become portable, running on different hardware platforms without changes
• Security is enhanced as abstraction restricts direct hardware access, thus mitigating risks
• Resource allocation is optimized dynamically by the OS, improving efficiency

Preemptive Multitasking

• The OS can interrupt a process, switching to another to ensure fair CPU usage
• Multi-user environments are enabled, preventing a single program from monopolizing resources

Monolithic Kernel

• Everything, including device drivers, memory management, and file systems, operates in kernel mode (Ring 0)
• Faster execution and fewer context switches can occur
• Less modular architecture means a single failure can crash the entire system

Microkernel

• Only essential functions like IPC, scheduling, and memory operate in kernel mode
• Other services, such as device drivers and file systems, run in user space
• More modular and secure design means failures are less likely to crash the entire system
• Slower than monolithic kernels due to more IPC overhead

FUSE/udev/sshfs

• These exemplify moving services to user space, similar to microkernel designs
• FUSE (Filesystem in Userspace) enables users to create custom file systems without kernel modifications
• udev manages device nodes dynamically in user space
• sshfs facilitates remote file system mounting over SSH without kernel modifications

Command-Line, Text UI, GUI

• Different ways for users to interact with the OS exist
• Command-line interfaces are powerful and scriptable, but have a learning curve
• Text UIs are menu-based, such as ncurses programs like htop
• GUIs are graphical desktops that are user-friendly but require more resources

Kernel Mode (Ring 0) vs. User Mode

• Kernel Mode (Ring 0) has full access to the hardware
• Critical OS functions like memory management and device drivers run in Kernel mode
• User Mode access is restricted and can only use system calls to interact with hardware
• User Mode protects system stability by preventing direct hardware access
• CPUs enforce separation using privilege levels

Processes and PIDs

• A process is a running instance of a program
• A PID (Process ID) is a unique identifier assigned by the OS
• Program binaries such as /bin/ls are just files
• When a program binary is executed, it becomes a process with its own PID, memory, and state

Process Lifecycle and Symbols

• Process states include New, Ready, Running, Waiting (I/O), and Terminated
• Symbols represent different states in tools like ps (e.g., R for running, S for sleeping)

Address Space Layout

• Each process has a virtual address space
• The code segment stores executable instructions
• The data segment stores global/static variables
• The heap is used for dynamic memory (e.g., malloc in C)
• The stack is used for function calls and local variables
• Argv/env is used to store command-line arguments and environment variables

Users and UIDs

• Every user has a UID (User ID)
• Root (UID = 0) has full control over the system
• A UID is a software label, not hardware-enforced, but controlled by the OS

Files and File Systems

• A file is the basic unit of data storage
• A file system is a structure that organizes files
• File systems provide abstraction for storage devices such as HDDs, SSDs, and USB drives

Library Calls vs. System Calls

• Library calls (lib calls) are functions provided by libraries (e.g., printf(), malloc())
• System calls (sys calls) are direct OS requests (e.g., open(), read(), write())
• Lib calls run in user space.
• Sys calls require a switch to kernel space.

Abstraction and Portability

• Higher-level abstractions make software more portable across different OS/hardware
• Code written in C is more portable than assembly code because C offers higher abstraction

Environment Variables

• Environment variables are key-value pairs stored in the shell/process environment
• Environment variables are used for configuration
• Variables can be global, available to all child processes or local, only for the current shell

Internal vs. External Commands

• Internal (built-in) commands are executed directly by the shell
• External commands are separate binaries stored in system directories
• Internal commands are generally faster

Execution Types

• Direct execution runs code directly on the CPU
• Indirect execution requires an interpreter
• Limited direct execution allows user programs to run but enforces control using interrupts

Execution Context and Context Switching

• The execution context is the state of a process
• A context switch occurs when the CPU switches from one prcoess to another
• Context switching involves saving and restoring registers so it's expensive

Scheduling and Principles

• The OS determines which process/thread gets CPU time based on scheduling policies
• Common scheduling strategies include FIFO, Round Robin, Priority Scheduling and Multilevel Queue

fork() and exec()

• fork() creates a new process by duplicating the parent
• exec() replaces the process memory with a new program
• Using separate calls provides flexibility, allows child processes to modify their state, and enables parallel execution

Threads vs. Processes

• Processes have separate memory spaces
• Threads within a process share memory (stack, heap)
• Faster context switching is a benefit of threads
• Threads can lead to easier communication, but also risk race conditions

pthreads vs. clone()

• pthreads is a high-level API for threading that works across different OS implementations
• clone() is a low-level system call that creates a process or thread, offering more control but is harder to use

Paging and Swapping

• Paging divides memory into fixed-size pages
• Virtual memory is mapped to physical memory using a page table.
• Swapping moves entire processes from RAM to disk when memory is full

Role of the Kernel in Abstraction

• Provides a simplified interface for hardware (CPU, memory, I/O)
• Manages execution, handles memory, and controls access

Memory Allocation and Symbols

• Memory allocation can be static (compile time), stack (runtime), or heap (runtime)
• Symbols represent functions, variables, etc. in compiled programs
• Some symbols exist only at compile-time, others at runtime.

Libcall vs. Syscall

• Lib calls call functions from libraries and run in user mode.
• Syscalls directly request OS services, triggering a context switch into kernel mode.

Consequences

• Lib calls are faster but syscalls have more overhead but direct hardware access.

Compile-time Libraries

• Loaded and linked at compile time

Load-time Libraries

• Dynamically linked to shared libraries at load time.

Library Usage

• Syscall transitions occur at runtime during actual execution, and transition to kernel mode.

Steps for Talking to a Computer

• Terminal /sbin/getty starts when a terminal is opened and waits for a login
• Login /usr/bin/login handles user authentication
• /etc/passwd and /etc/shadow are read for credentials After Login
• Shell /bin/bash will start
• The custom shell, like 3000shell, interprest the user commands.

User Account Info

/etc/passwd

• Stores usernames, UIDs, GIDs, home directories, and shell paths. /etc/shadow
• Stores hashed passwords for security.

UID, EUID, GID, EGID, setuid

• Identifies users UID (User ID):
• Identifies a user. EUID (Effective UID):
• Determines actual privileges.

If a program has setuid enabled:

• It can run with elevated privileges (e.g., sudo). GID (Group ID), EGID (Effective GID):
• Same as UID, but for groups.

File Permision bits & Notation Conversion

Octal Notation

• rwxr-xr--→ 754 Owner = rwx=7, Group = r-x=5, Others= r--=4. Symbolic notation
• chmod u+x file → Adds execute permission to the user

Special Bits

• setuid (chmod u+s) Runs as the files owner
• setgid (chmod g+s) Runs with the group's permissions.
• Sticky_bit (chmod +t)Only the owner can delete files in directory.

Workflow of a shell

• Reads input (command line)
• Parses and tokenizes commands
• Expands wildcards and variables
• Determines if it's built-in or external commands
• If external, it forks a child proces
• Uses exec() to replace process memory with command
• Waits for process completion

Init (PID 1) - Before any user process

• First process started by kernel
• Manages system initialization and background service
• Modern systems use Systemd. SysV init or openRC

Zombie State & Reaping

Zombie process

• A process that has finished executing but still has an entry in the process table
• Happens if the parents does notcall wait() to clean up

Reaping The OS (or parent process) removes zombie when wait() is called

Signals & Concurrency Issues

• Signals - Asynchronous notifications sent to processes
• Predefined, no payload-- Cannot send extra dta, only a signal number.
• Concurrency Issue-- if a signel is sent beffore a process si ready, it might get lost. DA-RESTART--- ensures internrupted system calls are retired instead of failing.

Signal Handling [signaction())] Sending Signals (kill())

• sigaction() Sets a signal handler for a process
• kill(pid, SIGTERM) Sends a termination signal to a process

Shell Pipeline (|) & redirection (<, >, >>)

Pipeline (|)

• Chains commands together by passingstdout of one to stdin of next..
• Example - cat file.txt |grep "error" | wc -1

Redirection

• < file Reads input froma file
• > file overwites a file with output
• >> file appends output.

Ways to provide input

• Command line Args --- ./scrip arg1 arg2
• Piped input-- Echo "hello" | my program
• Files--- my program < input.txt
• Standard input (stdin) --- Reads input dynamically.

Path, Pathname, Flilame

• Path --- Location of the file
• Filename- the name of a fil - w/out file path
• Absolute path name- Full path to the root
• Relative Pathname--- based on current

Ioctl() - Sends control command to devices (change terminal settings). Monting a File System

• Attaching a file system(USB)
• Mount /dev/SDB111 /mnt/USB - monts the device /mnt/Use Checks if directory is mount Pion - Mountpoint

The Shell

• A command line interpreter that allows users to interact with the OS
• Bash ZSH, Fish, SH
• Executes internal commands and external commands
• Provides features like vars, scripting, pipes, redirection, and job control

Standard input,output or error streams

Login Process

• Getly start and displays a login prompt

User Account info

• Contains basic user info but not password

Format

• usernamex:un/gid Examples

A shell

• the enviornment consits od vars the fact shell processes

Ram Vs Storages

RAM-FAst Votatile Storage IO Operations refer to reading /writing data between RAM and storage.

Block Device Layer & Block Size

• Storage is managed in blocks the Smallest unit of disk I/O
• The Block device layer abstract Hardware Differnces and allows buffering of Read/Wiite Operations

File types & inodes File types::

Regular files, directories, symbolic links, device files, sockets, FIFOs Stores Medata About files

File descriptor

• per process fils decrptio
• process tacks openfiles y insing intager ID

File System & device files

Special files

• exist only in VFS (Virtual File System) Not an the physicial disk Device files
• Are stored in /Dev and reperesnt Hadware.

Dev Files,Logical Size

The amount of data a file contains; - logical file Actural space the file occupy's on disl: - Physical fire .

• If 7> 0 ,the files Sparse(contains "holes")
• If O>7, disk fragmentation Or Compressin may be involvedi *

Files system cresh Consistency & Recovery

• System Crash Consiatancy - Ensuting data interity after chashes
• method Recory

Specail File Systems

• special file systems - OS- Information
• User -Spaces file Systems ALLoc implimenting custom

External Vs Internal Fragmentition

External F:

• Free space is split into small, unusable Chunks
• Intenall - un used

memory Vs Storage Alloaition

Memroy - Usises pages(files Sized unis,typicall by +kb)

• Storage - Uses - Blocks (also files, size Vary's by file system). dynamic Us Static Lnking
• Static linking - All depencies die induiled in the binary (larger Sizs, independent) dynamic lnking - The program loads shared libraries at runtime (Smaller, by depends On System libraries),

Per-Process Properties

Each process has:

• Enviorn ment variaables - Env, home, $path, ete
• Filse discipters - open files, pipes sockets

Current working directory CWD - Determines ivelative path behavior

Readiny commaand output

• Standy Commande Outputo - like ds stan de du. etc- Melps diagroner file syshemen And Storage isrues.

Explore key OS concepts: abstraction, preemptive multitasking, kernel architectures, and the user/kernel mode distinction. Understand process states, memory management, user IDs and the difference between hard and symbolic links.