KERNEL

Kẻ Đứng Sau Windows, macOS và Linux

Từ người mới bắt đầu đến trung cấp — Hiểu sâu về "Trái Tim" của mọi Hệ Điều Hành

Kernel Là Gì?

1.1 Định nghĩa từ gốc

Từ "Kernel" bắt nguồn từ tiếng Anh cổ "cyrnel", nghĩa là "hạt nhân", "phần lõi" — thứ nằm ở trung tâm nhất của một vật thể. Trong ngữ cảnh hệ điều hành, Kernel là phần lõi — chương trình trung tâm nhất của hệ điều hành, chạy trực tiếp trên phần cứng với quyền cao nhất (Ring 0 / Kernel Mode).

Hãy tưởng tượng máy tính của bạn là một tòa nhà văn phòng khổng lồ:

Trong tòa nhà này:

• CPU = Phòng máy chủ — nơi thực thi công việc
• RAM = Bàn làm việc — không gian làm việc tạm thời
• SSD/HDD = Kho lưu trữ — nơi cất giữ tài liệu
• Kernel = Người Quản Lý Tòa Nhà — phân phối tài nguyên, điều phối công việc, đảm bảo an ninh
• Ứng dụng = Nhân viên — yêu cầu tài nguyên và thực hiện công việc

1.2 Bốn phép ẩn dụ cho Kernel

1.3 Vì sao mọi hệ điều hành đều cần Kernel?

Không có Kernel, mỗi ứng dụng sẽ phải tự quản lý phần cứng. Điều này dẫn đến:

Máy Tính Hoạt Động Như Thế Nào?

Từ lúc bạn bấm nút nguồn cho đến khi desktop hiện ra — một hành trình kỳ diệu diễn ra trong vài giây.

2.1 Hành trình khởi động — Từng bước một

2.2 Sơ đồ phân tầng hệ thống

Vì Sao Không Thể Chạy Ứng Dụng Trực Tiếp Lên CPU?

3.1 Kịch bản không có Kernel

Giả sử bạn có 3 ứng dụng: Chrome, VS Code, và Spotify. Tất cả đều muốn dùng RAM cùng lúc. Không có Kernel — chuyện gì xảy ra?

3.2 Kernel giải quyết như thế nào?

3.3 Ví dụ thực tế: Phân phối CPU

/*
 * DEMO: Cách Kernel phân phối CPU cho nhiều tiến trình
 * (Mô phỏng đơn giản bằng C - pthread)
 */
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* task(void* name) {
    for (int i = 0; i < 5; i++) {
        printf("[%s] Đang chạy... lượt %d\n", (char*)name, i);
        usleep(100000); // Giả lập công việc (100ms)
    }
    return NULL;
}

int main() {
    pthread_t chrome, vscode, spotify;

    // Tạo 3 "ứng dụng" cùng chạy
    pthread_create(&chrome,  NULL, task, "Chrome");
    pthread_create(&vscode,  NULL, task, "VS Code");
    pthread_create(&spotify, NULL, task, "Spotify");

    // Kernel (thông qua scheduler) sẽ xen kẽ thực thi
    // Mỗi ứng dụng được một "lát" CPU rồi chuyển sang ứng
    // dụng khác — bạn sẽ thấy output đan xen!

    pthread_join(chrome,  NULL);
    pthread_join(vscode,  NULL);
    pthread_join(spotify, NULL);

    printf("Tất cả đã hoàn thành!\n");
    return 0;
}

Kernel Làm Những Công Việc Gì?

Kernel có 6 nhiệm vụ chính, mỗi nhiệm vụ là cả một lĩnh vực khoa học máy tính. Hãy đi sâu vào từng nhiệm vụ.

4.1 Quản Lý CPU — Scheduler (Bộ Điều Phối)

CPU giống như một nhân viên duy nhất trong văn phòng. Nhưng có hàng trăm "công việc" (process/thread) cần được xử lý. Làm sao để một người làm được trăm việc?

Context Switch — "Chuyển cảnh"

Khi Kernel chuyển từ Process A sang Process B, nó phải:

1. Lưu trạng thái của Process A (giá trị thanh ghi CPU, con trỏ lệnh, stack pointer...)
2. Nạp trạng thái của Process B
3. Nhảy đến vị trí Process B đang dừng

Mỗi Context Switch tốn ~1-5 microsecond — cực nhanh, nhưng nếu có hàng nghìn process, tổng chi phí có thể đáng kể.

Code minh họa: Tạo Process trong Linux

/*
 * DEMO: fork() — System Call tạo process mới
 * Kernel sao chép toàn bộ process cha → process con
 * Cả hai cùng chạy "song song"
 */
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork(); // ← GỌI KERNEL!

    if (pid == 0) {
        // Đây là Process CON
        printf("[CON]  PID=%d, Cha=%d\n", getpid(), getppid());
        printf("[CON]  Tôi đang làm việc...\n");
    } else if (pid > 0) {
        // Đây là Process CHA
        printf("[CHA] PID=%d, Con=%d\n", getpid(), pid);
        wait(NULL); // Đợi con hoàn thành
        printf("[CHA] Con đã xong!\n");
    } else {
        printf("Fork thất bại!\n");
    }
    return 0;
}

4.2 Quản Lý RAM — Memory Manager

Virtual Memory — Ảo ảnh lớn nhất trong máy tính

Mỗi ứng dụng "nghĩ" rằng mình sở hữu toàn bộ RAM (vd: 16GB). Nhưng thực tế, Kernel đang tạo ra một không gian địa chỉ ảo cho từng process.

Paging & Swap

Khi RAM đầy, Kernel dùng Swap: đẩy những trang RAM ít dùng ra ổ cứng (swap file/partition). Khi cần lại, nó đọc ngược vào RAM. Đây là lý do máy tính chạy chậm khi hết RAM — ổ cứng chậm hơn RAM ~1000 lần!

OOM Killer — Sát thủ cuối cùng

Khi RAM và Swap đều cạn kiệt, Linux Kernel kích hoạt OOM Killer (Out-Of-Memory Killer). Nó chọn và giết một process để giải phóng RAM, dựa trên điểm số OOM (process càng chiếm nhiều RAM, điểm càng cao, càng dễ bị giết).

# Kiểm tra log OOM Killer trên Linux
dmesg | grep -i "out of memory"
# Output ví dụ:
# Out of memory: Killed process 12345 (chrome) total-vm:8GB

Heap vs Stack

4.3 Quản Lý File — Virtual File System (VFS)

Kernel cung cấp một giao diện thống nhất cho mọi loại filesystem. Dù ổ cứng của bạn format bằng NTFS, EXT4 hay APFS — ứng dụng chỉ cần gọi open(), read(), write(), Kernel sẽ lo phần còn lại.

So sánh các Filesystem

Kernel đọc file như thế nào?

/*
 * DEMO: Cách ứng dụng đọc file thông qua Kernel
 * Mỗi dòng code C bên dưới → 1 SYSTEM CALL → Kernel xử lý
 */
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 1. open() → System Call → Kernel tìm file trên ổ cứng
    int fd = open("/home/user/data.txt", O_RDONLY);
    if (fd == -1) { perror("open"); return 1; }

    char buffer[1024];

    // 2. read() → System Call → Kernel đọc sector từ ổ cứng
    //    → copy dữ liệu vào buffer trong RAM của process
    ssize_t bytes = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes > 0) {
        buffer[bytes] = '\0';
        printf("Đọc được %zd bytes:\n%s\n", bytes, buffer);
    }

    // 3. close() → System Call → Kernel giải phóng file descriptor
    close(fd);
    return 0;
}

4.4 Quản Lý Driver — Giao Tiếp Với Phần Cứng

Driver là "phiên dịch viên" giữa Kernel và phần cứng. Mỗi thiết bị nói một "ngôn ngữ" khác nhau — Driver dịch ngôn ngữ đó thành lệnh chuẩn mà Kernel hiểu.

4.5 Network Stack — Mạng Máy Tính

Kernel chứa toàn bộ TCP/IP Stack — bộ giao thức giúp máy tính của bạn nói chuyện với toàn bộ Internet.

Ví dụ: Server TCP đơn giản

/*
 * DEMO: TCP Server — Mỗi hàm là một System Call
 * Kernel xử lý toàn bộ TCP handshake, retransmit, checksum...
 */
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    // socket() → Kernel tạo socket, cấp file descriptor
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),          // Cổng 8080
        .sin_addr.s_addr = INADDR_ANY,    // Lắng nghe mọi IP
    };

    // bind() → Kernel gán socket với địa chỉ IP + Port
    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));

    // listen() → Kernel bắt đầu lắng nghe kết nối
    listen(server_fd, 5);

    printf("Server đang lắng nghe trên cổng 8080...\n");

    // accept() → Kernel chờ và nhận kết nối từ client
    int client_fd = accept(server_fd, NULL, NULL);

    // send() → Kernel đóng gói dữ liệu → TCP → IP → Ethernet
    char* msg = "HTTP/1.1 200 OK\r\n\r\n<h1>Hello từ Kernel!</h1>";
    send(client_fd, msg, strlen(msg), 0);

    close(client_fd);
    close(server_fd);
    return 0;
}

4.6 Security — Bảo Mật

Kernel là lớp bảo vệ cuối cùng của hệ thống. Nếu Kernel bị xâm phạm, toàn bộ máy tính bị chiếm quyền điều khiển.

Các cơ chế bảo mật của Kernel

User Space và Kernel Space

5.1 Hai thế giới tách biệt

5.2 System Call — Cánh cổng duy nhất

System Call (lời gọi hệ thống) là cách DUY NHẤT để ứng dụng (User Space) yêu cầu Kernel làm việc gì đó. Không có đường tắt, không có cửa sau. Mỗi System Call đều được Kernel kiểm tra quyền trước khi thực thi.

Các System Call quan trọng nhất

Code C: Hành trình của printf()

/*
 * Khi bạn gọi printf("Hello World\n");
 * Đây là những gì THỰC SỰ diễn ra:
 */
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    // Cấp 1: Ứng dụng gọi printf()
    printf("Hello World\n");

    // Cấp 2: printf() trong glibc gọi write() system call
    // (Viết lại tương đương):
    const char* msg = "Hello từ System Call!\n";
    write(STDOUT_FILENO, msg, strlen(msg));
    //      ↑
    //      └── ĐÂY LÀ SYSTEM CALL THỰC SỰ
    //          CPU chuyển từ Ring 3 → Ring 0
    //          Kernel nhận yêu cầu → ghi ra terminal → trả về

    // Cấp 3: _exit() system call — kết thúc process
    _exit(0);
    // (Không dùng return vì _exit là system call trực tiếp)
}

Kiến Trúc Kernel

6.1 Các loại kiến trúc Kernel

6.2 Bảng so sánh chi tiết

Kernel Của Linux

7.1 Lịch sử Linux Kernel

7.2 Đặc điểm nổi bật của Linux Kernel

CFS — Completely Fair Scheduler

Mỗi process có vruntime — process nào dùng CPU ít nhất sẽ được ưu tiên chạy tiếp. Dùng Red-Black Tree để tìm process có vruntime nhỏ nhất trong O(log n).

BPF / eBPF — Berkeley Packet Filter

Công nghệ đột phá: cho phép chạy code an toàn TRONG KERNEL mà không cần biên dịch lại kernel. eBPF được dùng cho: network filtering, observability (quan sát hệ thống), security, tracing. Cilium, Falco, systemd — tất cả đều dùng eBPF.

Namespaces & Cgroups → Containers

Đây là nền tảng của Docker và Kubernetes:

• Namespaces: Cô lập tài nguyên cho process (PID namespace, Network namespace, Mount namespace...)
• Cgroups: Giới hạn tài nguyên (CPU, RAM, I/O) cho nhóm process

Module (.ko files)

Linux cho phép nạp/tháo driver lúc đang chạy — không cần reboot. modprobe để nạp, rmmod để gỡ.

# Kiểm tra phiên bản Linux Kernel
uname -r
# Output: 6.8.0-40-generic

# Xem thông tin chi tiết về kernel
cat /proc/version

# Xem danh sách module kernel đang nạp
lsmod | head -10

# Xem tham số kernel
sysctl -a | grep kernel

Kernel Của Windows — Windows NT Kernel

8.1 Kiến trúc Windows NT

8.2 Các thành phần cốt lõi

8.3 BSOD — Blue Screen of Death

Khi Windows Kernel phát hiện lỗi nghiêm trọng không thể phục hồi, nó dừng toàn bộ hệ thống và hiển thị BSOD. Mỗi mã lỗi (STOP code) cho biết nguyên nhân:

• IRQL_NOT_LESS_OR_EQUAL — Driver truy cập RAM sai quyền
• PAGE_FAULT_IN_NONPAGED_AREA — Truy cập vùng RAM không tồn tại
• KMODE_EXCEPTION_NOT_HANDLED — Lỗi không được xử lý trong Kernel Mode
• DRIVER_POWER_STATE_FAILURE — Lỗi driver khi chuyển chế độ năng lượng

Kernel Của macOS — XNU

9.1 XNU = Mach + BSD + IOKit

9.2 Lịch sử XNU

9.3 Đặc điểm độc đáo của XNU

• Hybrid Kernel: Kết hợp Mach (microkernel) + BSD (monolithic) → vừa linh hoạt vừa hiệu năng
• IOKit: Driver framework hướng đối tượng (C++), cho phép kế thừa và tái sử dụng driver
• Metal: Tích hợp sâu với GPU cho đồ họa và tính toán GPGPU ngay trong kernel
• APFS: Filesystem tối ưu cho SSD/NVMe — snapshot, clone, nén, mã hóa, space sharing
• Apple Silicon Integration: XNU và chip M-series được thiết kế cùng nhau → hiệu năng tối ưu
• Darwin: Toàn bộ nền tảng macOS (kernel + drivers + tools) là mã nguồn mở! github.com/apple-oss-distributions/xnu

So Sánh Linux, Windows và macOS Kernel

So sánh System Call

Kernel Panic Là Gì?

Kernel Panic là trạng thái khi Kernel gặp lỗi nghiêm trọng không thể phục hồi — nó "hoảng loạn" và dừng toàn bộ hệ thống để ngăn thiệt hại thêm (như ghi dữ liệu hỏng vào ổ cứng).

Nguyên nhân phổ biến gây Kernel Panic

Boot Process — Quá Trình Khởi Động Chi Tiết

12.1 So sánh 3 quy trình boot

12.2 Vai trò của init/systemd

systemd (Linux) hay launchd (macOS) là tiến trình đầu tiên (PID 1) do Kernel khởi động. Nó là "cha" của mọi tiến trình khác trong hệ thống. Nếu PID 1 chết → Kernel Panic ngay lập tức.

# Xem tiến trình PID 1 trên Linux
ps -p 1 -o comm=
# Output: systemd (hoặc init)

# Xem cây tiến trình
pstree -p 1
# Output: systemd(1)─┬─NetworkManager(845)
#                    ├─cron(902)
#                    ├─nginx(1234)───nginx(1235)
#                    └─...

Kernel Module (LKM — Loadable Kernel Module)

13.1 Module là gì?

Kernel Module là một đoạn code có thể được nạp vào hoặc tháo khỏi kernel đang chạy — không cần reboot. Đây là cách Linux mở rộng chức năng kernel một cách linh hoạt (driver, filesystem mới, firewall rule...).

13.2 Code: Viết một Kernel Module đơn giản

/*
 * hello.c — Kernel Module đơn giản nhất
 * Biên dịch: make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
 * Nạp:      sudo insmod hello.ko
 * Tháo:     sudo rmmod hello
 * Xem log:  dmesg | tail
 */
#include <linux/module.h>   // Tất cả module đều cần
#include <linux/kernel.h>   // Cho KERN_INFO, printk()
#include <linux/init.h>     // Cho __init, __exit

// Hàm chạy khi module được nạp (insmod/modprobe)
static int __init hello_init(void) {
    printk(KERN_INFO "🎉 Hello Kernel! Module đã được nạp.\n");
    return 0; // 0 = thành công
}

// Hàm chạy khi module bị tháo (rmmod)
static void __exit hello_exit(void) {
    printk(KERN_INFO "👋 Tạm biệt Kernel! Module đã được tháo.\n");
}

// Đăng ký hàm init và exit
module_init(hello_init);
module_exit(hello_exit);

// Metadata (tùy chọn nhưng nên có)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bạn");
MODULE_DESCRIPTION("Module Kernel đầu tiên");
MODULE_VERSION("1.0");

13.3 Các lệnh quản lý module

# Liệt kê tất cả module đang nạp
lsmod

# Xem thông tin chi tiết về một module
modinfo ext4

# Nạp module (tự động resolve dependency)
sudo modprobe nvidia

# Gỡ module
sudo rmmod nvidia

# Xem module phụ thuộc
modprobe -D nvidia

# Kiểm tra xem module đã được nạp chưa
lsmod | grep nvidia

Kernel và Driver — Mối Quan Hệ Sống Còn

14.1 Driver chạy ở đâu?

Tùy vào kiến trúc kernel:

• Monolithic (Linux): Driver chạy trong Kernel Space — hiệu năng cao nhất nhưng nếu driver lỗi → kernel panic
• Microkernel (QNX, seL4): Driver chạy trong User Space — an toàn hơn nhưng chậm hơn (phải IPC qua lại)
• Hybrid (Windows, macOS): Một số driver trong Kernel Space (GPU, storage), một số trong User Space (máy in, USB device)

14.2 Driver có thể làm treo máy không?

CÓ! Đây là nguyên nhân #1 gây BSOD/Kernel Panic. Trên Windows, ~70% BSOD là do driver bên thứ ba (đặc biệt là GPU, network, antivirus). Trên Linux, driver NVIDIA là "kẻ thù số 1" của sự ổn định — chính Linus Torvalds đã nổi tiếng với câu nói "NVIDIA, fuck you!" vì họ không hỗ trợ Linux tốt trong nhiều năm.

14.3 Driver ký số (Code Signing)

Để ngăn malware giả làm driver:

• Windows: Bắt buộc driver phải được Microsoft ký số (từ Windows 10 version 1607)
• macOS: Driver (kext/System Extension) phải được Apple notarize
• Linux: Secure Boot yêu cầu kernel module phải được ký, nhưng có thể tắt

14.4 Driver độc hại — Rootkit

Rootkit là loại malware nguy hiểm nhất — nó ẩn mình trong kernel qua một driver giả mạo. Vì chạy ở Ring 0, rootkit có thể:

• Ẩn process, file, network connection khỏi antivirus
• Ghi lại mọi phím bấm (keylogger kernel-level)
• Đọc mọi dữ liệu trong RAM
• Vô hiệu hóa antivirus từ bên trong kernel

Kernel và Docker — Container Không Phải Máy Ảo

15.1 Container hoạt động như thế nào?

15.2 Namespaces — Cô lập tài nguyên

Linux Kernel cung cấp 8 loại Namespace để cô lập container:

15.3 Cgroups — Giới hạn tài nguyên

# Giới hạn container chỉ dùng tối đa 512MB RAM và 0.5 CPU
docker run -d \
  --memory="512m" \
  --cpus="0.5" \
  --name my-app \
  nginx

# Kiểm tra cgroup của container
cat /sys/fs/cgroup/memory/docker/<container-id>/memory.limit_in_bytes

Kernel và Virtual Machine (Máy Ảo)

16.1 Hypervisor — Người giám sát máy ảo

16.2 KVM — Kernel-based Virtual Machine

KVM biến Linux Kernel thành một Type 1 Hypervisor. KVM là một kernel module (kvm.ko + kvm-intel.ko hoặc kvm-amd.ko). Khi bạn nạp module KVM, Linux Kernel có khả năng chạy máy ảo trực tiếp với hiệu năng gần như native (nhờ CPU hỗ trợ ảo hóa: Intel VT-x / AMD-V).

# Kiểm tra CPU có hỗ trợ ảo hóa không
grep -E '(vmx|svm)' /proc/cpuinfo
# vmx = Intel VT-x
# svm = AMD-V

# Nạp module KVM
sudo modprobe kvm
sudo modprobe kvm-intel  # hoặc kvm-amd

# Kiểm tra KVM đã sẵn sàng
ls -l /dev/kvm

# Tạo máy ảo với QEMU + KVM
qemu-system-x86_64 -enable-kvm -m 4G -cdrom ubuntu.iso

Vì Sao Hacker Thích Khai Thác Kernel?

Kernel chạy ở Ring 0 — cấp quyền cao nhất. Nếu hacker chiếm được quyền thực thi trong kernel, họ sở hữu toàn bộ máy tính, vượt qua mọi cơ chế bảo mật.

17.1 Các kỹ thuật tấn công Kernel

17.2 Privilege Escalation — Ví dụ thực tế

Vì Sao Kernel Cực Kỳ Quan Trọng?

18.1 Nếu Kernel lỗi — Thảm họa!

18.2 Tại sao viết Kernel khó?

• Không có ai "dọn dẹp" cho bạn — Kernel tự quản lý bộ nhớ, không có garbage collector
• Không thể dùng thư viện chuẩn — Không có printf(), không có malloc() trong kernel (phải dùng kmalloc, printk)
• Debug cực kỳ khó — Bug kernel = crash toàn bộ máy, không có stack trace đẹp như ứng dụng
• Concurrency khắc nghiệt — Hàng nghìn tiến trình chạy cùng lúc, phải dùng spinlock, mutex, RCU
• Một lỗi nhỏ = thảm họa lớn — NULL pointer dereference trong kernel = kernel panic, không phải "segfault" nhẹ nhàng
• Phải hỗ trợ mọi phần cứng — Từ siêu máy tính đến đồng hồ thông minh

Những Hiểu Lầm Phổ Biến Về Kernel

19.1 Linux = Kernel?

19.2 Ubuntu có phải Kernel?

19.3 Windows có Kernel không?

19.4 macOS dùng Linux Kernel không?

19.5 Android Kernel là gì?

Các hiểu lầm khác

Hỏi Đáp — 50+ Câu Hỏi Thường Gặp

Từ Điển Thuật Ngữ — 150+ Thuật Ngữ Kernel & Hệ Điều Hành

ACPI

Advanced Configuration and Power Interface — chuẩn quản lý năng lượng và cấu hình thiết bị, kernel dùng để điều khiển sleep, hibernate, CPU frequency.

Address Space

Không gian địa chỉ — tập hợp các địa chỉ bộ nhớ mà một process có thể truy cập. Kernel tạo không gian địa chỉ ảo riêng cho từng process.

APFS

Apple File System — filesystem mặc định của macOS/iOS, tối ưu cho SSD, hỗ trợ snapshot, clone, mã hóa, space sharing.

ASLR

Address Space Layout Randomization — kỹ thuật bảo mật: ngẫu nhiên hóa địa chỉ bộ nhớ để hacker khó đoán vị trí code/data.

BIOS

Basic Input/Output System — firmware cũ cho bo mạch chủ, khởi tạo phần cứng và nạp bootloader. Đang bị thay thế bởi UEFI.

Block Device

Thiết bị lưu trữ truy cập theo khối (block) — SSD, HDD. Kernel dùng block I/O layer để đọc/ghi các sector.

Bootloader

Chương trình nhỏ nạp kernel vào RAM khi khởi động: GRUB, systemd-boot, Windows Boot Manager, boot.efi (macOS).

BPF / eBPF

Berkeley Packet Filter / Extended BPF — công nghệ chạy code an toàn trong kernel, dùng cho network filtering, observability, security.

BTRFS

B-Tree File System — filesystem Linux hiện đại với snapshot, nén, RAID, checksum, copy-on-write.

Buffer Overflow

Lỗi bảo mật khi dữ liệu ghi vượt quá kích thước buffer, ghi đè lên vùng nhớ lân cận — có thể dẫn đến thực thi mã độc trong kernel.

Caches

Bộ nhớ đệm — kernel cache dữ liệu đọc từ ổ cứng vào RAM để tăng tốc lần đọc sau (page cache, inode cache, dentry cache).

Cgroups

Control Groups — cơ chế của Linux Kernel để giới hạn, theo dõi, và cô lập tài nguyên (CPU, RAM, I/O) cho nhóm process. Nền tảng của Docker.

Character Device

Thiết bị truy cập theo dòng ký tự — bàn phím, chuột, serial port. Kernel dùng character device driver.

CFS

Completely Fair Scheduler — scheduler mặc định của Linux từ 2.6.23, dùng Red-Black Tree để đảm bảo công bằng giữa các process.

Context Switch

Hành động lưu trạng thái process hiện tại và nạp trạng thái process mới khi CPU chuyển đổi giữa các process/thread.

Core Dump

File chứa toàn bộ bộ nhớ của process khi crash, dùng để debug. Thường bị vô hiệu hóa mặc định vì lý do bảo mật.

Daemon

Process nền chạy liên tục trong User Space, thường khởi động bởi init/systemd. Ví dụ: sshd, httpd, cron.

DMA

Direct Memory Access — kỹ thuật cho phép thiết bị đọc/ghi trực tiếp vào RAM không qua CPU. Kernel thiết lập DMA channel.

Dentry Cache

Directory Entry Cache — kernel cache cấu trúc thư mục để tăng tốc tìm kiếm file.

Device Tree

Cấu trúc dữ liệu mô tả phần cứng cho kernel (dùng trong embedded Linux, ARM). Thay thế cho "hardcoded" hardware info.

Driver

Phần mềm giúp kernel giao tiếp với thiết bị phần cứng cụ thể. Có thể nằm trong kernel space hoặc user space.

EEPROM

Electrically Erasable Programmable Read-Only Memory — bộ nhớ không bay hơi, lưu firmware/BIOS.

ELe

Executable and Linkable Format — định dạng file thực thi trên Linux/Unix. Kernel đọc ELF header để nạp chương trình.

EXT4

Fourth Extended File System — filesystem mặc định của hầu hết Linux distribution. Journaling, ổn định, hỗ trợ file đến 16TB.

FAT32

File Allocation Table 32-bit — filesystem đơn giản, tương thích cao, nhưng giới hạn file 4GB.

File Descriptor

Số nguyên kernel cấp cho process để tham chiếu đến file đang mở, socket, pipe, hoặc thiết bị.

Firmware

Phần mềm nhúng trong phần cứng, chạy trước OS. BIOS/UEFI là firmware của bo mạch chủ.

Fork

System Call tạo process mới bằng cách sao chép process hiện tại. Process con là bản sao của process cha.

FPU

Floating-Point Unit — đơn vị xử lý số thực trong CPU. Kernel lưu/khôi phục trạng thái FPU khi context switch.

GPT

GUID Partition Table — chuẩn phân vùng ổ cứng hiện đại, thay thế MBR. Hỗ trợ ổ >2TB và 128 phân vùng.

GRUB

Grand Unified Bootloader — bootloader phổ biến nhất cho Linux, hỗ trợ multi-boot, menu chọn OS.

HAL

Hardware Abstraction Layer — tầng trừu tượng hóa phần cứng trong Windows NT, giúp kernel không phụ thuộc vào phần cứng cụ thể.

Heap

Vùng nhớ động trong process, dùng cho dữ liệu được cấp phát lúc chạy (malloc/new). Kernel quản lý heap qua brk() và mmap().

HFS+

Hierarchical File System Plus — filesystem cũ của macOS, tiền nhiệm của APFS. Còn gọi là Mac OS Extended.

Hypervisor

Phần mềm tạo và quản lý máy ảo. Type 1 chạy trực tiếp trên HW (KVM, ESXi), Type 2 chạy trong OS (VirtualBox).

I/O Scheduler

Thành phần kernel quyết định thứ tự đọc/ghi sector trên ổ cứng để tối ưu hiệu năng. Linux có: mq-deadline, kyber, BFQ.

init

Tiến trình đầu tiên (PID 1) được kernel khởi động. Trên Linux hiện đại, init thường là systemd.

initramfs

Initial RAM Filesystem — filesystem tạm trong RAM chứa driver và script cần để mount filesystem thật khi boot.

inode

Index Node — cấu trúc dữ liệu lưu metadata của file (kích thước, quyền, vị trí trên ổ) trong filesystem Unix/Linux.

Interrupt (Ngắt)

Tín hiệu từ phần cứng (hoặc phần mềm) yêu cầu CPU dừng việc hiện tại để xử lý sự kiện khẩn cấp. Kernel có interrupt handler cho từng loại ngắt.

IOMMU

Input/Output Memory Management Unit — MMU cho thiết bị I/O, bảo vệ RAM khỏi bị thiết bị DMA đọc/ghi trái phép.

IPC

Inter-Process Communication — cơ chế để các process giao tiếp: pipe, socket, shared memory, message queue, signal.

IRQ

Interrupt Request — đường dẫn phần cứng để thiết bị gửi ngắt đến CPU. Kernel quản lý bảng IRQ và phân phối cho driver.

Journaling

Kỹ thuật filesystem ghi nhật ký thay đổi trước khi thực sự ghi dữ liệu. Nếu mất điện giữa chừng, journal giúp khôi phục trạng thái nhất quán.

Kernel Mode

Chế độ CPU có toàn quyền truy cập phần cứng (Ring 0 trên x86). Kernel chạy ở chế độ này.

Kernel Panic

Trạng thái kernel dừng toàn bộ hệ thống vì gặp lỗi không thể phục hồi. Linux/macOS gọi là Kernel Panic, Windows gọi là BSOD.

Kernel Space

Vùng bộ nhớ dành riêng cho kernel, không thể truy cập từ User Space. Chạy ở Ring 0.

Kernel Thread

Thread chạy trong Kernel Space cho các tác vụ nền: kswapd (swap), kworker (workqueue), ksoftirqd (softirq).

KPTI

Kernel Page Table Isolation — bản vá bảo mật chống lại lỗ hổng Meltdown, cô lập page table của kernel và user space.

KVM

Kernel-based Virtual Machine — module biến Linux Kernel thành Type 1 Hypervisor.

LKM

Loadable Kernel Module — file .ko chứa code có thể nạp/tháo vào kernel đang chạy.

LTS Kernel

Long-Term Support Kernel — phiên bản Linux Kernel được hỗ trợ dài hạn (2-6 năm), nhận backport bản vá bảo mật.

MBR

Master Boot Record — sector đầu tiên của ổ cứng (512 byte), chứa bootloader và bảng phân vùng (cũ, giới hạn 2TB).

Memory Leak

Rò rỉ bộ nhớ — process cấp RAM nhưng không trả lại, RAM bị "mất tích" dần. Trong kernel, memory leak có thể dẫn đến panic.

Memory Mapping

Ánh xạ file hoặc thiết bị vào không gian địa chỉ của process (mmap()). Kernel quản lý page table để thực hiện ánh xạ này.

MMU

Memory Management Unit — phần cứng trong CPU dịch địa chỉ ảo sang địa chỉ vật lý, kiểm tra quyền truy cập. Kernel lập trình MMU qua page table.

Mount

Hành động gắn filesystem vào cây thư mục. Kernel quản lý mount point và VFS layer.

Mutex

Mutual Exclusion — cơ chế khóa trong kernel để đảm bảo chỉ một thread truy cập tài nguyên tại một thời điểm.

Namespace

Cơ chế của Linux Kernel để cô lập tài nguyên cho process — nền tảng của container (Docker, LXC). Có 8 loại namespace.

NTFS

New Technology File System — filesystem chính của Windows. Hỗ trợ journaling, ACL, nén, mã hóa (EFS), symbolic link.

OOM Killer

Out-Of-Memory Killer — cơ chế của Linux Kernel tự động chọn và giết process khi RAM và swap đều cạn kiệt.

Page Cache

Kernel cache nội dung file trong RAM. Khi ứng dụng đọc file, kernel lưu bản sao trong page cache để lần đọc sau nhanh hơn.

Page Fault

Ngoại lệ xảy ra khi process truy cập địa chỉ ảo chưa được ánh xạ vào RAM vật lý. Kernel xử lý bằng cách nạp trang từ swap hoặc cấp trang mới.

Page Table

Bảng dữ liệu kernel dùng để ánh xạ địa chỉ ảo → địa chỉ vật lý. Mỗi process có page table riêng. MMU đọc page table để dịch địa chỉ.

Paging

Cơ chế quản lý bộ nhớ: RAM được chia thành các "trang" (page, thường 4KB). Kernel có thể đẩy trang ít dùng ra swap để giải phóng RAM.

PID

Process IDentifier — số định danh duy nhất kernel cấp cho mỗi process. PID 1 luôn là init/systemd.

Pipe

Kênh giao tiếp một chiều giữa hai process trong Unix/Linux. Kernel quản lý buffer của pipe. Shell pipeline (ls | grep txt) dùng pipe.

Preemption

Khả năng kernel tự ngắt tác vụ hiện tại để chạy process quan trọng hơn. Linux hỗ trợ kernel preemption từ phiên bản 2.6.

Process

Một chương trình đang chạy, bao gồm: code, data, heap, stack, file descriptor, page table. Kernel quản lý process qua task_struct.

Race Condition

Lỗi xảy ra khi hai process/thread cùng truy cập tài nguyên chia sẻ mà không đồng bộ — kết quả phụ thuộc vào thứ tự thực thi. Nguyên nhân phổ biến của kernel bug.

RCU

Read-Copy-Update — cơ chế đồng bộ trong Linux Kernel cho phép nhiều reader đọc cùng lúc mà không cần khóa, writer tạo bản sao để cập nhật.

Root

Siêu người dùng (superuser) trong Unix/Linux — UID 0, có toàn quyền. Kernel kiểm tra UID để phân quyền thực thi system call.

Rootkit

Malware ẩn trong kernel (Ring 0), có thể che giấu process, file, network connection khỏi antivirus.

Scheduler

Bộ điều phối CPU — thành phần kernel quyết định process nào được chạy tiếp theo. Linux dùng CFS (Completely Fair Scheduler).

Secure Boot

Công nghệ UEFI chỉ cho phép boot kernel/module đã được ký số, ngăn malware khởi động cùng hệ thống.

SELinux

Security-Enhanced Linux — hệ thống Mandatory Access Control (MAC) cho Linux Kernel, do NSA phát triển.

Semaphore

Cơ chế đồng bộ cổ điển: biến đếm kiểm soát số lượng thread được truy cập tài nguyên. Kernel cung cấp semaphore API.

Shell

Giao diện dòng lệnh (bash, zsh, PowerShell) — chạy trong User Space, giao tiếp với kernel qua system call. Shell không phải là kernel.

Signal

Cơ chế kernel thông báo sự kiện cho process: SIGTERM (yêu cầu tắt), SIGKILL (buộc tắt), SIGSEGV (segfault), SIGINT (Ctrl+C).

Slab Allocator

Cơ chế cấp phát bộ nhớ trong kernel, tối ưu cho các đối tượng nhỏ và thường dùng. Linux dùng SLUB (Unqueued Slab Allocator).

Socket

Điểm cuối giao tiếp mạng — kernel quản lý socket, buffer, và protocol state machine (TCP state: LISTEN, ESTABLISHED, CLOSE_WAIT...).

Spinlock

Khóa quay vòng — thread "quay" (busy-wait) cho đến khi khóa được mở. Dùng trong kernel khi thời gian chờ rất ngắn và không thể sleep.

Stack

Vùng nhớ LIFO dùng cho biến cục bộ và lời gọi hàm. Mỗi thread có stack riêng. Kernel thread dùng stack nhỏ (thường 8-16KB).

Swap

Không gian trên ổ cứng dùng làm "RAM mở rộng". Kernel đẩy trang RAM ít dùng ra swap (swap out) và đọc lại khi cần (swap in).

Symlink

Symbolic Link — file đặc biệt trỏ đến file/thư mục khác. Kernel phân giải symlink khi mở file.

System Call

Giao diện duy nhất để ứng dụng yêu cầu kernel thực hiện tác vụ: open(), read(), write(), fork(), exec(), socket()...

systemd

Hệ thống init hiện đại cho Linux (PID 1), quản lý service, socket, timer, mount, login. Gây tranh cãi nhưng phổ biến nhất hiện nay.

Task

Thuật ngữ kernel dùng cho cả process và thread. Trong Linux Kernel, mỗi task có một task_struct.

TCP

Transmission Control Protocol — giao thức mạng tin cậy, kernel quản lý TCP state machine (handshake, retransmit, flow control, congestion control).

Thread

Đơn vị thực thi nhỏ nhất — nhiều thread có thể chia sẻ chung không gian địa chỉ trong một process. Kernel schedule từng thread riêng biệt.

Time Slice

Khoảng thời gian CPU cấp cho một process/thread trước khi chuyển sang process khác. Thường 10-100ms.

TLB

Translation Lookaside Buffer — cache nhỏ trong CPU lưu kết quả dịch địa chỉ gần đây, tăng tốc MMU. Kernel phải flush TLB khi thay đổi page table.

Trap

Ngoại lệ phần mềm — process chủ động gây ra để chuyển sang kernel mode (system call, breakpoint). Khác với interrupt (ngắt từ phần cứng).

UDP

User Datagram Protocol — giao thức mạng không kết nối, không đảm bảo, nhưng nhanh. Kernel xử lý UDP đơn giản hơn TCP.

UEFI

Unified Extensible Firmware Interface — firmware hiện đại thay thế BIOS. Hỗ trợ GPT, Secure Boot, boot từ ổ >2TB, giao diện đồ họa.

User Mode

Chế độ CPU hạn chế (Ring 3 trên x86). Mọi ứng dụng chạy ở chế độ này. Không thể truy cập trực tiếp phần cứng.

User Space

Tất cả phần mềm chạy ngoài kernel — ứng dụng, thư viện, shell, desktop environment. Chạy ở Ring 3.

VFS

Virtual File System / Virtual File Switch — tầng trừu tượng của Linux Kernel cung cấp giao diện chung cho mọi filesystem.

Virtual Memory

Kỹ thuật tạo không gian địa chỉ ảo cho mỗi process, cô lập chúng với nhau và với RAM vật lý. Kernel + MMU cùng thực hiện.

Vmlinuz

Tên file Linux Kernel đã nén (gzip/LZ4). "z" = compressed. Nằm trong /boot/.

Workqueue

Cơ chế kernel trì hoãn công việc để chạy sau trong context của kernel thread. Dùng khi driver cần làm việc không gấp.

Writeback

Kernel trì hoãn ghi dữ liệu xuống ổ cứng để tối ưu hiệu năng. Dữ liệu được giữ trong page cache, định kỳ kernel flush xuống ổ.

XNU

X is Not Unix — kernel của macOS/iOS/iPadOS, kết hợp Mach microkernel + BSD + IOKit.

Zero-day

Lỗ hổng bảo mật chưa được công bố/công khai — không có bản vá. Zero-day kernel exploit cực kỳ nguy hiểm và có giá trị cao.

ZFS

Zettabyte File System — filesystem 128-bit với checksum, dedup, nén, snapshot, "không thể hỏng dữ liệu" nhờ copy-on-write và Merkle tree.

Kết Luận — "Trái Tim Của Hệ Điều Hành"

22.1 Tổng kết hành trình

Qua 22 chương, chúng ta đã đi từ những khái niệm cơ bản nhất — "Kernel là gì?" — đến những kiến thức chuyên sâu về scheduler, memory management, system call, kiến trúc kernel, và so sánh 3 kernel lớn nhất thế giới.

22.2 Những điều quan trọng nhất cần nhớ

1. Kernel là chương trình trung tâm của mọi hệ điều hành — nó quản lý CPU, RAM, ổ cứng, thiết bị ngoại vi, mạng, và bảo mật
2. Không có Kernel = Không có máy tính — ứng dụng không thể chạy trực tiếp trên phần cứng một cách an toàn
3. Kernel chạy ở Ring 0 với toàn quyền — đây là lý do nó vừa mạnh mẽ vừa nguy hiểm nếu có lỗi
4. Mỗi hệ điều hành có kernel riêng: Linux → Linux Kernel, Windows → NT Kernel, macOS → XNU
5. System Call là cầu nối duy nhất giữa ứng dụng và kernel — mọi thứ đều phải qua cánh cổng này
6. Kernel KHÔNG PHẢI là toàn bộ hệ điều hành — nó là trái tim, nhưng cơ thể còn có shell, GUI, ứng dụng
7. Viết kernel cực kỳ khó — một lỗi nhỏ có thể crash toàn bộ hệ thống
8. Linux Kernel là dự án phần mềm lớn nhất thế giới — hơn 30 triệu dòng code, 15,000+ contributors

22.3 Tương lai của Kernel

• 🔒 Rust trong kernel — loại bỏ lỗi memory-safety, nguyên nhân của ~70% lỗ hổng bảo mật
• 🧠 AI-assisted scheduling — dùng machine learning để dự đoán và tối ưu scheduler
• 🔗 eBPF mở rộng — kernel ngày càng "lập trình được" mà không cần biên dịch lại
• 📱 Heterogeneous computing — quản lý CPU + GPU + NPU + FPGA trong cùng một kernel
• ⏱️ Real-time Linux trong mainline — Linux trở thành RTOS chính thức
• 🔐 Formal verification — chứng minh toán học rằng kernel không có bug (như seL4 đã làm)