Mastering Embedded Linux Programming Unleash the full potential of Embedded Linux with Linux 4.9 and Yocto Project 2.2 (Morty)… (Chris Simmonds)（Z-Library）

【One-Line Pitch】 A practical, end-to-end guide to building embedded Linux devices from scratch—toolchain, bootloader, kernel, root filesystem, and beyond—for engineers who want to understand what happens under the hood rather than just accept a vendor's board support package. 【Book Arc】 - **Opening (~0%–10%)**: Frames the five core elements of every embedded Linux system (toolchain, bootloader, kernel, root filesystem, plus your application) and explains the open-source licensing context you'll be working within. - **Early (~10%–35%)**: Builds the foundation hands-on—constructing a cross toolchain with crosstool-NG, understanding bootloaders (U-Boot, barebox, UEFI), device trees, and configuring/compiling the kernel. - **Middle (~35%–55%)**: Moves into the root filesystem: what a minimal rootfs needs, init and shell basics, and how the kernel hands off control to user space. - **Late (~55%–80%)**: Covers build automation with Buildroot and the Yocto Project, storage strategies for flash memory, and remote field updates for deployed devices. - **Ending (~80%–100%)**: Focuses on writing and hardening embedded code—hardware access from applications, multi-threaded programming, memory management, scheduling, and debugging/profiling applications and the kernel. 【Key Takeaways】 - **Embedded Linux is five composable elements, not a monolith** (Opening): toolchain, bootloader, kernel, root filesystem, and your application. Understanding each separately lets you replace vendor defaults with better choices. - **A cross toolchain is the first thing you build, and crosstool-NG is the practical path** (Early): Binutils, GCC, and a C library (glibc, musl, uClibc) form the standard GNU toolchain; crosstool-NG generates a standalone one from source. - **Bootloaders are staged and board-specific** (Early): U-Boot, barebox, and UEFI each follow a multi-phase boot sequence; device trees (compiled with `dtc`) describe hardware and let you layer board variants without duplicating code. - **Kernel configuration is where vendor support matters most** (Middle): Mainline Linux supports only a subset of devices, so you often depend on SoC vendor kernels—choose vendors who upstream their changes. - **The kernel's job ends at `init`** (Middle): A minimal root filesystem needs only `init`, a shell, and daemons; everything else is your responsibility to assemble. - **Buildroot and Yocto automate the whole pipeline** (Late): These build systems handle toolchain, kernel, rootfs, and package integration so you don't hand-roll every step. - **Field updates and power management are deployment concerns, not afterthoughts** (Late): Remote update strategy and power budgeting must be designed in, not bolted on. - **Debugging and profiling span both user space and kernel** (Ending): Application-level debugging, kernel debugging, and system profiling are distinct skills you'll need to find performance bottlenecks. 【Reading Tips】 - **Deep-read the early chapters on toolchain and bootloader**—these are the hardest to get right and the most vendor-specific; skimming them will cost you later. - **Skim the licensing discussion** if you already understand GPL v2 and kernel module implications; it's context, not technique. - **Treat the build-system chapters (Buildroot/Yocto) as reference**—read once for the workflow, then return when you actually configure a build. - **The debugging/profiling chapters are best read with a real target board in hand**; the techniques only stick when applied. - **Watch for version-specific details** (Linux 4.9, Yocto 2.2 Morty)—commands and configs may differ in newer releases. 【Coverage Limits】 The excerpts cover the book's structure, foundational concepts, and early-to-mid technical detail well, but the later chapters on remote updates, power management, and debugging are only summarized here—specific techniques and examples from those sections are not covered in depth.