Understanding Linux Processes, Scheduling Algorithms, and Inter‑Process Communication

From a user perspective a process is an executing instance of a program with its own memory space, registers, and execution context; the kernel creates it via the scheduler and assigns a unique PID. The article first explains the basic concepts of processes, their independent memory, parent‑child relationships, and the three classic states: running, blocked, and ready.

It then details Linux‑specific process structures, showing how the struct Env (or PCB) stores registers, status, and page directory, and how functions such as env_alloc , env_create , and env_run initialize a new process, load its ELF image, and switch to user mode.

The scheduling section reviews several algorithms: First‑Come‑First‑Serve, time‑slice round‑robin, Shortest‑Job‑First (preemptive and non‑preemptive), priority scheduling, and mixed policies. Real‑time strategies are covered, including Earliest‑Deadline‑First (EDF) and Rate‑Monotonic Scheduling (RMS), with the utilization bound U = Σ(Ci / Pi) ≤ ln 2 for guaranteed schedulability.

Inter‑process communication (IPC) mechanisms are compared. Pipes and named pipes provide byte‑stream channels for related processes; sockets (stream, datagram, raw) enable networked communication; signals act as lightweight notifications; semaphores implement binary or counting locks; shared memory offers fast random‑access data exchange but requires explicit synchronization; and message queues support many‑to‑many asynchronous messaging.

Finally, the article walks through the Linux‑0.11 kernel implementation of the fork system call. The assembly routine _system_call saves user registers, switches segment selectors to kernel space, and dispatches to _sys_fork . The C routine copy_process allocates a new task_struct, copies the parent’s PCB, sets up a new TSS and LDT, and marks the child as TASK_RUNNING . After fork returns, the scheduler’s schedule() function invokes switch_to(next) , which loads the child’s TSS via a far jump ( ljmp ), causing the child’s eax to be zero and thus executing the child branch of the if (!fork()) test in main() . This demonstrates how kernel‑mode stack and user‑mode stack are linked through the TSS, enabling true context switching between processes.

int copy_process(int nr, long ebp, long edi, long esi, long gs, long none,
                long ebx, long ecx, long edx,
                long fs, long es, long ds,
                long eip, long cs, long eflags, long esp, long ss)
{ ... }

_system_call:
    cmpl $nr_system_calls-1,%eax
    ja bad_sys_call
    push %ds
    push %es
    push %fs
    pushl %edx
    pushl %ecx
    pushl %ebx
    movl $0x10,%edx
    mov %dx,%ds
    mov %dx,%es
    movl $0x17,%edx
    mov %dx,%fs
    call _sys_call_table(,%eax,4)
    ...
    ret