Operating Systems, Linux Architecture & CLI

Unit 3 — Operating Systems, Linux Architecture & Command-Line Environments

1. Operating System Foundations & Evolution

An Operating System (OS) is system software that acts as an intermediary interface between computer hardware and user applications. It fulfills two primary objectives:

1. Extended Machine (Abstractor): Hides complex, heterogeneous physical hardware registers behind uniform, programmer-friendly interfaces (system calls).
2. Resource Manager: Allocates CPU execution time, primary memory addresses, disk storage, and I/O devices fairly, securely, and efficiently among competing processes.

+-------------------------------------------------------------+
|                     USER APPLICATIONS                       |
|           Browsers · Text Editors · Compilers · Games       |
+-------------------------------------------------------------+
|                  SYSTEM CALL INTERFACE                      |
|                  open() · read() · fork() · write()         |
+-------------------------------------------------------------+
|                   OPERATING SYSTEM KERNEL                   |
|   Process Manager · Memory Manager · File System · Drivers  |
+-------------------------------------------------------------+
|                      COMPUTER HARDWARE                      |
|                     CPU · RAM · Storage · I/O               |
+-------------------------------------------------------------+

1.1 Five Core Functions of an Operating System

1. Processor / Process Management: Scheduling CPU time slices among active threads, tracking process execution states, handling context switching, and resolving deadlocks.
2. Memory Management: Allocating memory chunks to processes, deallocating memory on termination, and managing virtual memory paging/swapping between RAM and disk.
3. File System Management: Organizing files and folders into hierarchical directory structures, managing file access permissions, and reading/writing disk sectors.
4. Device / I/O Management: Buffering, caching, and communicating with hardware peripherals via specialized device drivers.
5. Security & Protection: Preventing unauthorized access through user authentication, protecting memory spaces from cross-process corruption, and enforcing file access control lists.

1.2 Classification of Operating Systems

1.3 Generations & Evolution of Operating Systems

Operating systems evolved through distinct architectural generations in lockstep with advancing semiconductor and computing hardware:

2. Linux Architecture & Shell Environments

Linux is a free, open-source, POSIX-compliant, multi-user, multitasking operating system based on Unix design principles.

2.1 The Four Architecture Layers

1. Hardware: Physical silicon (CPU, RAM, Disks, Network cards).
2. Kernel: The core heart of the operating system that resides continuously in protected memory space. Controls hardware directly, executes process scheduling, and enforces memory isolation.
3. Shell: The command language interpreter that reads text commands from the user or script file and translates them into underlying kernel system calls.
   • Common Shells: bash (Bourne Again Shell - Linux default), zsh (Z Shell - macOS default), sh (Bourne Shell).
4. User Applications & Utilities: Command-line utilities (ls, grep, cat) and high-level software suites running in user space.

2.2 Shell Environment Variables

The shell maintains configuration state through key-value environment variables:

• echo $SHELL: Displays active shell binary path (e.g., /bin/bash).
• echo $HOME: Current user's home directory (e.g., /home/student).
• echo $USER: Active logged-in username.
• echo $PATH: Colon-separated list of directories searched by the shell when executing commands.

3. Core Linux Command-Line Navigation & File Manipulation

The Linux directory structure is a single inverted tree starting from the root directory (/):

                                      / (Root)
                                      |
         +---------+---------+--------+--------+---------+
         |         |         |        |        |         |
       /bin      /etc      /home     /var     /tmp     /usr
       (Core     (Config    |        (Logs)   (Temp)   (User
      Commands)  Files)  /student                      Programs)

3.1 Essential Navigation Commands

3.2 Directory and File Manipulation Commands

3.3 File Viewing & Text Processing Commands

• cat filename: Concatenates and prints entire file content to terminal standard output.
• less filename: Interactive pager allowing forward/backward scrolling through large files (q to quit).
• head -n 10 file.txt: Displays the first 10 lines of a file.
• tail -n 10 file.txt: Displays the last 10 lines of a file.
• grep "keyword" file.txt: Global Regular Expression Print: searches and prints lines matching pattern.
• wc -l file.txt: Word Count utility: -l counts total lines, -w counts words, -c counts bytes.
• find /path -name "*.c": Recursively searches filesystem for files matching name pattern.

4. Linux Security & File Permissions Architecture

Every file and directory in Linux has an explicit security ownership model divided into three user classes and three permission modes:

        -   r w x   r - x   r - -
        |   \___/   \___/   \___/
     File   User    Group   Others
     Type  (Owner)

4.1 Permission Classes & Value Weights

4.2 Octal Calculation & chmod Command

The octal permission is calculated by summing the values of granted permissions for each class:

• rwx = $4 + 2 + 1 = \mathbf{7}$ (Full control)
• rw- = $4 + 2 + 0 = \mathbf{6}$ (Read and Write)
• r-x = $4 + 0 + 1 = \mathbf{5}$ (Read and Execute)
• r-- = $4 + 0 + 0 = \mathbf{4}$ (Read-only)
• --- = $0 + 0 + 0 = \mathbf{0}$ (No access)

Standard Octal Configurations:

• chmod 755 script.sh: Owner gets rwx (7), Group gets r-x (5), Others get r-x (5). (Standard for executable scripts and directories).
• chmod 644 document.txt: Owner gets rw- (6), Group gets r-- (4), Others get r-- (4). (Standard for web and document files).
• chmod 600 private.key: Owner gets rw- (6), Group gets none (0), Others get none (0). (Strict security for SSH keys).

Symbolic Notation Examples:

• chmod u+x program.bin: Grants execute permission to the owner.
• chmod g-w shared.txt: Revokes write permission from the group.
• chmod o=r public.txt: Sets others permission strictly to read-only.

4.3 Ownership Commands

• chown student:cse file.txt: Changes owner to user student and group to cse.
• chgrp cse file.txt: Changes assigned group to cse.

5. Linux Process Management & System Calls

A process is an active program currently in execution loaded into memory.

5.1 Process Lifecycle States

[ New ] ---> [ Ready ] <====== Context Switch ======> [ Running ] ---> [ Terminated ]
                 ^                                         |
                 |                                         v
                 +-------------- [ Waiting / Blocked ] <---+
                                    (I/O Request)

• New: Process is being initialized and created.
• Ready: Process is in memory waiting to be assigned CPU time by the scheduler.
• Running: Instructions are currently being executed by the CPU core.
• Waiting / Blocked: Process yielded CPU waiting for an external event (I/O, keyboard, disk read).
• Terminated: Process finished execution; system resources are reclaimed.

5.2 Process Control Block (PCB) & Identification

The Linux kernel maintains a Task Struct / PCB for every active process:

• PID (Process ID): Unique integer identifying the process (e.g., PID 1042).
• PPID (Parent Process ID): The PID of the process that spawned this child process.
• Process State: Current status (Running R, Sleeping S, Stopped T, Zombie Z).

5.3 Core Linux System Calls (fork, exec, wait)

In C and Linux systems programming, process hierarchies are constructed using low-level kernel system calls:

1. fork() System Call:
   • Creates an exact duplicate child process by cloning the parent process memory space, file descriptors, and registers.
   • Return Values:
     • Returns 0 to the newly created child process.
     • Returns the child's PID ($> 0$) to the parent process.
     • Returns a negative value ($-1$) if process creation fails.
2. exec() Family (execl, execvp):
   • Replaces the current process memory image with a completely new binary program from disk. The PID remains unchanged, but execution starts fresh from the new program's main().
3. wait() / waitpid():
   • Causes the parent process to suspend execution and wait until a child process terminates, reading the child's termination exit status code.

Classic fork() Code Pattern:

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        printf("Fork failed!\n");
        return 1;
    } else if (pid == 0) {
        // Child process execution branch
        printf("Child Process: PID = %d, Parent PID = %d\n", getpid(), getppid());
    } else {
        // Parent process execution branch
        wait(NULL); // Wait for child to finish
        printf("Parent Process: Child with PID = %d completed\n", pid);
    }
    return 0;
}

• Zombie Process: A child process that completed execution, but its exit status has not yet been read by its parent via wait(). Retains a minimal PCB entry in the process table.
• Orphan Process: A child process whose parent terminated prematurely. In Linux, orphan processes are automatically adopted by init / systemd (PID 1).

5.4 Process Monitoring Commands

• ps: Displays snapshot of active processes in current terminal session.
• ps aux: Displays all active processes running across the entire system.
• top: Interactive real-time display of running processes, CPU usage, and memory consumption.
• htop: Enhanced, colorful, ncurses-based interactive process monitor with mouse navigation.
• kill [PID]: Sends the termination signal SIGTERM (15) requesting graceful shutdown.
• kill -9 [PID]: Sends SIGKILL (9), immediately terminating the process without cleanup.
• Background execution: Appending & runs command in background (./long_job.sh &).

6. Remote Cloud Execution via SSH

Cloud computing and modern server administration rely on headless Command Line Interfaces over secure network connections.

6.1 Secure Shell (SSH)

SSH (Secure Shell) operates over default port 22, providing cryptographically encrypted command execution and administrative access across public networks.

# Connect to a remote Linux cloud server using password or key
ssh username@remote_server_ip

# Example: Connecting to an AWS Ubuntu instance with a private key
ssh -i "my-keypair.pem" ubuntu@ec2-54-210-12-89.compute-1.amazonaws.com

6.2 Secure Copy Protocol (SCP)

Transfers files securely between local and remote computers over SSH:

# Upload local file to remote server
scp local_report.txt username@remote_server_ip:/home/username/

# Download remote file to local computer
scp username@remote_server_ip:/var/log/syslog ./syslog_backup.txt

7. Unit 3 Review & CAT 3 Exam Checklist

• 5 Core OS Functions: Process, Memory, File System, Device, and Security management.
• OS Types: Compare Batch, Time-Sharing, and Real-Time (Hard vs Soft RTOS) systems.
• Linux Architecture: Describe Hardware $\rightarrow$ Kernel $\rightarrow$ Shell $\rightarrow$ User Programs.
• Octal Permission Calculation: Convert symbolic strings (e.g., -rwxr-xr--) into exact octal numbers (754) and vice versa.
• System Calls: Explain the return value behavior of fork() and describe the relationship between fork(), exec(), and wait().
• Zombies vs. Orphans: Differentiate between a zombie process and an orphan process.
• Remote Cloud Operations: Explain the role of port 22 and SSH keypair authentication.