PadhaikoAll subjects

System Programming Fundamentals

Network and Systems Programming (ENCT 386)

Open in the Padhaiko app

1.1 Overview of system programming and its role in networking

System programming is the discipline of writing low-level software that interacts directly with the operating system kernel, hardware abstractions, and core system resources—such as processes, memory, file descriptors, timers, and network interfaces—rather than relying solely on high-level application frameworks.

Definition

System Programming vs. Application Programming

Why System Programming Is Essential in Networking

Modern networked systems (web servers, load balancers, routers, proxies, DNS resolvers, and distributed databases) must handle thousands or millions of simultaneous connections with microsecond-level responsiveness. System programming provides the exact tools required:

  1. Direct Socket and Protocol Control: Applications need explicit access to TCP/UDP sockets, raw IP packets, socket options (SO_REUSEADDR, TCP_NODELAY), and kernel buffers to implement custom protocols or tune throughput.
  2. Low-Overhead I/O Multiplexing: High-concurrency servers rely on kernel event notification primitives (select, poll, epoll) and non-blocking file descriptors to monitor thousands of sockets inside a single thread.
  3. Zero-Copy and Buffer Management: System calls like sendfile() and mmap() minimize expensive memory copies between kernel buffers and user-space memory when serving large static files or streaming media.
  4. Process and Thread Orchestration: Network daemons must fork worker processes, manage thread pools, synchronize shared caches using mutexes or semaphores, and handle asynchronous OS signals (SIGTERM, SIGCHLD, SIGPIPE) cleanly without dropping active clients.

1.2 User space versus kernel space

Modern CPUs enforce hardware-level privilege separation using protection rings (on x86-64, Ring 0 for the OS kernel and Ring 3 for user applications; on ARM64, EL1 vs. EL0). The operating system divides virtual memory and CPU execution into two strictly isolated domains: Kernel Space and User Space.

Definition

Kernel Space and User Space

AspectUser SpaceKernel Space
CPU Privilege LevelUnprivileged mode (e.g., Ring 3 on x86-64)Privileged / Supervisor mode (e.g., Ring 0 on x86-64)
Memory IsolationPrivate virtual address space per process; isolated by MMUShared kernel virtual address space mapped across all processes
Hardware AccessProhibited; must request services via system callsFull direct access to CPU, MMU, NIC, and disk controllers
Fault ImpactCrash (e.g., segmentation fault) terminates only that processUnhandled bug causes a kernel panic, crashing the entire OS
Typical ComponentsShells, web servers (nginx), libc, Python/C user programsProcess scheduler, VFS, TCP/IP stack, memory manager, drivers

Mode Switching (Context Transition)

Because user programs cannot read a disk sector or transmit a network frame directly, they must cross the boundary into kernel space using a software interrupt or trap instruction (such as syscall on x86-64 or svc on ARM64):

  1. The user process places the system call number and arguments into designated CPU registers.
  2. The CPU executes the syscall instruction, which switches the hardware privilege level from User Mode to Kernel Mode and jumps to a trusted kernel entry point.
  3. The kernel validates every user-supplied pointer and permission check, performs the requested hardware/resource operation, and places the return value in a register.
  4. The kernel executes sysret (or eret), dropping privilege back to User Mode and resuming the user program.

1.3 System calls and standard libraries

A system call (syscall) is the programmatic interface through which a user-space process requests a privileged service from the operating system kernel. In practice, C programs rarely invoke raw CPU syscall trap instructions directly; instead, they call wrapper functions provided by the C Standard Library (libc, such as glibc or musl on Linux).

Definition

System Calls vs. Library Functions

AspectSystem CallsStandard Library Functions
Execution DomainCrosses into Kernel Space on every callRuns primarily in User Space; calls syscalls only when needed
BufferingUnbuffered at user level (kernel may still cache pages)User-space buffered (stdio buffer, typically 4 KB–8 KB)
Error ReportingReturns -1 and sets thread-local errnoVaries (NULL, EOF, or negative value; errno set if syscall failed)
PortabilityOS-specific / POSIX-specificPortable across all platforms implementing ISO C (stdio.h, stdlib.h)
Overhead per CallHigher (requires user-kernel mode switch)Very low for small operations absorbed by user-space buffers

Error Handling with errno and perror()

When a POSIX system call succeeds, it returns 0 or a non-negative integer (such as a file descriptor or byte count). When it fails, it returns -1 and stores a positive integer error code in the global (thread-local) variable errno (defined in <errno.h>).

Common POSIX errno Constants in System & Network Programming
ConstantTypical MeaningCommon Cause
EACCESPermission deniedOpening a protected file or binding a privileged port (< 1024) without root
ENOENTNo such file or directoryTarget path passed to open() or execve() does not exist
EINTRInterrupted system callA blocking syscall (like read() or accept()) was interrupted by a signal
EAGAIN / EWOULDBLOCKResource temporarily unavailableNon-blocking socket/fd has no data ready to read right now
EBADFBad file descriptorUsing a closed, negative, or uninitialized file descriptor
ECONNREFUSEDConnection refusedClient connect() reached a host where no server is listening on that port

1.4 File descriptors and low-level I/O

In Unix and Linux, "everything is a file" (or behaves like a file interface): regular disk files, terminal consoles, pipes, character devices, and network sockets are all accessed through small non-negative integers called file descriptors (fds).

Definition

File Descriptor

A file descriptor (fd) is a per-process, non-negative integer (0, 1, 2, ...) that acts as an index into the process's File Descriptor Table inside the kernel. Each entry points to an Open File Table entry (storing the file offset, access mode, and status flags), which in turn points to the kernel's v-node / i-node (or socket structure) representing the underlying resource.

Standard File Descriptors

By POSIX convention, every newly launched process inherits three pre-opened file descriptors from its parent shell:

Standard POSIX File Descriptors
FD NumberPOSIX Symbolic Constant (<unistd.h>)stdio StreamDefault Target
0STDIN_FILENOstdinKeyboard / terminal input
1STDOUT_FILENOstdoutTerminal screen output
2STDERR_FILENOstderrTerminal error output (unbuffered)

Kernel Three-Table File Representation

Understanding the separation of three kernel data structures explains how fork(), dup(), and dup2() work:

Kernel File Descriptor Architecture (Three-Table Model)Text
Process FD Table (Per-Process)       Open File Table (Kernel-Wide)         Inode / Socket Table
+----+-------+---------------+       +---------------------------+        +---------------------+
| fd | flags | file ptr      | ----> | mode: O_RDWR              | -----> | File metadata/data  |
+----+-------+---------------+       | offset: 1024              |        | (inode #4821, size) |
|  0 | ...   | -> tty_in     |       | refcount: 1               |        +---------------------+
|  1 | ...   | -> tty_out    |       +---------------------------+
|  2 | ...   | -> tty_err    |
|  3 | ...   | --------------+----^
+----+-------+---------------+

Core Low-Level POSIX I/O System Calls

Low-level unbuffered I/O uses five fundamental calls declared in <fcntl.h> and <unistd.h>:

Essential Low-Level POSIX I/O System Calls
System CallSignature SummaryPurpose & Return Value
open()int open(const char *path, int oflag, ... /* mode_t mode */);Opens or creates a file; returns lowest free fd (>= 0) or -1 on error. Flags include O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, O_NONBLOCK.
read()ssize_t read(int fd, void *buf, size_t count);Reads up to count bytes from fd into buf; returns bytes read (0 at EOF, -1 on error). Note: may return fewer bytes than requested (short read).
write()ssize_t write(int fd, const void *buf, size_t count);Writes up to count bytes from buf to fd; returns bytes written or -1 on error. Always loop on sockets/pipes to handle partial writes.
lseek()off_t lseek(int fd, off_t offset, int whence);Repositions the open file offset (SEEK_SET, SEEK_CUR, SEEK_END); fails with ESPIPE on pipes and sockets.
close()int close(int fd);Releases fd back to the process FD table and decrements the open file entry's reference count; returns 0 or -1.
dup() / dup2()int dup(int oldfd); / int dup2(int oldfd, int newfd);Duplicates an fd so both integers share the same Open File Table entry (and file offset). dup2() atomically closes newfd (if open) and duplicates oldfd onto newfd (used for shell I/O redirection).

1.5 Linux/Unix system architecture overview

A Linux/Unix operating system is organized into cleanly decoupled layers so that user programs remain portable across diverse storage, CPU, and networking hardware.

Linux/Unix Layered System ArchitectureText
+-----------------------------------------------------------------------+
|  USER SPACE                                                           |
|  [ Shells, Daemons, Network Servers ]   [ C Standard Library (libc) ] |
+-----------------------------------------------------------------------+
                  |   System Call Interface (SCI: syscall / libc)   |
+-----------------------------------------------------------------------+
|  KERNEL SPACE                                                         |
|  +-----------------+  +--------------------+  +--------------------+  |
|  | Process &       |  | Virtual File       |  | Network Stack      |  |
|  | Thread Scheduler|  | System (VFS)       |  | (Sockets, TCP/UDP, |  |
|  | (fork, exec)    |  | (ext4, procfs)     |  |  IP, Netfilter)    |  |
|  +-----------------+  +--------------------+  +--------------------+  |
|  +-----------------+  +--------------------+  +--------------------+  |
|  | Memory Manager  |  | IPC Subsystem      |  | Device Drivers     |  |
|  | (VM, mmap, swap)|  | (pipes, shm, msg)  |  | (NIC, NVMe, tty)   |  |
|  +-----------------+  +--------------------+  +--------------------+  |
+-----------------------------------------------------------------------+
|  HARDWARE:  CPU & MMU  |  Physical RAM  |  NIC (Ethernet/WiFi) | Disk |
+-----------------------------------------------------------------------+

Key Kernel Subsystems Relevant to Network & Systems Programming

  1. System Call Interface (SCI): Validates arguments, checks permissions, and dispatches traps (read, socket, fork, epoll_wait) to the proper kernel subsystem.
  2. Process & Scheduler Subsystem: Manages task_struct descriptors, process creation (fork/clone), virtual-CPU time-slicing, states (RUNNING, INTERRUPTIBLE, ZOMBIE), and signal delivery.
  3. Memory Management Subsystem: Implements virtual memory paging, copy-on-write (fork()), page cache (buffering file I/O in RAM), and memory-mapped files (mmap()).
  4. Virtual File System (VFS): Provides a uniform open/read/write/close abstraction over concrete file systems (ext4, xfs), pseudo-filesystems (/proc, /sys), pipes, and sockets.
  5. Networking Subsystem: Implements the BSD Socket layer, transport protocols (TCP, UDP), network layer (IPv4/IPv6, routing tables), and link-layer queueing disciplines before handing frames to the NIC device driver.
  6. Device Drivers: Hardware-specific kernel modules that program device registers, service interrupts, and run DMA transfers between peripheral hardware (disks, network cards) and kernel memory.

Worked Examples

Example

Tracing File Descriptor Allocation and Redirection with dup2()

A newly started Linux process has standard file descriptors 0 (stdin), 1 (stdout), and 2 (stderr) open. It executes the following sequence of system calls (assume every call succeeds):

  1. fd1 = open("input.txt", O_RDONLY);
  2. fd2 = open("output.log", O_WRONLY | O_CREAT | O_TRUNC, 0644);
  3. close(fd1);
  4. fd3 = open("err.log", O_WRONLY | O_CREAT | O_APPEND, 0644);
  5. dup2(fd2, STDOUT_FILENO);
  6. close(fd2);

Trace the integer values assigned to fd1, fd2, and fd3, and determine which file printf("OK\n") writes to afterward.

Initial State: At process startup, descriptors 0, 1, and 2 are already occupied by stdin, stdout, and stderr.

Applying the Lowest-Available FD Rule:

  • fd1 = open("input.txt", ...) receives the lowest free integer: fd1 = 3. Open set: {0, 1, 2, 3}.
  • fd2 = open("output.log", ...) receives the next lowest free integer: fd2 = 4. Open set: {0, 1, 2, 3, 4}.
  • close(fd1) frees descriptor 3. Open set: {0, 1, 2, 4}.
  • fd3 = open("err.log", ...) reuses the newly freed lowest slot: fd3 = 3. Open set: {0, 1, 2, 3, 4}.

Redirecting Standard Output with dup2():

After close(fd2), fd 4 is closed (reference count drops to 1), while fd 1 remains connected to output.log.

Tracing printf("OK\n"): Because printf() writes to stdout (STDOUT_FILENO = 1), and fd 1 now points to output.log, "OK\n" is written into output.log. (Also note fd1 + fd2 + fd3 summed across assignments equals 3 + 4 + 3 = 10, while final open non-standard fd is fd3 = 3, and fd1=3, fd2=4, STDOUT=1 -> 3 + 4 + 1 = 8.)

Answer:
  • fd1 = 3, fd2 = 4, and fd3 = 3 (reusing freed slot 3).
  • After dup2(fd2, 1) and close(fd2), open descriptors are 0 (stdin), 1 (output.log), 2 (stderr), and 3 (err.log).
  • printf("OK\n") writes to output.log.
Example

Low-Level POSIX File Copy Program in C

Write a clean, well-structured C program using only POSIX low-level I/O system calls (open, read, write, close) that copies a source file to a destination file using a 4096-byte buffer, handles partial writes safely, and reports errors via perror().

Open Source and Destination Files with Proper Flags and Permissions:

  • Open the source file with O_RDONLY.
  • Open the destination file with O_WRONLY, O_CREAT, and O_TRUNC (bitwise OR) and permission mode 0644 (rw-r--r--).

Loop with read() and Handle Partial write() Calls:

POSIX Low-Level File Copy Utility (posix_cp.c)C
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define BUF_SIZE 4096

int write_all(int fd, const char *buf, ssize_t len) {
    ssize_t total = 0;
    while (total < len) {
        ssize_t n = write(fd, buf + total, (size_t)(len - total));
        if (n < 0) {
            if (errno == EINTR) continue; /* retry if interrupted by signal */
            return -1;
        }
        total += n;
    }
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <src> <dst>\n", argv[0]);
        return EXIT_FAILURE;
    }

    int src_fd = open(argv[1], O_RDONLY);
    if (src_fd < 0) {
        perror("open source");
        return EXIT_FAILURE;
    }

    int dst_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (dst_fd < 0) {
        perror("open destination");
        close(src_fd);
        return EXIT_FAILURE;
    }

    char buf[BUF_SIZE];
    ssize_t nread;
    while ((nread = read(src_fd, buf, sizeof(buf))) != 0) {
        if (nread < 0) {
            if (errno == EINTR) continue;
            perror("read");
            close(src_fd);
            close(dst_fd);
            return EXIT_FAILURE;
        }
        if (write_all(dst_fd, buf, nread) < 0) {
            perror("write");
            close(src_fd);
            close(dst_fd);
            return EXIT_FAILURE;
        }
    }

    close(src_fd);
    close(dst_fd);
    return EXIT_SUCCESS;
}
Answer:

The program opens both files via open(), streams 4096-byte chunks with read(), guarantees complete transmission of each chunk using write_all() (retrying on EINTR and advancing the pointer on partial writes), checks errors with perror(), and releases both file descriptors with close().

Example

Quantifying System Call Overhead: Unbuffered vs. Buffered I/O

A C program copies a 1 MiB (1,048,576 bytes) file using read() and write(). Suppose each system call (round-trip user-to-kernel-to-user mode switch) takes 0.4 microseconds. Ignore actual disk/cache copy time and compute the pure syscall transition overhead when using:

  1. A 1-byte buffer (BUF_SIZE = 1).
  2. A 4096-byte buffer (BUF_SIZE = 4096).

Case 1 — 1-Byte Buffer: Reading and writing 1,048,576 bytes 1 byte at a time requires:

  • 1,048,576 read() syscalls (ignoring the single final read() returning 0 at EOF, or 1,048,576 data syscalls) + 1,048,576 write() syscalls = 2,097,152 data-transfer syscalls.
  • Total mode-switch overhead = 2,097,152 * 0.4 us = 838,860.8 us (~838.86 ms or 0.839 s) spent purely crossing the user-kernel boundary.

Case 2 — 4096-Byte (4 KiB) Buffer:

  • Number of chunks = 1,048,576 / 4096 = 256 chunks.
  • Total data-transfer syscalls = 256 read() + 256 write() = 512 syscalls.
  • Total mode-switch overhead = 512 * 0.4 us = 204.8 us (~0.205 ms).

Speedup Ratio: 838,860.8 us / 204.8 us = 4096 times lower syscall transition overhead.

Answer:
  1. 1-byte buffer: 2,097,152 data syscalls -> 838,860.8 microseconds (~838.9 ms) of syscall overhead.
  2. 4096-byte buffer: 512 data syscalls -> 204.8 microseconds (~0.205 ms) of syscall overhead (a 4096x reduction).

Exercises

Practice Exercises — System Programming Fundamentals

Question 1

Define system programming and explain four specific reasons why system-level programming (rather than high-level application frameworks alone) is critical for building scalable networked applications.

Definition: System programming is the development of low-level software (utilities, daemons, servers, drivers) that directly invokes operating system interfaces (system calls) to manage processes, threads, memory, file descriptors, and network hardware.

Four Roles in Networking:

  1. Direct Socket Control: Exposes TCP/UDP sockets, raw sockets, and kernel tuning options (SO_REUSEADDR, TCP_NODELAY, buffer sizes).
  2. I/O Multiplexing: Enables a single server process to monitor thousands of concurrent connections via select(), poll(), or epoll().
  3. Zero-Copy Transfers: Uses sendfile() and mmap() to avoid redundant user-kernel memory copies when serving high-volume network traffic.
  4. Deterministic Concurrency and Signal Handling: Provides fine-grained control over fork(), POSIX threads, mutexes, and asynchronous OS signals (SIGCHLD, SIGTERM) without garbage-collection pauses.
Answer:

System programming builds infrastructure directly atop OS system calls. In networking, it is critical for (1) direct socket/protocol control, (2) high-concurrency I/O multiplexing (epoll), (3) zero-copy data movement (sendfile/mmap), and (4) deterministic process, thread, and signal management.

Question 2

Differentiate between user space and kernel space. Trace the exact hardware and kernel sequence that occurs when a C program calls read(fd, buf, 100).

User Space vs. Kernel Space:

  • User Space executes at unprivileged CPU level (e.g., Ring 3 on x86-64) inside an isolated per-process virtual address space; it cannot access hardware or kernel memory directly, and a crash terminates only that process.
  • Kernel Space executes at privileged/supervisor level (Ring 0) with unrestricted access to RAM, MMU, NICs, and disks; an unhandled fault triggers a kernel panic.

Execution Sequence for read(fd, buf, 100):

  1. The C program calls the libc read() wrapper, which places the SYS_read syscall number and arguments (fd, buf, 100) in CPU registers and executes a trap instruction (syscall).
  2. Hardware elevates CPU privilege from User Mode to Kernel Mode and jumps to the kernel syscall dispatcher.
  3. The kernel validates that fd is valid and readable, and checks that buf points to writable user-space memory belonging to the calling process.
  4. The VFS subsystem invokes the underlying file/socket driver; if data is unavailable on a blocking fd, the process sleeps until an interrupt delivers data.
  5. The kernel copies up to 100 bytes into buf, puts the byte count in the return register, and executes sysret to drop back to User Mode.
Answer:

User space is unprivileged and process-isolated (Ring 3), whereas kernel space has unrestricted hardware access (Ring 0). Calling read() triggers a syscall trap into Ring 0, where the kernel validates fd and buf, retrieves data via VFS/drivers, copies bytes to user memory, and returns via sysret to User Mode.

Question 3

A network logging daemon writes 512 KiB (524,288 bytes) of log records. Suppose one mode switch (write() syscall) costs 0.5 microseconds, and the stdio library uses an 8 KiB (8,192-byte) user-space buffer. Compare:

  1. Calling unbuffered write(fd, &ch, 1) for every byte.
  2. Calling fwrite(&ch, 1, 1, fp) where stdio flushes automatically every 8 KiB.

Compute the number of write() syscalls and total syscall transition time in both cases.

Case 1 — Unbuffered write() per byte: Each 1-byte write() crosses into kernel space (2 mode switches per syscall: user-to-kernel entry + kernel-to-user return = 2 * 0.5 us = 1.0 us per syscall):

  • Number of write() syscalls = 524,288.
  • Total syscall transition time = 524,288 * 2 * 0.5 us = 524,288.0 us (524.288 ms).

Case 2 — stdio Buffered fwrite() (8 KiB user buffer): fwrite() copies each byte into libc's 8,192-byte user-space buffer without calling the kernel. It invokes write() only when the buffer fills:

  • Number of write() syscalls = 524,288 / 8,192 = 64 syscalls.
  • Total syscall transition time (at 2 * 0.5 us = 1.0 us per syscall) = 64 * 2 * 0.5 us = 64.0 us (0.064 ms).
Answer:
  1. Unbuffered write() per byte: 524,288 syscalls -> 524,288 us (524.288 ms) of transition overhead.
  2. Buffered fwrite() (8 KiB buffer): 64 syscalls -> 64.0 us (0.064 ms) of transition overhead (an 8,192x reduction).
Question 4

A process starts with standard fds 0, 1, and 2 open. It runs:

C
a = open("f1.txt", O_RDONLY);
b = open("f2.txt", O_WRONLY | O_CREAT, 0644);
close(0);
c = dup(b);
d = open("f3.txt", O_RDONLY);

Determine the exact integer values returned for a, b, c, and d, and explain how c and b interact when write(c, "Hi", 2) is followed by write(b, "!", 1).

Tracing Lowest-Available FD Assignments:

  • Initial open fds: {0, 1, 2}.
  • a = open("f1.txt", ...): lowest free fd is a = 3. Open set: {0, 1, 2, 3}.
  • b = open("f2.txt", ...): lowest free fd is b = 4. Open set: {0, 1, 2, 3, 4}.
  • close(0): closes stdin, freeing slot 0. Open set: {1, 2, 3, 4}.
  • c = dup(b): duplicates b onto the lowest free fd, which is c = 0. Open set: {0, 1, 2, 3, 4}.
  • d = open("f3.txt", ...): lowest free fd is d = 5. Open set: {0, 1, 2, 3, 4, 5}.

Interaction Between b and c: Because c was created via dup(b), entries 0 and 4 in the process FD table point to the same Open File Table entry (sharing the same file offset).

  1. write(c, "Hi", 2) writes "Hi" at offset 0 and advances the shared offset to 2.
  2. write(b, "!", 1) writes "!" at the shared offset 2 (instead of overwriting "Hi"), resulting in "Hi!" in f2.txt with offset 3.
Answer:

a = 3, b = 4, c = 0, and d = 5 (sum a + b + c + d = 12). Because dup(b) makes c share b's Open File Table entry and file offset, write(c, "Hi", 2) followed by write(b, "!", 1) sequentially writes "Hi!" into f2.txt.

Question 5

Sketch the Linux/Unix layered system architecture and trace how a network application's send() call on a TCP socket flows down through user space, kernel subsystems, and hardware.

Architectural Layers (Top to Bottom):

  1. User Space: Applications/daemons + libc standard library wrappers.
  2. System Call Interface (SCI): Validates fd and user buffer pointers, transitions CPU to Kernel Mode.
  3. Kernel Subsystems: Virtual File System (VFS) / BSD Socket layer, Network Protocol Stack (TCP/UDP, IP, Netfilter), Memory Manager (kernel socket buffers sk_buff), Process Scheduler, and IPC.
  4. Device Drivers: NIC driver managing transmit ring descriptors and DMA.
  5. Physical Hardware: CPU, RAM, and Network Interface Card (NIC).

Downward Path of send(sockfd, data, len, 0):

  1. Application calls libc send(), trapping via syscall into the SCI.
  2. SCI verifies sockfd maps to a socket in the process's FD table.
  3. The BSD Socket layer copies data from user space into kernel sk_buff structures inside the socket send buffer.
  4. The TCP layer segments the payload, attaches sequence/ack numbers and checksum, and passes segments to the IP layer for routing and IP header attachment.
  5. The NIC device driver places packet descriptors onto the hardware TX ring; the NIC fetches the frames via DMA and transmits electrical/optical signals onto the network medium.
Answer:

Linux/Unix separates User Space (libc and apps), the System Call Interface, Kernel Subsystems (Scheduler, Memory Manager, VFS, Network Stack, IPC, Device Drivers), and Hardware. A send() call traps across SCI into the BSD socket layer, moves data into kernel sk_buffs, traverses TCP -> IP -> NIC driver, and is transmitted by the NIC over DMA.

Process Management and IPC →