Master OS Fundamentals: From Kernel/User Modes to Semaphores

Introduction

Operating systems are the core brain of a computer, managing hardware and software resources to ensure stability, security, and efficiency. A solid understanding of OS fundamentals is essential for building reliable applications.

Core Functions of an Operating System

Process Management : create, schedule, and terminate processes.

Memory Management : allocate and reclaim memory.

File System Management : store, access, and protect files.

Device Management : control and coordinate peripheral devices.

User Mode vs. Kernel Mode

User mode runs ordinary applications with restricted access to hardware, while kernel mode has full system privileges, ensuring safe and orderly operation of the core.

User Mode

Definition : the normal execution mode for applications; direct hardware or kernel access is prohibited.

Function : programs request OS services via system calls, and their resource access is limited to protect the system.

Kernel Mode

Definition : the privileged execution mode of the OS kernel, with complete access to hardware and memory.

Function : kernel code and device drivers run here, performing low‑level operations and managing resources.

Switching between user and kernel mode occurs through system calls or interrupts, which incurs a performance cost.

Process and Thread Management

Processes are independent execution units, while threads are lightweight workers within a process. Understanding their lifecycle and scheduling is key to effective concurrency.

Processes typically have three basic states—running, ready, and blocked—and may transition through additional states such as suspended or terminated.

Semaphores: Synchronization and Mutual Exclusion

Semaphores are synchronization primitives that control access to shared resources, preventing race conditions and ensuring orderly execution.

Integer Semaphore

Basic operations are wait(S) and signal(S):

wait(S) {
    while (S <= 0);
    S = S - 1;
}

signal(S) {
    S = S + 1;
}

Record Semaphore

wait(S) {
    S = S - 1;
    if (S < 0) {
        block(); // current thread blocks
    }
}
signal(S) {
    S = S + 1;
    if (S <= 0) {
        wakeup(); // wake up a blocked thread
    }
}

Applications

Synchronization : coordinate the execution order of multiple processes or threads, e.g., the producer‑consumer problem.

Mutual Exclusion : ensure that only one thread accesses a critical section at a time.

Predecessor Relationship : enforce task ordering using semaphores.

// Producer‑Consumer example
// Initialize semaphores
sem_init(&full, 0, 0);
sem_init(&empty, 0, N);

void producer() {
    while (true) {
        // produce data
        sem_wait(&empty);   // wait for empty slot
        // place data
        sem_post(&full);    // signal full slot
    }
}

void consumer() {
    while (true) {
        sem_wait(&full);    // wait for full slot
        // retrieve data
        sem_post(&empty);   // signal empty slot
    }
}

Conclusion

Operating systems provide a safe execution environment by separating user and kernel modes, achieve efficient concurrency through process and thread management, and rely on semaphores for synchronization and mutual exclusion, enabling developers to create stable and high‑performance software.