Chapter 1: Introduction
Advantages of Linux and open source systems
Introduction to the Yocto Project
Chapter 2: Cross-compiling
The Yocto Project reference
Chapter 3: Bootloaders
The role of the bootloader
Comparing various bootloaders
Delving into the bootloader cycle
Chapter 4: Linux Kernel
The role of the Linux kernel
Delving into the features of the Linux kernel
The Yocto Project reference
Chapter 5: The Linux Root Filesystem
Interacting with the root filesystem
Chapter 6: Components of the Yocto Project
Chapter 7: ADT Eclipse Plug-ins
The Application Development Toolkit
Chapter 8: Hob, Toaster, and Autobuilder
Chapter 9: Wic and Other Tools
Chapter 10: Real-time
Understanding GPOS and RTOS
Linux real-time applications
Chapter 11: Security
Security for the Yocto Project
Meta-security and meta-selinux
Chapter 12: Virtualization
Virtualization support for the Yocto Project
Chapter 13: CGL and LSB
Specific support for the Yocto Project
Chapter 14: The Build System
Setting up the host system
Creating a build directory
Building your first image
Explaining the Freescale Yocto ecosystem
Installing support for Freescale hardware
Building Wandboard images
Troubleshooting your Wandboard's first boot
Configuring network booting for a development setup
Sharing the shared state cache
Setting up a package feed
Working with build statistics
Debugging the build system
Chapter 15: The BSP Layer
Creating a custom BSP layer
Introducing system development workflows
Adding a custom kernel and bootloader
Explaining Yocto's Linux kernel support
Describing Linux's build system
Configuring the Linux kernel
Building the Linux kernel
Building external kernel modules
Debugging the Linux kernel and modules
Debugging the Linux kernel booting process
Using the kernel function tracing system
Debugging device tree issues
Chapter 16: The Software Layer
Exploring an image's contents
Adding a new software layer
Selecting a specific package version and providers
Adding supported packages
Adding data, scripts, or configuration files
Managing users and groups
Using the sysvinit initialization manager
Using the systemd initialization manager
Installing package-installation scripts
Reducing the Linux kernel image size
Reducing the root filesystem image size
Analyzing your system for compliance
Working with open source and proprietary code
Chapter 17: Application Development
Preparing and using an SDK
Using the Application Development Toolkit
Developing GTK+ applications
Developing Qt applications
Describing workflows for application development
Working with the GNU build system
Working with the CMake build system
Working with the SCons builder
Developing with libraries
Working with the Linux framebuffer
Using the X Windows system
Adding Python applications
Integrating the Oracle Java Runtime Environment
Integrating the Open Java Development Kit
Integrating Java applications
Chapter 18: Debugging, Tracing, and Profiling
Using strace for application debugging
Using the kernel's performance counters
Using static kernel tracing
Using dynamic kernel tracing
Using dynamic kernel events
Exploring Yocto's tracing and profiling tools
Tracing and profiling with perf
Chapter 19: Starting Out
Selecting the right operating system
Hardware for embedded Linux
Hardware used in this book
Software used in this book
Chapter 20: Learning About Toolchains
Types of toolchain - native versus cross toolchain
Other tools in the toolchain
Looking at the components of the C library
Linking with libraries: static and dynamic linking
The art of cross compiling
Problems with cross compiling
Chapter 21: All About Bootloaders
What does a bootloader do?
Booting with UEFI firmware
Moving from bootloader to kernel
Chapter 22: Porting and Configuring the Kernel
Porting Linux to a new board
Chapter 23: Building a Root Filesystem
What should be in the root filesystem?
Programs for the root filesystem
Libraries for the root filesystem
The proc and sysfs filesystems
Transfering the root filesystem to the target
Configuring user accounts
Starting a daemon process
A better way of managing device nodes
Creating filesystem images with device tables
Mounting the root filesystem using NFS
Using TFTP to load the kernel
Chapter 24: Selecting a Build System
No more rolling your own embedded Linux
Package formats and package managers
Chapter 25: Creating a Storage Strategy
Accessing flash memory from the bootloader
Accessing flash memory from Linux
Filesystems for flash memory
Filesystems for NOR and NAND flash memory
Filesystems for managed flash
Read-only compressed filesystems
Making the root filesystem read-only
Chapter 26: Introducing Device Drivers
The role of device drivers
Finding out about drivers at runtime
Finding the right device driver
Device drivers in user-space
Writing a kernel device driver
Discovering hardware configuration
Chapter 27: Starting up - the init Program
After the kernel has booted
Introducing the init programs
Chapter 28: Learning About Processes and Threads
Chapter 29: Managing Memory
Kernel space memory layout
How much memory does my application use?
Chapter 30: Debugging with GDB
Debugging applications using GDB
Remote debugging using gdbserver
Debugging shared libraries
Debugging forks and threads
Chapter 31: Profiling and Tracing
Other profilers: OProfile and gprof
Using Valgrind for application profiling
Using strace to show system calls
Chapter 32: Real-time Programming
Identifying the sources of non-determinism
Understanding scheduling latency
The real-time Linux kernel (PREEMPT_RT)
Threaded interrupt handlers
Getting the PREEMPT_RT patches
Avoiding page faults in a real-time application
Measuring scheduling latencies
![Learning Object Oriented Programming with C# 7 [Video]](https://proxy-ga.blitzz.co/proxy/123456/web.archive.org/web/20171118225851im_/https:/d255esdrn735hr.cloudfront.net/sites/default/files/imagecache/featured_book_block/bookretailers/V07834_MockupCover.png)
