Kernel Diaries - Architecture

Linux is a powerful and versatile operating system, widely used in servers, embedded systems, and even desktops. To understand its inner workings, we need to examine its architecture, which follows a layered design, providing abstraction and modularity. This blog explores Linux architecture with examples and illustrations to simplify key concepts.

1. Overview of Linux Architecture

Linux architecture consists of several layers, each with specific responsibilities:

Hardware Layer: Includes physical components like CPU, memory, storage, and peripheral devices.
Kernel Layer: The core of Linux, managing processes, memory, hardware interactions, and system calls.
System Call Interface (SCI): Acts as a bridge between user applications and the kernel.
User Space: Where user applications and utilities run.

Below is a high-level representation of Linux architecture:

+-----------------------+
| User Applications    |
+-----------------------+
| System Call Interface |
+-----------------------+
| Kernel Layer         |
| - Process Management |
| - Memory Management  |
| - Device Drivers     |
| - File System        |
| - Network Stack      |
+-----------------------+
| Hardware Layer       |
+-----------------------+

2. Linux Kernel: The Heart of the OS

The kernel is responsible for resource management and system stability. It has multiple subsystems:

a. Process Management

Handles process creation, scheduling, and termination.

Example: The fork() system call in C creates a new process.

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child Process\n");
    } else {
        printf("Parent Process\n");
    }
    return 0;
}

b. Memory Management

Manages RAM allocation using paging and swapping.

Example: The malloc() function in C dynamically allocates memory.

c. File System Management

Manages file storage and retrieval.

Example: The open() system call interacts with the file system.

#include <fcntl.h>
#include <unistd.h>
int main() {
    int fd = open("test.txt", O_RDONLY);
    if (fd < 0) {
        perror("Error opening file");
    }
    close(fd);
    return 0;
}

d. Networking Subsystem

Handles communication between devices and networks using protocols like TCP/IP.

Example: The socket() system call creates a network socket.

#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("Error creating socket");
    }
    return 0;
}

e. Security Mechanisms

Includes mandatory access control (MAC), discretionary access control (DAC), and Linux Security Modules (LSM) such as SELinux and AppArmor.

Example: Checking security context with SELinux.

ls -Z /etc/passwd

3. User Space: Running Applications

User space includes all applications, shells, and libraries. Examples:

bash (Command-line interpreter)
vim (Text editor)
ls, cat, grep (Linux commands)

4. System Calls: Bridging User Space and Kernel

System calls allow user applications to interact with the kernel.

Example: write() system call writes data to a file.

#include <unistd.h>
int main() {
    write(1, "Hello, Linux!\n", 14);
    return 0;
}

5. Conclusion

Understanding Linux architecture is crucial for system administration, kernel development, and security research. With its layered design, Linux ensures modularity, stability, and flexibility across different hardware platforms.