The Linux Programming Interface Bản đồ toàn cuốn · Whole-book map

Bản đồ toàn cuốn · 26 chương · 6 module Whole-book map · 26 chapters · 6 modules

Hai mươi sáu chương, một giao diện duy nhất giữa chương trình và nhân Linux Cả cuốn sách dạy một việc: chương trình nói chuyện với hệ điều hành thế nào Twenty-six chapters, one single interface between a program and the Linux kernel

Đọc rời rạc, The Linux Programming Interface trông như một rừng lời gọi hệ thống: mở tệp, cấp bộ nhớ, tạo tiến trình, bắt tín hiệu, mở socket. Đọc như một lập luận thì nó là một giao diện duy nhất — bề mặt mà nhân Linux chìa ra cho mọi chương trình — được mở ra từng mảng một.1 Trang này bày sáu module đồng hành ra cùng lúc để thấy cả bề mặt đó, và gọi tên những sợi chỉ chạy xuyên nhiều chương mà lối đọc tuần tự dễ bỏ sót.

Cuốn sách rất dày, nhưng tất cả xoay quanh một câu hỏi: khi chương trình của bạn cần tệp, bộ nhớ, hay mạng, nó “xin” hệ điều hành như thế nào? Mỗi chương mở một cái cửa trong bức tường giữa bạn và nhân Linux. Trang này vẽ cả bức tường ra một lần. Nhớ nhé: nhìn cả bức tường trước, rồi hãy mở từng cái cửa.

Read piecemeal, The Linux Programming Interface looks like a jungle of system calls: open a file, allocate memory, create a process, catch a signal, open a socket. Read as an argument, it is one single interface — the surface the Linux kernel exposes to every program — opened one region at a time.1 This page lays all six companion modules out at once so that surface becomes visible, and names the threads running across chapters that sequential reading tends to miss.

Lập luận này không phải suy diễn: tác giả Michael Kerrisk là người duy trì dự án Linux man-pages, và cuốn sách được dựng quanh đúng các lời gọi hệ thống mà ông ghi chép trong các trang hướng dẫn đó.4 Vì vậy “giao diện lập trình” trong nhan đề không phải ẩn dụ — nó là tập các syscall và hàm thư viện có thật, và mỗi chương mở ra một nhóm trong tập đó.1This argument is not a guess: the author, Michael Kerrisk, maintains the Linux man-pages project, and the book is built around exactly the system calls he documents there.4 So the "programming interface" in the title is not a metaphor — it is a real set of syscalls and library functions, and each chapter opens one group within that set.1

Luận đề của bản đồ: mọi chương đồng hành hoặc (a) trình bày một tài nguyên hệ thống — tệp, bộ nhớ, tiến trình, tín hiệu, socket — qua các lời gọi thao tác nó, hoặc (b) chỉ cách nhiều chương trình chia sẻ và đồng bộ tài nguyên đó, hoặc (c) đưa chương trình ra ngoài một máy. Biết một chương thuộc loại nào là đã biết phải đọc nó thế nào.

Ý chính: mỗi chương làm một trong ba việc — giới thiệu một thứ của hệ thống (tệp, bộ nhớ, tiến trình…), chỉ cách chia sẻ thứ đó cho nhiều chương trình, hoặc cho chương trình nói chuyện với máy khác. Nhớ nhé: ba kiểu chương, thế thôi.

The map's thesis: every companion chapter either (a) presents a system resource — files, memory, processes, signals, sockets — through the calls that manipulate it, (b) shows how many programs share and synchronize that resource, or (c) takes the program beyond a single machine. Knowing which kind a chapter is tells you how to read it.

Lập luận · 00 The argument · 00

Cuốn sách không dạy hàng trăm lời gọi — nó dạy một giao diện, từng mảng một Một bề mặt duy nhất, mở ra từng phần The book does not teach hundreds of calls — it teaches one interface, region by region

Kerrisk viết cho lập trình viên muốn hiểu chương trình tương tác với hệ điều hành ra sao trên Linux và UNIX — không phải học thuộc từng hàm, mà nắm được các tài nguyên mà nhân quản lý và cách yêu cầu chúng.1 Từ đó, cả cuốn sách là một tour có trật tự qua bề mặt syscall: mỗi module mở ra một nhóm tài nguyên, và mỗi nhóm dựa lên nhóm trước.1

Tác giả không muốn bạn thuộc lòng vài trăm hàm. Ông muốn bạn hiểu hệ điều hành giữ những gì — tệp, bộ nhớ, tiến trình, mạng — và cách xin chúng. Rồi ông dẫn bạn đi một vòng, mỗi lần mở một nhóm. Nhớ nhé: hiểu nhóm tài nguyên quan trọng hơn thuộc tên hàm.

Kerrisk writes for programmers who want to understand how a program interacts with the operating system on Linux and UNIX — not to memorise each function, but to grasp the resources the kernel manages and how to request them.1 From there, the whole book is an ordered tour of the syscall surface: each module opens one group of resources, and each group builds on the one before.1

Ba kiểu chương. (a) Trình bày một tài nguyên — Module 1–3 giới thiệu tệp, bộ nhớ, tiến trình và các lời gọi thao tác chúng. (b) Chia sẻ và đồng bộ — Module 4–5 cho thấy nhiều dòng việc và nhiều chương trình cùng dùng một tài nguyên mà không giẫm lên nhau. (c) Ra ngoài một máy — Module 6 đưa chương trình thành dịch vụ nền và kết nối qua mạng.

Nói đơn giản. Có chương giới thiệu một thứ của hệ thống, có chương dạy cách chia thứ đó cho nhiều việc, có chương cho chương trình ra mạng. Nhớ nhé: biết chương thuộc loại nào thì biết nên chờ đợi điều gì.

Three kinds of chapter. (a) Presenting a resource — Modules 1–3 introduce files, memory and processes and the calls that work on them. (b) Sharing and synchronizing — Modules 4–5 show many strands of work and many programs using one resource without colliding. (c) Beyond one machine — Module 6 turns the program into a background service and connects it over the network.

khái niệm & syscall (M1) → mô tả tệp + File I/O (M2) → tiến trình + bộ nhớ (M3) → tín hiệu + luồng (M4) → IPC (M5) → socket + mạng (M6)

học luật chơi → làm việc với tệp → tạo tiến trình → chạy song song → chia dữ liệu → ra mạng

concepts & syscalls (M1) → file descriptors + file I/O (M2) → processes + memory (M3) → signals + threads (M4) → IPC (M5) → sockets + networking (M6)

Mô tả tệp (file descriptor) mở ở Module 2 là bản lề của cả ngăn xếp: pipe, FIFO, socket và cả eventfd về sau đều là một mô tả tệp, nên các lời gọi read/write học một lần dùng được ở khắp nơi.5The file descriptor opened in Module 2 is the hinge of the whole stack: pipes, FIFOs, sockets and later even eventfd are all a file descriptor, so the read/write calls learned once work everywhere.5

Cách dùng trang này. Sáu module bên dưới bám theo nhóm chủ đề của chính cuốn sách, nhưng đọc nó như một lập luận: mỗi module nói rõ nó thêm gì vào cái trước. Mỗi thẻ chương mở thẳng vào trang đồng hành của chương đó. Nếu bạn đang truy một khái niệm cụ thể, mục Sợi chỉ xuyên suốt chỉ ra nó xuất hiện ở những chương nào.

Bấm vào tên chương là mở cả chương. Nếu bạn muốn tìm một ý, kéo xuống mục “Sợi chỉ xuyên suốt” — ở đó ghi ý đó nằm ở những chương nào. Nhớ nhé: không bắt buộc phải đọc theo số chương.

How to use this page. The six modules below follow the book's own topic groups, but read it as an argument: each says what it adds to the one before. Every chapter card opens that chapter's companion page directly. If you are hunting a specific idea, the through-lines section names every chapter it appears in.

Module 1 · Vỡ lòng · Chương 1–3 Module 1 · Primer · Chapters 1–3

Vỡ lòng: khái niệm nền tảng và luật chơi của lập trình hệ thống Những điều phải biết trước khi gọi bất kỳ hàm nào Primer: fundamental concepts and the rules of system programming

Ba chương mở đầu đặt nền chung cho mọi thứ sau đó: vì sao Linux và UNIX trông như hôm nay (lịch sử và các chuẩn POSIX), những khái niệm cốt lõi — tệp, tiến trình, người dùng, nhân — và các quy ước lập trình hệ thống như cách gọi syscall, kiểm lỗi, và kiểu dữ liệu chuẩn.1 Chưa có tài nguyên nào được mở sâu; đây là từ vựng và thói quen để đọc hai mươi ba chương còn lại.

Trước khi học mở tệp hay tạo tiến trình, bạn cần biết vài điều chung: Linux từ đâu ra, “tệp” và “tiến trình” nghĩa là gì, và cách gọi một hàm hệ thống cho đúng rồi kiểm xem nó có lỗi không. Nhớ nhé: đây là phần làm quen, đọc nhanh nhưng đừng bỏ.

The opening three chapters set the common ground for everything that follows: why Linux and UNIX look the way they do (history and the POSIX standards), the core concepts — files, processes, users, the kernel — and system-programming conventions such as how to make a syscall, check for errors, and use the standard data types.1 No resource is opened in depth yet; this is the vocabulary and the habits for reading the other twenty-three chapters.

Điều module này thêm vào: một ngôn ngữ chung. Sau Module 1, bạn biết một syscall là gì, vì sao phải luôn kiểm giá trị trả về, và các chuẩn nào định hình giao diện — nền để mọi chương sau xây lên.1

Nói đơn giản. Module này cho bạn bộ từ vựng và thói quen kiểm lỗi. Nhớ nhé: luôn kiểm xem hàm hệ thống có báo lỗi không.

What this module adds: a common language. After Module 1 you know what a syscall is, why you must always check return values, and which standards shape the interface — the ground every later chapter builds on.1

lịch sử & chuẩn POSIX (Ch 1) → khái niệm nền: tệp · tiến trình · người dùng · nhân (Ch 2) → quy ước gọi syscall & kiểm lỗi (Ch 3)

Linux từ đâu ra → các khái niệm cơ bản → cách gọi hàm hệ thống cho đúng

history & POSIX standards (Ch 1) → core concepts: files · processes · users · kernel (Ch 2) → syscall conventions & error checking (Ch 3)

  1. Chapter 1

    Lịch sử và chuẩn: vì sao UNIX và Linux là như vậy Linux ra đời thế nào, và vì sao có nhiều chuẩn History and standards: why UNIX and Linux are as they are

    Chương dựng bối cảnh: UNIX sinh ra ở Bell Labs, ngôn ngữ C, nhánh BSD và System V, rồi Linux; và vì sao các chuẩn như POSIX tồn tại để mã viết một lần chạy được trên nhiều hệ.1 Hiểu điều này giải thích vì sao nhiều hàm có biến thể và cờ tương thích.

    Chương này kể UNIX và Linux từ đâu tới, và vì sao người ta lập ra “chuẩn” để chương trình chạy được trên nhiều hệ khác nhau. Nhớ nhé: chuẩn là lời hứa để mã của bạn không bị kẹt vào một hệ duy nhất.

    The chapter sets the scene: UNIX born at Bell Labs, the C language, the BSD and System V branches, then Linux; and why standards such as POSIX exist so that code written once runs on many systems.1 Understanding this explains why many functions have variants and compatibility flags.

    Điểm nốiWhere it connects Các chuẩn nêu ở đây quay lại ở mọi chương sau dưới dạng ghi chú “hàm này thuộc POSIX hay chỉ của Linux”. The standards named here return in every later chapter as notes on whether a function is POSIX or Linux-specific.

  2. Chapter 2

    Khái niệm nền tảng: tệp, tiến trình, người dùng, nhân Những từ cốt lõi: tệp, tiến trình, người dùng Fundamental concepts: files, processes, users, the kernel

    Chương lướt nhanh qua toàn bộ các ý niệm lớn trước khi đi sâu: hệ thống tệp và thư mục, tiến trình và chương trình, người dùng và nhóm, cây thư mục, quyền, và vai trò của nhân.1 Nó chính là bản đồ thu nhỏ của cả cuốn sách, giống Chương 1 của nhiều sách hệ thống khác.

    Chương này giới thiệu nhanh mọi nhân vật chính: tệp, thư mục, tiến trình, người dùng, và cái “nhân” điều phối tất cả. Nhớ nhé: đọc chương này là có ngay cái khung để treo mọi chương sau vào.

    The chapter sweeps through all the big ideas before going deep: the filesystem and directories, processes and programs, users and groups, the directory tree, permissions, and the role of the kernel.1 It is a miniature map of the whole book.

    Điểm nốiWhere it connects Mỗi đoạn ở đây là một module sau được nén lại: tệp → Module 2, tiến trình → Module 3, người dùng và quyền → Chương 15. Each passage here is a later module compressed: files → Module 2, processes → Module 3, users and permissions → Chapter 15.

  3. Chapter 3

    Khái niệm lập trình hệ thống: gọi syscall và kiểm lỗi Cách gọi hàm hệ thống cho đúng, và bắt lỗi System programming concepts: making syscalls and checking errors

    Chương đặt các quy ước thực hành: lời gọi hệ thống là gì và chi phí của nó, hàm thư viện khác syscall ra sao, cách dùng biến errno để báo lỗi, các kiểu dữ liệu chuẩn (pid_t, size_t…), và tính khả chuyển.1

    Chương này dạy nếp làm việc: gọi hàm hệ thống thế nào, và luôn kiểm xem nó có lỗi không qua một biến tên errno. Nhớ nhé: bỏ qua kiểm lỗi là nguồn gốc của những bug khó tìm nhất.

    The chapter lays out the practical conventions: what a system call is and what it costs, how library functions differ from syscalls, using the errno variable to report errors, the standard data types (pid_t, size_t…), and portability.1

    Điểm nốiWhere it connects Thói quen kiểm errno học ở đây áp vào mọi lời gọi của hai mươi ba chương sau. The errno-checking habit learned here applies to every call in the next twenty-three chapters.

Module 2 · File I/O & hệ thống tệp · Chương 4, 5, 13, 14, 15, 18 Module 2 · File I/O & filesystems · Chapters 4, 5, 13, 14, 15, 18

File I/O và hệ thống tệp: mô hình I/O phổ quát là bản lề của cả cuốn sách Làm việc với tệp — nền mà mọi thứ khác dựa lên File I/O and filesystems: the universal I/O model is the book's hinge

Sáu chương này mở ra tài nguyên nền tảng nhất: tệp, qua mô hình I/O phổ quát — cùng bốn lời gọi open, read, write, close dùng được cho mọi loại tệp.5 Rồi chúng đi sâu: chi tiết thêm của File I/O, tầng đệm (buffering), cấu trúc hệ thống tệp, thuộc tính và quyền của tệp, và thư mục với liên kết.1

Phần này dạy làm việc với tệp — thứ đơn giản và quan trọng nhất. Chỉ cần bốn động tác: mở, đọc, ghi, đóng. Rồi đi sâu hơn: cách máy đệm dữ liệu cho nhanh, hệ thống tệp sắp xếp ra sao, và quyền của tệp. Nhớ nhé: học tệp một lần, dùng lại cho pipe, socket, và mọi thứ khác.

These six chapters open the most foundational resource: the file, through the universal I/O model — the same four calls open, read, write, close working for every kind of file.5 Then they go deep: further File I/O details, the buffering layer, filesystem structure, file attributes and permissions, and directories with links.1

Điều module này thêm vào: mô tả tệp — con số nhỏ mà cả cuốn sách xoay quanh. Một khi bạn biết đọc/ghi qua một mô tả tệp, bạn đã biết một nửa cách nói chuyện với pipe, FIFO và socket về sau.5

Nói đơn giản. Mở một tệp, bạn nhận một con số nhỏ gọi là “mô tả tệp”. Dùng con số đó để đọc và ghi. Nhớ nhé: con số nhỏ ấy sau này còn đại diện cho cả kết nối mạng.

What this module adds: the file descriptor — the small number the whole book revolves around. Once you can read and write through a descriptor, you already know half of how to talk to pipes, FIFOs and sockets later.5

open → mô tả tệp → read/write → close (Ch 4–5) · tầng đệm (Ch 13) · hệ thống tệp & mount (Ch 14) · quyền & stat (Ch 15) · thư mục & liên kết (Ch 18)

mở → đọc/ghi → đóng · đệm cho nhanh · hệ thống tệp · quyền · thư mục

open → file descriptor → read/write → close (Ch 4–5) · buffering (Ch 13) · filesystem & mount (Ch 14) · permissions & stat (Ch 15) · directories & links (Ch 18)

  1. Chapter 4

    File I/O: mô hình I/O phổ quát Mở, đọc, ghi, đóng — bốn động tác nền File I/O: the universal I/O model

    Chương trung tâm của module: bốn lời gọi open, read, write, close và ý niệm rằng chúng dùng được cho mọi loại tệp, không chỉ tệp thường.5 Đây là nơi khái niệm mô tả tệp ra đời.

    Chương này dạy bốn động tác cơ bản với tệp. Cái hay là cùng bốn động tác đó về sau dùng cho cả bàn phím, màn hình, và mạng. Nhớ nhé: học bốn động tác này là mở khoá gần như mọi chương sau.

    The module's central chapter: the four calls open, read, write, close and the idea that they work for every kind of file, not just regular files.5 This is where the file-descriptor concept is born.

    Điểm nốiWhere it connects Mô tả tệp mở ở đây chính là thứ pipe (Ch 44) và socket (Ch 56) dùng lại nguyên vẹn. The file descriptor opened here is exactly what pipes (Ch 44) and sockets (Ch 56) reuse unchanged.

  2. Chapter 5

    File I/O: chi tiết thêm, cờ và nguyên tử Những chi tiết quan trọng khi làm việc với tệp File I/O: further details, flags and atomicity

    Chương đào sâu phần còn lại của I/O: các cờ của open, thao tác nguyên tử, lseek, bảng mô tả tệp trong nhân, và lời gọi vạn năng fcntl.1 Đây là nơi hiểu vì sao chia sẻ mô tả tệp lại tinh tế.

    Chương này bổ sung những chi tiết cần khi làm việc với tệp cho đúng: nhảy tới vị trí nào, ghi mà không bị chen ngang, và cách nhân ghi nhớ tệp đang mở. Nhớ nhé: những chi tiết nhỏ này quyết định đúng–sai khi nhiều việc cùng ghi.

    The chapter digs into the rest of I/O: open flags, atomic operations, lseek, the kernel's file-descriptor tables, and the all-purpose fcntl call.1 This is where you learn why sharing a descriptor is subtle.

    Điểm nốiWhere it connects Cờ không chặn (O_NONBLOCK) giới thiệu ở đây là tâm điểm của các mô hình I/O thay thế ở Chương 63. The non-blocking flag (O_NONBLOCK) introduced here is the heart of the alternative I/O models in Chapter 63.

  3. Chapter 13

    Tầng đệm I/O: vì sao ghi không chạm đĩa ngay Vì sao dữ liệu ghi ra chưa xuống đĩa liền File I/O buffering: why a write doesn't hit the disk at once

    Chương tách ba tầng đệm: đệm của thư viện stdio, đệm của nhân (page cache), và cách ép dữ liệu xuống đĩa bằng fsync/fflush.1 Hiểu điều này giải thích vì sao dữ liệu có thể mất khi mất điện dù chương trình “đã ghi xong”.

    Khi bạn ghi, dữ liệu thường nằm tạm trong bộ đệm cho nhanh, chứ chưa xuống đĩa liền. Vì vậy có lúc cần ép nó xuống. Nhớ nhé: “ghi xong” chưa chắc là “đã lưu an toàn”.

    The chapter separates three buffering layers: the stdio library buffer, the kernel buffer (page cache), and forcing data to disk with fsync/fflush.1 This explains why data can be lost on a power cut even though the program "finished writing."

    Điểm nốiWhere it connects Cùng ý “tầng nhanh đệm cho tầng chậm” quay lại ở ánh xạ bộ nhớ (Ch 49), nơi tệp và bộ nhớ hoà làm một. The same "a fast layer buffering a slow one" idea returns in memory mappings (Ch 49), where file and memory become one.

  4. Chapter 14

    Hệ thống tệp: i-node, mount, và cây thư mục Đĩa được tổ chức thành hệ thống tệp ra sao File systems: i-nodes, mounting, and the directory tree

    Chương chuyển từ một tệp đơn lẻ sang cả kho tệp: cấu trúc một hệ thống tệp, i-node, các loại hệ thống tệp, và cách mount ghép chúng vào một cây thư mục duy nhất.1

    Chương này cho thấy đĩa được sắp xếp thành “hệ thống tệp”, và mọi ổ đĩa được gắn vào một cây thư mục chung bắt đầu từ dấu gạch chéo. Nhớ nhé: mọi tệp trên máy đều nằm trên cùng một cái cây.

    The chapter moves from a single file to the whole store of files: the structure of a filesystem, i-nodes, filesystem types, and how mount joins them into one unified directory tree.1

    Điểm nốiWhere it connects I-node ở đây là thứ mà thuộc tính tệp (Ch 15) và liên kết (Ch 18) cùng trỏ tới. The i-node here is what file attributes (Ch 15) and links (Ch 18) both point at.

  5. Chapter 15

    Thuộc tính tệp: stat, thời gian, quyền và quyền sở hữu Thông tin kèm theo mỗi tệp: ai sở hữu, ai được đọc File attributes: stat, timestamps, permissions and ownership

    Chương đọc siêu dữ liệu của tệp qua stat: kích thước, mốc thời gian, chủ sở hữu, và bộ ba quyền đọc–ghi–thực thi cho chủ–nhóm–người khác.1 Đây là mặt an ninh của tệp.

    Mỗi tệp đi kèm thông tin: ai làm chủ, lớn bao nhiêu, ai được đọc hay ghi. Chương này dạy cách đọc và đổi những thông tin đó. Nhớ nhé: quyền của tệp là hàng rào an ninh đầu tiên.

    The chapter reads a file's metadata through stat: size, timestamps, owner, and the read–write–execute permission triple for owner–group–other.1 This is the security face of a file.

    Điểm nốiWhere it connects Người dùng và nhóm giới thiệu ở Chương 2 trở thành cụ thể ở đây, và quyết định một daemon (Ch 37) được phép làm gì. The users and groups introduced in Chapter 2 become concrete here, and decide what a daemon (Ch 37) is allowed to do.

  6. Chapter 18

    Thư mục và liên kết: tên chỉ là con trỏ tới i-node Tên tệp và tệp thật là hai thứ khác nhau Directories and links: a name is just a pointer to an i-node

    Chương tách tên khỏi tệp: một thư mục chỉ là bảng ánh xạ tên sang i-node, nên một tệp có thể mang nhiều tên (liên kết cứng), và liên kết tượng trưng là một tên trỏ tới tên khác.1

    Tên tệp không phải là tệp; nó chỉ là một nhãn chỉ tới tệp thật. Vì vậy một tệp có thể có nhiều tên. Nhớ nhé: xoá một tên không chắc đã xoá tệp.

    The chapter separates the name from the file: a directory is just a table mapping names to i-nodes, so one file can carry several names (hard links), and a symbolic link is one name pointing at another.1

    Điểm nốiWhere it connects Ý “một đối tượng, nhiều tên” lặp lại ở FIFO (Ch 44) — một pipe có tên trên hệ thống tệp. The "one object, many names" idea recurs in FIFOs (Ch 44) — a pipe with a name on the filesystem.

Module 3 · Tiến trình & bộ nhớ · Chương 6, 7, 24, 25, 26, 27 Module 3 · Processes & memory · Chapters 6, 7, 24, 25, 26, 27

Tiến trình và bộ nhớ: bộ ba fork/exec/wait và vòng đời của một chương trình Chương trình được sinh ra, cấp bộ nhớ, chạy, rồi kết thúc Processes and memory: the fork/exec/wait triad and a program's life cycle

Sáu chương này mở tài nguyên “chương trình đang chạy”. Chúng giới thiệu tiến trình và bản đồ bộ nhớ của nó (Ch 6), cách cấp phát bộ nhớ động (Ch 7), rồi toàn bộ vòng đời: tạo bằng fork (Ch 24), kết thúc (Ch 25), theo dõi con bằng wait (Ch 26), và nạp chương trình mới bằng exec (Ch 27).1

Phần này kể cuộc đời một tiến trình: nó được tạo ra thế nào, lấy bộ nhớ ở đâu, chạy chương trình gì, và kết thúc ra sao. Ba động tác chính là fork (tách đôi), exec (thay nội dung), wait (chờ con). Nhớ nhé: fork rồi exec rồi wait — bộ ba này là trái tim của UNIX.

These six chapters open the "running program" resource. They introduce the process and its memory map (Ch 6), dynamic memory allocation (Ch 7), then the whole life cycle: creation with fork (Ch 24), termination (Ch 25), monitoring children with wait (Ch 26), and loading a new program with exec (Ch 27).1

Điều module này thêm vào: vòng đời và sự nhân bản. Mô hình UNIX tách việc “tạo một bản sao” (fork) khỏi việc “chạy chương trình khác” (exec), và điều phối chúng bằng wait — một thiết kế gọn mà cả shell lẫn mọi daemon đều dựa vào.3

Nói đơn giản. Muốn chạy chương trình mới, UNIX tách tiến trình làm đôi rồi cho một nửa biến thành chương trình khác. Nhớ nhé: tách đôi trước, thay nội dung sau.

What this module adds: a life cycle and duplication. The UNIX model separates "make a copy" (fork) from "run another program" (exec), and coordinates them with wait — a spare design that both the shell and every daemon rely on.3

tiến trình + bản đồ bộ nhớ (Ch 6) · malloc/heap (Ch 7) · fork (Ch 24) → exec (Ch 27) → wait (Ch 26) → thoát (Ch 25)

tiến trình → bộ nhớ → tách đôi → thay nội dung → chờ con → kết thúc

process + memory map (Ch 6) · malloc/heap (Ch 7) · fork (Ch 24) → exec (Ch 27) → wait (Ch 26) → exit (Ch 25)

Thứ tự số chương (24→27) không phải thứ tự đọc tự nhiên: về mặt lập luận, fork tạo con, exec thay chương trình trong con, rồi cha wait thu dọn con đã thoát — bốn chương là bốn chặng của cùng một vòng.3The chapter numbers (24→27) are not the natural reading order: logically, fork makes a child, exec replaces the program in the child, then the parent waits to reap the exited child — four chapters are four stages of one cycle.3

  1. Chapter 6

    Tiến trình: bản đồ bộ nhớ và số định danh Một tiến trình gồm những gì Processes: the memory map and identifiers

    Chương định nghĩa tiến trình so với chương trình, số định danh PID/PPID, và bản đồ bộ nhớ gồm các đoạn text, data, BSS, heap và stack.1 Đây là giải phẫu của thứ sẽ được tạo, chạy và huỷ trong các chương sau.

    Chương này mổ xẻ một tiến trình: nó có mã, có vùng biến, có ngăn xếp, và một số định danh riêng. Nhớ nhé: chương trình là tệp nằm yên; tiến trình là nó đang chạy.

    The chapter defines a process versus a program, the PID/PPID identifiers, and the memory map of text, data, BSS, heap and stack segments.1 This is the anatomy of what later chapters create, run and destroy.

    Điểm nốiWhere it connects Heap trong bản đồ bộ nhớ ở đây chính là vùng mà Chương 7 cấp phát bằng malloc. The heap in this memory map is exactly the region Chapter 7 allocates with malloc.

  2. Chapter 7

    Cấp phát bộ nhớ: malloc, free và heap Xin thêm bộ nhớ khi đang chạy Memory allocation: malloc, free and the heap

    Chương trình bày cấp phát động trên heap qua malloc/free, cơ chế brk/sbrk bên dưới, và cấp phát trên stack bằng alloca.1 Đây là nguồn của những lỗi rò bộ nhớ và con trỏ treo kinh điển.

    Khi chương trình cần thêm bộ nhớ lúc đang chạy, nó gọi malloc; xài xong thì free. Quên trả lại là rò bộ nhớ. Nhớ nhé: xin thì phải nhớ trả.

    The chapter presents dynamic heap allocation through malloc/free, the brk/sbrk mechanism beneath, and stack allocation with alloca.1 This is the source of the classic memory-leak and dangling-pointer bugs.

    Điểm nốiWhere it connects Ánh xạ bộ nhớ (Ch 49) là cách cấp vùng nhớ khác, và cũng là nền cho malloc khi xin khối lớn. Memory mapping (Ch 49) is another way to obtain memory, and also underlies malloc for large requests.

  3. Chapter 24

    Tạo tiến trình: fork và bản sao ghi-khi-chép Tách một tiến trình thành hai Process creation: fork and copy-on-write

    fork tạo một tiến trình con gần như sao y tiến trình cha, trả về hai lần — một ở cha, một ở con — và nhân dùng kỹ thuật sao-khi-ghi để không phải nhân đôi bộ nhớ ngay.3

    Gọi fork một lần, bạn có hai tiến trình giống hệt nhau; chỉ khác ở giá trị trả về để mỗi bên biết mình là cha hay con. Nhớ nhé: fork tách đôi, rồi hai bên đi hai đường.

    fork creates a child that is nearly an exact copy of the parent, returns twice — once in the parent, once in the child — and the kernel uses copy-on-write so it need not duplicate memory at once.3

    Điểm nốiWhere it connects Con tạo ra ở đây thường gọi exec (Ch 27) ngay sau; còn cha phải wait (Ch 26) để tránh để lại tiến trình xác. The child created here usually calls exec (Ch 27) right after; the parent must wait (Ch 26) to avoid leaving a zombie.

  4. Chapter 25

    Kết thúc tiến trình: exit và dọn dẹp Một tiến trình kết thúc thế nào Process termination: exit and cleanup

    Chương phân biệt _exit (syscall) với exit (hàm thư viện xả đệm), trạng thái thoát mà cha đọc được, và các hàm dọn dẹp đăng ký qua atexit.1

    Khi xong việc, tiến trình kết thúc và để lại một “mã thoát” cho cha biết nó thành công hay thất bại. Nhớ nhé: mã thoát 0 thường nghĩa là ổn.

    The chapter distinguishes _exit (the syscall) from exit (the library function that flushes buffers), the exit status the parent can read, and cleanup handlers registered with atexit.1

    Điểm nốiWhere it connects Trạng thái thoát ở đây chính là thứ wait (Ch 26) thu về; xả đệm liên quan thẳng tới Chương 13. The exit status here is exactly what wait (Ch 26) collects; the buffer flush ties straight back to Chapter 13.

  5. Chapter 26

    Theo dõi con: wait, waitpid và tiến trình xác Cha chờ con xong việc thế nào Monitoring children: wait, waitpid and zombies

    Chương dạy cha thu trạng thái của con qua wait/waitpid, giải thích tiến trình xác (zombie) khi cha chưa thu, và tiến trình mồ côi được init nhận nuôi.1

    Sau khi con kết thúc, cha phải “nhận lại” nó, nếu không con thành “xác” lởn vởn trong hệ thống. Nhớ nhé: sinh con thì phải nhớ chờ con.

    The chapter teaches the parent to collect a child's status with wait/waitpid, explains the zombie left when the parent has not collected, and the orphan adopted by init.1

    Điểm nốiWhere it connects Con kết thúc sẽ gửi tín hiệu SIGCHLD cho cha — đây là cây cầu thẳng sang Module 4. A finishing child sends SIGCHLD to the parent — a direct bridge into Module 4.

  6. Chapter 27

    Nạp chương trình: họ hàm exec và môi trường Thay nội dung tiến trình bằng chương trình mới Program execution: the exec family and the environment

    Chương trình bày họ hàm exec thay toàn bộ mã và dữ liệu của tiến trình hiện tại bằng một chương trình mới, giữ nguyên PID và các mô tả tệp đang mở, cùng cách truyền đối số và môi trường.1

    exec không tạo tiến trình mới; nó thay ruột của tiến trình hiện tại bằng một chương trình khác. Đây là cách shell chạy lệnh của bạn. Nhớ nhé: fork tạo thân, exec thay hồn.

    The chapter presents the exec family that replaces the current process's entire code and data with a new program, keeping the PID and open descriptors, together with how arguments and the environment are passed.1

    Điểm nốiWhere it connects Vì exec giữ các mô tả tệp đang mở, shell có thể nối pipe (Ch 44) trước khi chạy lệnh. Because exec keeps open descriptors, the shell can wire up a pipe (Ch 44) before running a command.

Module 4 · Tín hiệu & luồng · Chương 20, 21, 29, 30 Module 4 · Signals & threads · Chapters 20, 21, 29, 30

Tín hiệu và luồng: ngắt quãng không đồng bộ và sự song song thật Chuông báo bất ngờ, và làm nhiều việc một lúc Signals and threads: asynchronous interruption and real parallelism

Bốn chương này cho tiến trình hai năng lực mới. Tín hiệu (Ch 20–21) là cách nhân và tiến trình khác ngắt quãng một tiến trình để báo sự kiện; luồng (Ch 29–30) cho nhiều dòng điều khiển chạy trong cùng một không gian nhớ, cùng với vấn đề đồng bộ hoá đi kèm.1

Phần này thêm hai khả năng: nghe “chuông báo” khi có việc gấp (tín hiệu), và chạy nhiều việc song song trong một chương trình (luồng). Chạy song song nhanh nhưng dễ đụng nhau, nên cần khoá cửa cẩn thận. Nhớ nhé: làm nhiều việc một lúc thì phải giữ trật tự.

These four chapters give the process two new powers. Signals (Ch 20–21) are how the kernel and other processes interrupt a process to announce an event; threads (Ch 29–30) let several control flows run in one address space, with the synchronization problem that comes with it.1

Điều module này thêm vào: thời gian không tuần tự. Tín hiệu có thể ập tới giữa chừng bất kỳ dòng lệnh nào; luồng cho hai dòng lệnh chạy chồng lên nhau — cả hai đều phá vỡ giả định “một việc tại một thời điểm” và sinh ra một lớp lỗi mới.1

Nói đơn giản. Mọi thứ không còn chạy lần lượt nữa: việc có thể bị chen ngang, hoặc chạy cùng lúc. Nhớ nhé: khi hai việc đụng một chỗ, phải có khoá.

What this module adds: non-sequential time. A signal can strike in the middle of any statement; threads let two statements overlap — both break the "one thing at a time" assumption and create a new class of bugs.1

tín hiệu: khái niệm & gửi (Ch 20) → bộ xử lý tín hiệu an toàn (Ch 21) · luồng: tạo & chia bộ nhớ (Ch 29) → mutex & biến điều kiện (Ch 30)

chuông báo → cách xử lý chuông · tạo luồng → khoá để khỏi đụng nhau

signals: concepts & sending (Ch 20) → safe signal handlers (Ch 21) · threads: creation & shared memory (Ch 29) → mutexes & condition variables (Ch 30)

  1. Chapter 20

    Tín hiệu: khái niệm, gửi và mặt nạ Chuông báo của hệ điều hành là gì Signals: concepts, sending and masks

    Chương định nghĩa tín hiệu là thông điệp không đồng bộ, liệt kê các loại (như SIGINT, SIGKILL), cách gửi bằng kill, định đoạt mặc định, và mặt nạ tín hiệu để chặn tạm thời.1

    Tín hiệu là cách hệ điều hành “gõ cửa” tiến trình: Ctrl-C gửi một tín hiệu, hết giờ hẹn gửi một tín hiệu khác. Nhớ nhé: tín hiệu là tin nhắn ngắn, ập tới bất ngờ.

    The chapter defines a signal as an asynchronous message, lists the kinds (such as SIGINT, SIGKILL), sending with kill, default dispositions, and the signal mask for temporary blocking.1

    Điểm nốiWhere it connects SIGCHLD từ Chương 26 là một ví dụ tín hiệu; daemon (Ch 37) dùng tín hiệu để nhận lệnh nạp lại cấu hình. SIGCHLD from Chapter 26 is one signal example; daemons (Ch 37) use signals to be told to reload their config.

  2. Chapter 21

    Bộ xử lý tín hiệu: viết handler an toàn Cách xử lý chuông báo mà không gây lỗi Signal handlers: writing them safely

    Chương dạy viết hàm xử lý tín hiệu đúng cách: vì handler chạy xen giữa chương trình chính, chỉ được gọi các hàm an toàn-tín hiệu không đồng bộ, và dùng sigaction thay cho signal cũ.1

    Khi chuông reo, bạn chạy một đoạn xử lý ngắn. Nhưng đoạn này chen vào giữa chương trình, nên phải viết rất cẩn thận, không làm gì phức tạp. Nhớ nhé: trong handler, càng ít việc càng an toàn.

    The chapter teaches writing signal handlers correctly: because a handler runs interleaved with the main program, it may call only async-signal-safe functions, and should use sigaction rather than the old signal.1

    Điểm nốiWhere it connects Vấn đề “chen giữa” ở đây giống hệt vấn đề đồng bộ của luồng (Ch 30) — cùng một nỗi lo về dữ liệu dùng chung. The "interleaving" problem here mirrors the thread synchronization problem (Ch 30) — the same worry about shared data.

  3. Chapter 29

    Luồng: nhiều dòng điều khiển, một không gian nhớ Nhiều việc chạy trong cùng một chương trình Threads: many control flows, one address space

    Chương giới thiệu luồng POSIX (pthreads): nhiều luồng trong một tiến trình chia sẻ bộ nhớ nhưng có ngăn xếp riêng, tạo bằng pthread_create và hợp nhất bằng pthread_join.1 So với tiến trình, luồng nhẹ hơn nhưng nguy hiểm hơn vì chia sẻ dữ liệu.

    Luồng giống như nhiều người làm trong cùng một phòng: nhanh vì dùng chung đồ, nhưng dễ giẫm chân nhau. Nhớ nhé: luồng chia sẻ bộ nhớ, nên tiện mà cũng nguy.

    The chapter introduces POSIX threads (pthreads): many threads in one process share memory but have private stacks, created with pthread_create and joined with pthread_join.1 Compared with processes, threads are lighter but more dangerous because they share data.

    Điểm nốiWhere it connects Luồng là lựa chọn thay cho fork (Ch 24) khi cần chia sẻ dữ liệu; chia sẻ đó dẫn thẳng tới nhu cầu đồng bộ ở Chương 30. Threads are an alternative to fork (Ch 24) when data must be shared; that sharing leads straight to the synchronization need in Chapter 30.

  4. Chapter 30

    Đồng bộ luồng: mutex và biến điều kiện Khoá cửa để luồng không giẫm chân nhau Thread synchronization: mutexes and condition variables

    Chương giải quyết vấn đề dữ liệu dùng chung: mutex bảo vệ vùng tới hạn khỏi tranh đua, biến điều kiện cho luồng chờ một điều kiện mà không bận quay vòng.1 Đây là nơi khái niệm race condition và deadlock trở nên cụ thể.

    Khi nhiều luồng cùng sửa một chỗ, kết quả có thể sai. Mutex là cái khoá: mỗi lúc chỉ một luồng được vào. Nhớ nhé: dùng chung thì phải khoá, nhưng khoá sai dễ gây kẹt cứng.

    The chapter tackles shared data: a mutex protects a critical section from races, a condition variable lets a thread wait for a condition without busy-spinning.1 This is where race conditions and deadlocks become concrete.

    Điểm nốiWhere it connects Nỗi lo tranh đua ở đây là cùng một nỗi lo khi hai tiến trình chia bộ nhớ qua ánh xạ (Ch 49). The race worry here is the same one when two processes share memory via a mapping (Ch 49).

Module 5 · IPC / chuyền dữ liệu · Chương 41, 44, 49 Module 5 · IPC / passing data · Chapters 41, 44, 49

IPC: những cách để các tiến trình chia dữ liệu cho nhau Chương trình chuyền dữ liệu cho nhau thế nào IPC: the ways processes hand data to one another

Ba chương này mở các kênh giữa các tiến trình: thư viện chia sẻ cho phép nhiều chương trình dùng chung mã (Ch 41); pipe và FIFO là dòng byte một chiều nối hai tiến trình (Ch 44); và ánh xạ bộ nhớ cho chúng cùng nhìn vào một vùng nhớ (Ch 49).1 Mỗi cách đánh đổi giữa đơn giản và tốc độ.

Phần này dạy ba cách cho các chương trình chia nhau thứ gì đó: dùng chung mã (thư viện chia sẻ), chuyền byte qua một đường ống (pipe), hoặc cùng nhìn chung một vùng nhớ (ánh xạ). Nhớ nhé: pipe thì dễ, bộ nhớ chung thì nhanh nhưng khó hơn.

These three chapters open channels between processes: shared libraries let many programs share code (Ch 41); pipes and FIFOs are a one-way byte stream joining two processes (Ch 44); and memory mappings let them look into the same region of memory (Ch 49).1 Each trades simplicity against speed.

Điều module này thêm vào: các kênh chia sẻ. Có kênh chia mã (thư viện), có kênh chia dòng byte (pipe), có kênh chia nguyên một vùng nhớ (ánh xạ). Pipe lại chỉ là một cặp mô tả tệp — nên mô hình I/O của Module 2 trả cổ tức ở đây.5

Nói đơn giản. Ba kiểu chia sẻ: chia mã, chia dòng dữ liệu, chia vùng nhớ. Nhớ nhé: pipe đọc ghi y như tệp.

What this module adds: shared channels. One channel shares code (libraries), one shares a byte stream (pipes), one shares a whole memory region (mappings). A pipe is just a pair of file descriptors — so Module 2's I/O model pays off here.5

thư viện chia sẻ: dùng chung mã (Ch 41) · pipe/FIFO: dòng byte qua mô tả tệp (Ch 44) · mmap: cùng một vùng nhớ (Ch 49)

chia mã · chia dòng dữ liệu · chia vùng nhớ

shared libraries: shared code (Ch 41) · pipes/FIFOs: a byte stream over descriptors (Ch 44) · mmap: the same memory region (Ch 49)

  1. Chapter 41

    Thư viện chia sẻ: dùng chung mã giữa các chương trình Nhiều chương trình xài chung một thư viện Fundamentals of shared libraries: sharing code between programs

    Chương phân biệt thư viện tĩnh với thư viện chia sẻ, giải thích vì sao chia sẻ tiết kiệm bộ nhớ và cho cập nhật mã không cần biên dịch lại, cùng cách bộ nạp động tìm và gắn thư viện lúc chạy.1

    Thay vì mỗi chương trình mang một bản sao của cùng đoạn mã, tất cả dùng chung một bản. Tiết kiệm, và vá lỗi một chỗ là cả hệ được vá. Nhớ nhé: chia sẻ mã giống như mượn chung một quyển sách.

    The chapter distinguishes static from shared libraries, explains why sharing saves memory and allows updating code without recompiling, and how the dynamic loader finds and binds a library at run time.1

    Điểm nốiWhere it connects Bộ nạp động dùng ánh xạ bộ nhớ (Ch 49) để nạp thư viện; chia sẻ mã cũng là một dạng chia sẻ trang bộ nhớ. The dynamic loader uses memory mapping (Ch 49) to load libraries; sharing code is itself a form of sharing memory pages.

  2. Chapter 44

    Pipe và FIFO: dòng byte giữa hai tiến trình Đường ống nối đầu ra của bên này với đầu vào bên kia Pipes and FIFOs: a byte stream between two processes

    Chương trình bày pipe — kênh một chiều tạo bằng pipe, chính là cơ chế đằng sau dấu | của shell — và FIFO, một pipe có tên trên hệ thống tệp để các tiến trình không họ hàng cũng nối được.1

    Pipe là đường ống: cái gì bên này ghi vào, bên kia đọc ra. Đây chính là dấu gạch đứng | khi bạn nối lệnh trong terminal. Nhớ nhé: pipe nối đầu ra lệnh này với đầu vào lệnh kia.

    The chapter presents the pipe — a one-way channel made with pipe, the very mechanism behind the shell's | — and the FIFO, a named pipe on the filesystem so even unrelated processes can connect.1

    Điểm nốiWhere it connects Pipe là một cặp mô tả tệp (Ch 4), và shell nối nó nhờ exec giữ mô tả tệp (Ch 27). A pipe is a pair of file descriptors (Ch 4), and the shell wires it because exec keeps descriptors (Ch 27).

  3. Chapter 49

    Ánh xạ bộ nhớ: mmap, tệp và vùng nhớ chung Biến một tệp thành bộ nhớ, hoặc chia bộ nhớ chung Memory mappings: mmap, files and shared memory

    Chương trình bày mmap: ánh xạ một tệp vào không gian địa chỉ để đọc ghi tệp như đọc ghi mảng, và ánh xạ ẩn danh chia sẻ để hai tiến trình cùng nhìn một vùng nhớ — cách IPC nhanh nhất vì không phải sao chép.1

    mmap cho bạn coi một tệp như một mảng trong bộ nhớ, hoặc cho hai chương trình cùng dùng một vùng nhớ. Nhanh vì không phải chép qua chép lại. Nhớ nhé: cùng nhìn một vùng nhớ là cách chia dữ liệu nhanh nhất.

    The chapter presents mmap: mapping a file into the address space to read and write it like an array, and a shared anonymous mapping so two processes see the same memory — the fastest IPC because nothing is copied.1

    Điểm nốiWhere it connects Bộ nhớ chung mang lại đúng vấn đề đồng bộ của Chương 30; ánh xạ tệp là cùng ý đệm của Chương 13. Shared memory brings back the exact synchronization problem of Chapter 30; mapping a file is the same buffering idea as Chapter 13.

Module 6 · Daemon & mạng · Chương 37, 56, 59, 63 Module 6 · Daemons & networking · Chapters 37, 56, 59, 63

Daemon và mạng: chương trình bước ra ngoài một máy Chạy nền và nói chuyện qua mạng Daemons and networking: the program steps beyond one machine

Bốn chương cuối là nơi mọi thứ đã học được dùng cùng lúc. Daemon là tiến trình chạy nền lâu dài, không gắn terminal (Ch 37); socket là mô hình kết nối tổng quát (Ch 56); miền Internet cho socket chạy qua TCP/IP giữa các máy (Ch 59); và các mô hình I/O thay thế cho phép một chương trình phục vụ nhiều kết nối một lúc (Ch 63).1

Phần cuối cho chương trình “ra khỏi nhà”: chạy nền âm thầm như một dịch vụ, và nói chuyện với máy khác qua mạng. Để phục vụ nhiều người cùng lúc, nó cần những cách chờ dữ liệu thông minh hơn. Nhớ nhé: đây là lúc mọi thứ học trước được ghép lại.

The last four chapters are where everything learned so far is used at once. A daemon is a long-lived background process with no terminal (Ch 37); the socket is the general connection model (Ch 56); the Internet domain runs sockets over TCP/IP between machines (Ch 59); and alternative I/O models let one program serve many connections at once (Ch 63).1

Điều module này thêm vào: một máy thứ hai và sự phục vụ lâu dài. Socket kéo ranh giới ra ngoài một máy; daemon cho chương trình sống mãi để phục vụ; còn các mô hình I/O thay thế trả lời câu hỏi làm sao một tiến trình chờ hàng nghìn kết nối cùng lúc mà không bị kẹt ở một cái.6

Nói đơn giản. Thêm máy thứ hai (socket), thêm dịch vụ chạy mãi (daemon), và cách phục vụ nhiều người một lúc. Nhớ nhé: phục vụ đông thì không được đứng chờ từng người.

What this module adds: a second machine and long-lived service. Sockets stretch the boundary beyond one machine; daemons let a program live on to serve; and alternative I/O models answer how one process waits on thousands of connections at once without getting stuck on any one.6

daemon: tiến trình nền (Ch 37) · socket: mô hình kết nối (Ch 56) · miền Internet TCP/IP (Ch 59) · select/poll/epoll (Ch 63)

chạy nền → ổ cắm kết nối → qua Internet → phục vụ nhiều người một lúc

daemon: background process (Ch 37) · socket: the connection model (Ch 56) · Internet domain TCP/IP (Ch 59) · select/poll/epoll (Ch 63)

  1. Chapter 37

    Daemon: tiến trình nền sống lâu, không terminal Chương trình chạy âm thầm như một dịch vụ Daemons: long-lived background processes with no terminal

    Chương dạy cách biến một tiến trình thường thành daemon: tách khỏi terminal điều khiển, tạo phiên mới, đóng các mô tả tệp thừa, và ghi log đúng cách.1 Đây là khuôn mẫu cho mọi dịch vụ server.

    Daemon là chương trình chạy ngầm mãi mãi để phục vụ — như máy chủ web hay dịch vụ in. Nó tự cắt dây với cửa sổ terminal để sống độc lập. Nhớ nhé: daemon là người làm thầm lặng, không cần ai ngồi canh.

    The chapter teaches turning an ordinary process into a daemon: detaching from the controlling terminal, starting a new session, closing stray descriptors, and logging properly.1 This is the template for every server service.

    Điểm nốiWhere it connects Daemon dùng fork (Ch 24) để tách ra, tín hiệu (Ch 20) để nhận lệnh, và thường kết thúc bằng việc mở socket (Ch 56). A daemon uses fork (Ch 24) to detach, signals (Ch 20) to take commands, and usually ends up opening a socket (Ch 56).

  2. Chapter 56

    Socket: mô hình kết nối tổng quát Ổ cắm để hai chương trình nối với nhau Sockets: the general connection model

    Chương giới thiệu API socket chung: socket, bind, listen, accept, connect, và hai kiểu — dòng (stream) và gói (datagram).1 Một socket sau khi kết nối là một mô tả tệp, nên đọc ghi nó y như một tệp.5

    Socket là “ổ cắm” để hai chương trình nối dây nói chuyện. Một bên chờ (server), một bên gọi tới (client). Khi đã nối, gửi nhận giống hệt đọc ghi tệp. Nhớ nhé: nối xong rồi thì socket cũng chỉ là một tệp.

    The chapter introduces the generic socket API: socket, bind, listen, accept, connect, and two types — stream and datagram.1 A connected socket is a file descriptor, so you read and write it just like a file.5

    Điểm nốiWhere it connects Lời hứa của Module 2 trả cổ tức: socket đọc ghi bằng đúng read/write của Chương 4. Module 2's promise pays off: a socket is read and written with the very read/write of Chapter 4.

  3. Chapter 59

    Socket miền Internet: TCP/IP giữa các máy Nối hai máy thật qua Internet Internet domain sockets: TCP/IP between machines

    Chương đưa socket lên mạng thật: địa chỉ IPv4/IPv6, cổng, thứ tự byte mạng, và cách phân giải tên máy bằng getaddrinfo.1 Đây là nơi lý thuyết socket gặp Internet.

    Chương này cho socket chạy qua Internet thật: mỗi máy có địa chỉ IP, mỗi dịch vụ có một cổng, và có hàm để đổi tên miền thành địa chỉ. Nhớ nhé: địa chỉ IP là số nhà, cổng là số căn hộ.

    The chapter takes sockets onto the real network: IPv4/IPv6 addresses, ports, network byte order, and resolving host names with getaddrinfo.1 This is where socket theory meets the Internet.

    Điểm nốiWhere it connects Server mạng dựng ở đây thường là một daemon (Ch 37) phục vụ nhiều client, dẫn thẳng sang Chương 63. The network server built here is usually a daemon (Ch 37) serving many clients, leading straight into Chapter 63.

  4. Chapter 63

    Mô hình I/O thay thế: select, poll và epoll Phục vụ nhiều kết nối cùng lúc mà không bị kẹt Alternative I/O models: select, poll and epoll

    Chương giải quyết bài toán một server phục vụ nhiều kết nối: thay vì chặn trên từng mô tả tệp, dùng I/O đa kênh (select, poll) hay epoll của Linux để chờ trên cả nghìn mô tả tệp cùng lúc.6

    Một server không thể đứng chờ từng khách một. Chương này dạy cách theo dõi nhiều kết nối cùng lúc và chỉ xử lý cái nào sẵn sàng. Nhớ nhé: đừng chờ một người, hãy canh cả đám và ai xong trước thì làm trước.

    The chapter solves one server serving many connections: instead of blocking on each descriptor, use I/O multiplexing (select, poll) or Linux's epoll to wait on thousands of descriptors at once.6

    Điểm nốiWhere it connects Cờ không chặn (O_NONBLOCK) của Chương 5 là mảnh ghép còn thiếu; cả chương là sự trở lại của mô tả tệp (Ch 4) ở quy mô lớn. The non-blocking flag (O_NONBLOCK) of Chapter 5 is the missing piece; the whole chapter is the file descriptor (Ch 4) returning at scale.

Sợi chỉ xuyên suốt · 4 sợi Through-lines · four threads

Bốn ý quay lại ở nhiều chương, dưới nhiều cái tên Bốn ý lặp đi lặp lại trong cả cuốn sách Four ideas that keep returning, under different names

Đây là phần mà lối đọc tuần tự hay bỏ lỡ. Mỗi sợi dưới đây xuất hiện ở nhiều chương, thường mang tên khác nhau mỗi lần — nên nếu chỉ đọc một chương, bạn thấy một kỹ thuật; đọc cả các chỗ, bạn thấy một nguyên lý.1

Có bốn ý cứ quay đi quay lại trong sách, mỗi lần đổi tên một chút. Nếu chỉ đọc một chương thì tưởng là mẹo vặt; đọc cả mấy chỗ mới thấy đó là một quy tắc. Nhớ nhé: thấy quen quen thì đúng là bạn đã gặp rồi.

This is the part sequential reading misses. Each thread below appears in several chapters, usually under a different name each time — so one chapter shows you a technique, while all its sites show you a principle.1

  1. Thread 01

    Mô tả tệp ở khắp nơi Một con số nhỏ đại diện cho mọi thứ The file descriptor everywhere

    Sợi chỉ bản lề của cuốn sách. Mô tả tệp mở ở Chương 4 không chỉ dành cho tệp: pipe (Ch 44), socket (Ch 56, 59), và các cơ chế I/O đa kênh (Ch 63) đều thao tác trên cùng con số đó, qua cùng read/write.5 Học một lần, dùng ở khắp nơi.

    Mở tệp, bạn được một con số nhỏ. Hoá ra pipe, socket, kết nối mạng cũng dùng đúng loại con số đó, và đọc ghi y hệt. Nhớ nhé: nắm được mô tả tệp là nắm được nửa cuốn sách.

    The book's hinge thread. The descriptor opened in Chapter 4 is not only for files: pipes (Ch 44), sockets (Ch 56, 59), and the I/O multiplexing mechanisms (Ch 63) all operate on that same number, through the same read/write.5 Learn it once, use it everywhere.

    Xuất hiện ở:Appears in: Ch 4, Ch 44, Ch 56, Ch 63

  2. Thread 02

    Bộ ba fork / exec / wait Tách đôi, thay nội dung, chờ con The fork / exec / wait triad

    Sợi chỉ của mọi chuyện liên quan tới tiến trình. fork tạo con (Ch 24), exec thay chương trình trong con (Ch 27), và wait thu dọn con đã thoát (Ch 26) — ba lời gọi dựng nên shell, mọi daemon, và mọi server đa tiến trình.3

    Muốn chạy chương trình khác, UNIX tách đôi tiến trình, cho một nửa biến thành chương trình mới, rồi nửa kia chờ nó xong. Shell làm đúng điều này mỗi khi bạn gõ một lệnh. Nhớ nhé: fork, exec, wait — thuộc ba chữ này là hiểu nửa UNIX.

    The thread behind everything about processes. fork makes a child (Ch 24), exec replaces the program in the child (Ch 27), and wait reaps the exited child (Ch 26) — three calls that build the shell, every daemon, and every multi-process server.3

    Xuất hiện ở:Appears in: Ch 24, Ch 27, Ch 26, Ch 37

  3. Thread 03

    Chặn hay không chặn Đứng chờ, hay làm việc khác trong lúc chờ Blocking versus non-blocking

    Một lựa chọn quay lại suốt cuốn sách. Mặc định, read chặn tới khi có dữ liệu; cờ O_NONBLOCK (Ch 5) đổi điều đó, tín hiệu (Ch 20) có thể cắt ngang một lời gọi đang chặn, và các mô hình I/O thay thế (Ch 63) sinh ra chính để một tiến trình khỏi phải đứng chặn trên một kết nối.6

    Khi chờ dữ liệu, chương trình có hai cách: đứng yên chờ (chặn), hoặc vừa chờ vừa làm việc khác (không chặn). Cả cuốn sách liên tục chọn giữa hai cách này. Nhớ nhé: phục vụ đông người thì không được đứng chờ một người.

    A choice that returns throughout the book. By default read blocks until data arrives; the O_NONBLOCK flag (Ch 5) changes that, signals (Ch 20) can interrupt a blocking call, and the alternative I/O models (Ch 63) exist precisely so one process need not block on a single connection.6

    Xuất hiện ở:Appears in: Ch 5, Ch 20, Ch 44, Ch 63

  4. Thread 04

    “Mọi thứ là một tệp” Mọi thứ đều mở, đọc, ghi, đóng "Everything is a file"

    Nguyên lý thiết kế lớn của UNIX. Tệp thường, thư mục (Ch 18), pipe (Ch 44), bộ nhớ ánh xạ (Ch 49), và socket (Ch 56) đều được trình bày qua cùng một giao diện thao tác — phần lớn là open/read/write/close — nên hiểu một thứ là gần hiểu tất cả.5

    UNIX cố làm mọi thứ trông giống một tệp: bàn phím, màn hình, mạng, đường ống. Nhờ vậy bạn chỉ cần học một bộ động tác. Nhớ nhé: nếu nó mở–đọc–ghi–đóng được, thì với UNIX nó là một tệp.

    UNIX's great design principle. Regular files, directories (Ch 18), pipes (Ch 44), mapped memory (Ch 49) and sockets (Ch 56) are all presented through the same manipulation interface — mostly open/read/write/close — so understanding one is nearly understanding all.5

    Xuất hiện ở:Appears in: Ch 4, Ch 18, Ch 44, Ch 56

Lộ trình · 3 cách đọc Routes · three ways through

Ba lộ trình xuyên 26 chương Nên đọc chương nào trước? Three routes through 26 chapters

Cuốn sách là một tài liệu tra cứu dày, nên hiếm ai đọc thẳng từ đầu đến cuối.1 Mỗi chương khá độc lập, nên có thể đi theo ba đường khác nhau tuỳ mục tiêu. Cách phân nhóm dưới đây là gợi ý của trang này, bám theo sáu module ở trên.

Sách rất dày và dùng để tra cứu, nên không nhất thiết đọc hết một mạch. Tuỳ bạn cần gì mà có đường đi khác nhau. Nhớ nhé: được phép nhảy cóc, miễn là biết mình đang bỏ qua gì.

The book is a thick reference, so few read it straight through.1 Each chapter is fairly independent, so three different paths are possible depending on your goal. The grouping below is this page's suggestion, following the six modules above.

Nền tảng, cho người mới Foundations, for newcomers

Ch 1–3 → 4 → 5 → 6 → 24 → 26 → 27. Đường ngắn nhất để viết được chương trình hệ thống đầu tiên: khái niệm và quy ước, File I/O, tiến trình, rồi bộ ba tạo–chờ–nạp. Để dành hệ thống tệp, tín hiệu, luồng và mạng cho sau.

Đọc Chương 1–3, rồi 4, 5, 6, 24, 26, 27. Đây là bộ tối thiểu để viết chương trình chạm vào hệ điều hành. Nhớ nhé: chưa cần đụng mạng vội.

Ch 1–3 → 4 → 5 → 6 → 24 → 26 → 27. The shortest path to your first system program: concepts and conventions, File I/O, processes, then the create–wait–load triad. Save filesystems, signals, threads and networking for later.

Đồng thời là ưu tiên Concurrency first

Ch 6 → 24 → 20 → 21 → 29 → 30 → 63. Lộ trình “làm nhiều việc một lúc”: tiến trình, tạo tiến trình, tín hiệu và handler an toàn, luồng và đồng bộ, rồi các mô hình I/O đa kênh. Đây là các chương nặng nhất về thời gian không tuần tự.

Đọc 6, 24, 20, 21, 29, 30, 63. Đường cho người muốn hiểu chạy song song và phục vụ nhiều kết nối. Nhớ nhé: song song mạnh nhưng phải khoá cửa cẩn thận.

Ch 6 → 24 → 20 → 21 → 29 → 30 → 63. The "many things at once" route: processes, process creation, signals and safe handlers, threads and synchronization, then the I/O multiplexing models. These are the chapters that weigh most on non-sequential time.

Mạng là đích đến Networking as the goal

Ch 4 → 5 → 24 → 26 → 37 → 56 → 59 → 63. Đường dựng một server: mô hình I/O, tiến trình, daemon hoá, socket, miền Internet, rồi phục vụ nhiều kết nối. Mọi sợi chỉ của cuốn sách hội tụ ở cuối đường này.

Đọc 4, 5, 24, 26, 37, 56, 59, 63. Đường cho người muốn viết một máy chủ mạng. Nhớ nhé: server là nơi mọi thứ bạn học được dùng cùng lúc.

Ch 4 → 5 → 24 → 26 → 37 → 56 → 59 → 63. The build-a-server route: the I/O model, processes, daemonising, sockets, the Internet domain, then serving many connections. Every thread of the book converges at the end of this path.

Khép lại bản đồ Closing the map

Hai mươi sáu chương không phải hai mươi sáu chủ đề rời. Chúng là một giao diện duy nhất — bề mặt mà nhân Linux chìa ra — mở dần từ một mô tả tệp, qua tiến trình và luồng, tới lúc một chương trình bước ra ngoài và phục vụ cả thế giới.

Cả cuốn sách chỉ kể một điều: chương trình của bạn xin hệ điều hành tệp, bộ nhớ, và mạng như thế nào — từ động tác đầu tiên tới lúc thành một dịch vụ. Nhớ nhé: hiểu giao diện này là hiểu cách Linux chạy.

Twenty-six chapters are not twenty-six separate subjects. They are one single interface — the surface the Linux kernel exposes — opened step by step from a file descriptor, through processes and threads, until a program steps outside and serves the whole world.