Linux system programming talking directly to the kernel and C library (Robert Love)（Z-Library）

# Linux System Programming: Talking Directly to the Kernel and C Library ## 【One-Line Pitch】 A comprehensive, insider's guide to Linux system programming that bridges the gap between POSIX standards and Linux-specific extensions, teaching you how to write efficient, correct code that talks directly to the kernel. Essential reading for C programmers, systems engineers, and anyone building performance-critical applications on Linux. ## 【Book Arc】 - **Opening (~0%–9%)**: Lays the foundation with essential concepts—the Linux kernel, C library, and compiler toolchain, plus the critical distinction between APIs and ABIs, and how system calls work under the hood. - **Early (~9%–25%)**: Covers basic file I/O operations (open, read, write, close), error handling via errno, file permissions and ownership semantics, and the everything-is-a-file paradigm including special files and device access. - **Early (~25%–38%)**: Dives into advanced file I/O—scatter/gather I/O with readv()/writev(), event polling with epoll, and the performance implications of synchronized I/O flags like O_SYNC, O_DSYNC, and O_RSYNC. - **Middle (~38%–53%)**: Explores buffered I/O through the standard C library, demonstrating why block size matters dramatically for performance, and introduces multiplexed I/O as the solution to concurrent file descriptor monitoring. - **Late (~53%–100%)**: Extends into process management, threading with Pthreads, memory allocation and optimization, signal handling, and clock/timer management—the full toolkit for production-grade system programming. ## 【Key Takeaways】 - **ABI vs. API distinction matters** (Early): While APIs ensure source compatibility, ABIs guarantee binary compatibility—understanding this difference helps you write code that survives across systems and architectures without recompilation. - **errno is your error compass** (Early): The errno variable, valid only immediately after a failed call, maps numeric codes to human-readable errors like EACCES for "permission denied"—check it right after any system call returns -1. - **File ownership has subtle rules** (Early): Linux defaults to System V behavior (new files inherit the creating process's gid), but BSD behavior (inheriting parent directory's gid) kicks in with setgid directories—code that cares must call fchown() explicitly. - **Block size dramatically impacts I/O performance** (Middle): The dd benchmark shows 18.7 seconds for 1-byte blocks versus 0.025 seconds for 1,024-byte blocks—but unaligned sizes like 1,130 bytes can actually degrade performance despite fewer system calls. - **O_SYNC is expensive—use it sparingly** (Early): Synchronized I/O can increase elapsed time by one or two orders of magnitude; prefer fsync()/fdatasync() for critical operations rather than forcing sync on every write. - **Multiplexed I/O solves the blocking problem** (Middle): Instead of busy-polling or blocking on single descriptors, epoll and poll let you sleep efficiently and wake only when any of multiple file descriptors become ready. - **Symbolic links cost more than hard links** (Early): Resolving a symlink involves resolving two files, and they require special system calls—hard links are transparent and incur no additional overhead. ## 【Reading Tips】 - **Skim Chapter 1's ABI discussion** unless you're writing assembly or toolchain code—the key insight is that the toolchain enforces ABI, so you rarely need to memorize it. - **Deep-read the buffered I/O chapter** (Chapter 3): The dd benchmark table is worth studying carefully—it teaches the real-world impact of block size selection better than any theory. - **Pay special attention to the errno table** in Chapter 1—it's a reference you'll return to constantly when debugging system calls. - **Treat the O_SYNC/O_DSYNC/O_RSYNC discussion** as a decision framework: understand when you truly need synchronized I/O versus when fsync() at critical points suffices. - **The multiplexed I/O section** (poll/epoll) is where the book shifts from basics to production-grade patterns—read it twice if you're building servers or event-driven applications. ## 【Coverage Limits】 This guide covers the opening through middle sections (roughly 0–53% of the book), focusing on foundational concepts, file I/O, buffered I/O, and multiplexed I/O. The later chapters on process management, threading, memory, signals, and clocks are not covered in the source excerpts. ##