How Linux Works: What Every Superuser Should Know

Citation

Ward, B. (2021). How Linux Works: What Every Superuser Should Know (3rd ed.). No Starch Press.

Chapter Summary

The third edition has seventeen chapters, a bibliography and an index (which begins on page 423). The preface covers who should read the book, its prerequisites, how to read it, a note on hands-on work and how the book is organized. The publisher says this edition adds coverage of the Logical Volume Manager (LVM), the journald logging system and IPv6, expands the discussion of systemd, and adds a chapter on virtualization including containers and cgroups. The chapters follow a path from an overview of the system's layers, through the command line, devices, disks and booting, to processes, networking, user environments, development tools and virtualization, with many sections showing the commands and files that reveal what the system is doing.

Chapter 1: The Big Picture

The levels and layers of abstraction in a Linux system: hardware and main memory, the kernel, user space and users. This chapter supplies the map the rest of the book fills in.

Chapter 2: Basic Commands and Directory Hierarchy

A working introduction to the shell: basic and intermediate commands, navigating directories, environment variables and the command path, special characters, editors, online help, input and output redirection, error messages, processes, file permissions, archiving, the directory hierarchy and running commands as the superuser.

Chapters 3–4: Devices; Disks and Filesystems

Device files, the sysfs device path, dd, device naming and udev, with an in-depth section on SCSI in the kernel. Chapter 4 covers partitioning, filesystems, swap space and the Logical Volume Manager, and ends with a look inside a traditional filesystem.

Chapters 5–6: How the Linux Kernel Boots; How User Space Starts

The free sample chapter opens with how to view boot messages (for example with journalctl -k) and then covers kernel initialization and parameters, boot loaders, GRUB, UEFI Secure Boot problems and chainloading. Chapter 6 introduces init, systemd in detail, System V runlevels and init, shutting down, the initial RAM filesystem and emergency booting.

Chapter 7: System Configuration: Logging, System Time, Batch Jobs, and Users

System logging, the structure of /etc, user management files, getty and login, setting the time, scheduling tasks with cron, systemd timer units and at, user access topics and Pluggable Authentication Modules.

Chapter 8: A Closer Look at Processes and Resource Utilization

Tracking processes, finding open files with lsof, tracing program execution and system calls, threads, resource monitoring and control groups (cgroups).

Chapters 9–10: Understanding Your Network and Its Configuration; Network Applications and Services

Chapter 9 builds networking from layers and packets through IP routing, IPv6, ICMP and DNS tools, kernel network interfaces, configuration managers, hostname resolution, TCP and UDP, DHCP, configuring Linux as a router, NAT, firewalls, ARP and NDP, and wireless networking. Chapter 10 moves up to services: network servers, the older inetd/xinetd, diagnostic tools, remote procedure calls, network security and sockets.

Chapter 11: Introduction to Shell Scripts

Script basics, quoting, special variables, exit codes, conditionals, loops, command substitution, temporary files, here documents, useful utilities, subshells and reading input, ending with when not to use shell scripts.

Chapters 12–14: Network File Transfer and Sharing; User Environments; A Brief Survey of the Linux Desktop and Printing

Copying files with rsync and sharing them with Samba, SSHFS, NFS and cloud storage; shell startup files and their pitfalls; and the desktop stack, comparing Wayland with the X Window System, D-Bus and printing.

Chapters 15–16: Development Tools; Introduction to Compiling Software from C Source Code

The C compiler, make, lex and yacc, scripting languages and Java, then building software from source: build systems, GNU Autoconf, installation practice, applying patches and troubleshooting.

Chapter 17: Virtualization

New in this edition: virtual machines, containers and runtime-based virtualization.

Key Concepts

Chapters 1–4: Layers, shell and storage

• Kernel and user space: the division between the privileged kernel and the processes it manages.
• Device files and udev: how the kernel presents hardware as files and how device names are created.
• Filesystems, swap and LVM: how disks are partitioned, formatted and pooled into logical volumes.

Chapters 5–8: Booting and processes

• Boot sequence: firmware and boot loader (GRUB), kernel initialization and parameters, then init.
• systemd: the init system that starts and manages services, timers and logging.
• System calls and tracing: observing how a process asks the kernel for services.
• Control groups: kernel mechanism for limiting and accounting process resources.

Chapters 9–12: Networking

• Network layers: the physical, internet and transport layers, and how Linux configures each.
• Routing, NAT and firewalls: how packets are forwarded, translated and filtered.
• Sockets: the interface programs use to communicate over networks and locally.

Chapters 13–17: Users, development and virtualization

• Startup files: shell configuration that shapes each user's environment.
• Building from source: compilers, make, Autoconf and patches.
• Containers and virtual machines: isolating workloads by emulating machines or by sharing the host kernel.

Critical Analysis

Strengths

• A real system, examined directly. The sample chapter shows the method: each stage of boot is explained alongside the commands and log output that let the reader watch it on their own machine. This makes abstract ideas such as the kernel, init and system calls concrete.
• Coverage of the modern Linux stack. systemd, journald, cgroups, LVM, IPv6, Wayland and containers all have sections, reflecting the publisher's list of updates. Sandra Henry-Stocker, quoted by the publisher, notes that these changes are why a third edition was needed and describes the book as thorough and up to date.
• Usable as a reference. Lee Teschler (Microcontroller Tips, quoted by the publisher) found the book organized so that readers can go only as far into a topic as they need, and Ian Bruntlett's recommendation in C Vu (ACCU, vol. 33, no. 4) describes it as an overview with pointers for diving deeper.

Limitations

• Linux, not operating systems in general. The book explains how one system is put together and administered; scheduling algorithms, memory-management theory, synchronization and file-system design principles are not chapter topics, so it does not replace an operating systems textbook.
• Practical detail ages. Much of the value lies in specific commands, files and tools, which change with distributions and releases; the publisher maintains an errata list, and readers should check current documentation.
• Breadth over depth on some topics. Chapters such as the desktop survey and virtualization are short relative to their subjects, as their titles ("A Brief Survey", three sections on virtualization) suggest.

Where It Fits in the Course

This book is the practical companion in the operating systems course. Silberschatz, Galvin and Gagne's Operating System Concepts, Tanenbaum and Bos's Modern Operating Systems and Arpaci-Dusseau and Arpaci-Dusseau's free Operating Systems: Three Easy Pieces teach the concepts (processes, scheduling, memory, concurrency, file systems) in general terms; Ward shows where those concepts appear on a running Linux machine and how to inspect them. Read it alongside one of them: when a textbook chapter covers processes or file systems, use Chapters 4 and 8 here to see them in practice.

Saltzer and Kaashoek's Principles of Computer System Design works at a more general level, on abstraction, modularity, naming, protection and communication as design principles for computer systems; Ward's chapters on layers, networking and virtualization supply concrete Linux examples of those ideas.

How to Use This Book

The book suits students who need hands-on Linux experience to support an operating systems or networking course, new system administrators and developers who want to understand the machines they deploy to. Basic computer literacy and a willingness to use a command line are enough to start; programming helps for Chapters 15–16.

A practical plan:

• Core: Chapters 1–2 first, then Chapters 3–8 in order. These cover the system from the hardware up through booting, configuration and processes, and map most directly onto operating systems course topics.
• Networking: Chapters 9–10, essential for anyone running servers; Chapter 12 builds on them.
• Skills: Chapter 11 on shell scripting and Chapter 13 on user environments, best read with a terminal open.
• Optional by interest: Chapter 14 (desktop), Chapters 15–16 (development and building software) and Chapter 17 (virtualization), the last a useful bridge to containers.

Work through the book on a Linux machine or virtual machine you can break safely. Run the commands each section shows, compare the output with the book, and when something differs, check the distribution's documentation and the publisher's errata. Pair each chapter with the corresponding concept chapter of your operating systems textbook.