Operating System Fundamentals

Overview

Any computer system includes a fundamental collection of programs collectively known as the Operating System (OS). At a high level, the OS comprises:

• Kernel: Handles process management, memory management, file management, and device drivers
• Supporting programs: Libraries, shell programs, and other utilities

Purpose of an OS

The operating system serves two primary functions:

• Interfaces with hardware to manage all software and hardware resources
• Provides a stable execution environment for user applications

OS Position in Architecture

The operating system occupies a unique position in the computer architecture hierarchy as specialized management software.

Understanding "Management"

Management involves two key operations:

• Describing managed objects through data structures
• Organizing managed objects through relationships

System Calls vs Library Functions

From a development perspective, the OS presents itself as a unified entity but exposes specific interfaces for upper-layer development. These OS-provided interfaces are called system calls.

System calls provide basic functionality with higher requirements for developers. Experienced programmers can encapsulate certain system calls to create libraries, facilitating development at higher abstraction levels.

Process Fundamentals

Definition

• Textbook definition: An execution instance of a program
• Kernel perspective: An entity responsible for allocating system resources (CPU time, memory)

Process Control Block (PCB)

Process information resides in a data structure called the Process Control Block, essentially a collection of process attributes.

In Linux, this structure is the task_struct.

task_struct Structure

The task_struct is Linux's implementation of a PCB—a kernel data structure loaded into RAM containing comprehensive process information.

Fields in task_struct

• Identifier: Unique process ID distinguishing it from other processes
• State: Task state, exit codes, termination signals
• Priority: Relative scheduling priority compared to other processes
• Program Counter: Address of the next instruction to execute
• Memory Pointers: Pointers to code, process-specific data, and shared memory blocks
• Context Data: CPU register values when the process was suspended
• I/O Status: I/O requests, assigned devices, and open files
• Accounting: CPU time consumed, clock ticks, resource limits

Process Organization

All processes in the system exist as a linked list of task_struct structures within the kernel.

Inspecting Processes

Process information is accessible through the /proc virtual filesystem. Common tools include top and ps.

Retrieving Process Identifiers

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

int main() {
    pid_t current_pid = getpid();
    pid_t parent_pid = getppid();
    
    printf("Current Process ID: %d\n", current_pid);
    printf("Parent Process ID: %d\n", parent_pid);
    
    return 0;
}

Process Creation: fork()

Key characteristics of fork():

• Returns twice: once to parent, once to child
• Code is shared between parant and child
• Data is copied (copy-on-write semantics)
• Conditional logic typically follows fork() to differentiate execution paths

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

int main() {
    pid_t result = fork();
    
    if (result < 0) {
        perror("fork failed");
        return 1;
    }
    
    if (result == 0) {
        printf("Child process: PID=%d, Return value=%d\n", getpid(), result);
    } else {
        printf("Parent process: PID=%d, Return value=%d\n", getpid(), result);
    }
    
    sleep(1);
    return 0;
}

Process States

State Categories

Use ps aux or ps axj to examine process states:

• R (Running): Process is executing or waiting in the run queue
• S (Sleeping): Process waits for an event to complete (interruptible sleep)
• D (Disk Sleep): Uninterruptible sleep, typically waiting for I/O completion
• T (Stopped): Process is suspended; can be resumed with SIGCONT
• X (Dead): Terminal state with no resources; not visible in process list

Zombie Processes

A zombie state occurs when a child terminates but the parent hasn't read its exit status via wait().

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    pid_t child = fork();
    
    if (child < 0) {
        perror("fork error");
        return 1;
    }
    
    if (child > 0) {
        printf("Parent (PID: %d) sleeping for 30 seconds...\n", getpid());
        sleep(30);
    } else {
        printf("Child (PID: %d) terminating after 5 seconds\n", getpid());
        sleep(5);
        exit(EXIT_SUCCESS);
    }
    
    return 0;
}

Zombie Process Implications

• Exit status must persist until the parent reads it
• Status information resides in the PCB, requiring ongoing memory allocation
• Multiple unreclaimed zombie children can exhaust memory resources
• The task_struct structure itself consumes memory even for terminated processes

Orphan Processes

When a parent terminates before its child, the child becomes an orphan. Orphans are adopted by init (PID 1) for cleanup.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork error");
        return 1;
    }
    
    if (pid == 0) {
        printf("Child (PID: %d) sleeping for 10 seconds\n", getpid());
        sleep(10);
    } else {
        printf("Parent (PID: %d) exiting after 3 seconds\n", getpid());
        sleep(3);
        exit(0);
    }
    
    return 0;
}

Process Priority

Fundamentals

Process priority determines CPU resource allocation order. Higher-priority processes execute first. Proper priority configuration optimizes multi-tasking performance.

CPU affinity allows assigning processes to specific processors, improving overall system efficiency.

Inspecting Priorities

The ps -l command displays priority-related information:

• UID: User identifier of process owner
• PID: Process identifier
• PPID: Parent process identifier
• PRI: Scheduling priority (lower values indicate higher priority)
• NI: Nice value affecting priority

Understanding PRI and NI

Priority (PRI) indicates scheduling order, with smaller values representing higher precedence.

The nice value (NI) modifies the base priority:

New_PRI = Old_PRI + Nice_Value

Negative nice values reduce the priority value, increasing precedence. Nice values range from -20 to +19, providing 40 priority levels.

Priority vs Nice Value

The nice value is not the priority itself, but a correction factor that influences scheduling priority.

Modifying Priority with top

top
# Press 'r', enter PID, then enter nice value

Environment Variables

Definition

Environment variables are parameters that define the operating system runtime environment. They enable dynamic library linking without hardcoded paths and typically have global scope.

Common Environment Variables

• PATH: Command search directories
• HOME: User's default working directory
• SHELL: Current shell interpreter (typically /bin/bash)

Querying Environment Variables

echo $VARIABLE_NAME

Related Commands

Command	Function
echo	Display variable value
export	Create or modify environment variable
env	List all environment variables
unset	Remove environment variable
set	Show local and environment variables

Environment Table Structure

Each program receives an environment table—a character pointer array where each element points to a null-terminated string.

Accessing Environment Variables in Code

Method 1: Third parameter to main

#include <stdio.h>

int main(int argc, char *argv[], char *env[]) {
    for (int i = 0; env[i] != NULL; i++) {
        printf("%s\n", env[i]);
    }
    return 0;
}

Method 2: Global variable environ

#include <stdio.h>

int main(int argc, char *argv[]) {
    extern char **environ;
    
    for (int i = 0; environ[i] != NULL; i++) {
        printf("%s\n", environ[i]);
    }
    return 0;
}

The environ variable is declared in libc without a header file—use extern for declaration.

Method 3: getenv function

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *path = getenv("PATH");
    if (path) {
        printf("PATH=%s\n", path);
    }
    return 0;
}

Global Nature of Environment Variables

Environment variables inherit to child processes.

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *value = getenv("MYVAR");
    if (value != NULL) {
        printf("MYVAR=%s\n", value);
    }
    return 0;
}

export MYVAR="test data"
./program

When launching a command, the shell (bash) creates a child process. The exported variable propagates through inheritance, demonstrating that environment variables flow downward to descendants.