最新章節

• Index
• Summary
• Further reading
• Measuring scheduling latencies
• Interrupt shielding
• Avoiding page faults in a real-time application

• Index 更新時間：2021-07-30 09:45:30
• Summary
• Further reading
• Measuring scheduling latencies
• Interrupt shielding
• Avoiding page faults in a real-time application
• High resolution timers
• Getting the PREEMPT_RT patches
• Preemptible kernel locks
• Threaded interrupt handlers
• The real-time Linux kernel (PREEMPT_RT)
• Kernel preemption
• Understanding scheduling latency
• Identifying the sources of non-determinism
• What is real-time?
• Chapter 14. Real-time Programming
• Summary
• Using strace to show system calls
• Helgrind
• Callgrind
• Using Valgrind for application profiling
• Using LTTng
• Introducing Ftrace
• Tracing events
• Other profilers: OProfile and gprof
• Introducing perf
• Profiling with top
• Beginning to profile
• The observer effect
• Chapter 13. Profiling and Tracing
• Summary
• Additional reading
• Debugging kernel code
• GDB user interfaces
• Core files
• Debugging forks and threads
• Just-in-time debugging
• Debugging shared libraries
• Starting to debug
• Remote debugging using gdbserver
• Debugging applications using GDB
• Preparing to debug
• The GNU debugger
• Chapter 12. Debugging with GDB
• Summary
• Further reading
• Running out of memory
• Identifying memory leaks
• Per-process memory usage
• How much memory does my application use?
• Mapping memory with mmap
• Swap
• Process memory map
• User space memory layout
• Kernel space memory layout
• Virtual memory basics
• Chapter 11. Managing Memory
• Summary
• Further reading
• Scheduling
• Threads
• Processes
• Process or thread?
• Chapter 10. Learning About Processes and Threads
• Summary
• Further reading
• systemd
• System V init
• BusyBox init
• Introducing the init programs
• After the kernel has booted
• Chapter 9. Starting up - the init Program
• Summary
• Additional reading
• Discovering hardware configuration
• Loading kernel modules
• Writing a kernel device driver
• Device drivers in user-space
• Finding the right device driver
• Finding out about drivers at runtime
• Network devices
• Block devices
• Character devices
• The role of device drivers
• Chapter 8. Introducing Device Drivers
• Summary
• Further reading
• Updating in the field
• Filesystem choices
• Making the root filesystem read-only
• Temporary filesystems
• Read-only compressed filesystems
• Filesystems for managed flash
• Filesystems for NOR and NAND flash memory
• Filesystems for flash memory
• Accessing flash memory from Linux
• Accessing flash memory from the bootloader
• Storage options
• Chapter 7. Creating a Storage Strategy
• Summary
• Further reading
• The Yocto Project
• Buildroot
• Package formats and package managers
• Build systems
• No more rolling your own embedded Linux
• Chapter 6. Selecting a Build System
• Summary
• Additional reading
• Using TFTP to load the kernel
• Mounting the root filesystem using NFS
• Creating filesystem images with device tables
• Configuring the network
• A better way of managing device nodes
• Starting a daemon process
• Configuring user accounts
• The init program
• Creating a boot ramdisk
• Transfering the root filesystem to the target
• Kernel modules
• The proc and sysfs filesystems
• Device nodes
• Libraries for the root filesystem
• Programs for the root filesystem
• What should be in the root filesystem?
• Chapter 5. Building a Root Filesystem
• Summary
• Additional reading
• Porting Linux to a new board
• Booting your kernel
• Cleaning kernel sources
• Compiling
• Building the kernel
• Choosing a kernel
• What does the kernel do?
• Chapter 4. Porting and Configuring the Kernel
• Summary
• Barebox
• U-Boot
• Choosing a bootloader
• Introducing device trees
• Moving from bootloader to kernel
• Booting with UEFI firmware
• The boot sequence
• What does a bootloader do?
• Chapter 3. All About Bootloaders
• Summary
• Problems with cross compiling
• The art of cross compiling
• Linking with libraries: static and dynamic linking
• Looking at the components of the C library
• Other tools in the toolchain
• Anatomy of a toolchain
• Finding a toolchain
• Choosing the C library
• Types of toolchain - native versus cross toolchain
• What is a toolchain?
• Chapter 2. Learning About Toolchains
• Summary
• Software used in this book
• Hardware used in this book
• Hardware for embedded Linux
• Open source
• Project lifecycle
• The players
• Selecting the right operating system
• Chapter 1. Starting Out
• Customer support
• Reader feedback
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Support files eBooks discount offers and more
• www.PacktPub.com
• About the Reviewers
• About the Author
• Foreword
• Credits
• 版權頁
• 封面

• 封面
• 版權頁
• Credits
• Foreword
• About the Author
• About the Reviewers
• www.PacktPub.com
• Support files eBooks discount offers and more
• Preface
• What this book covers
• What you need for this book
• Who this book is for
• Conventions
• Reader feedback
• Customer support
• Chapter 1. Starting Out
• Selecting the right operating system
• The players
• Project lifecycle
• Open source
• Hardware for embedded Linux
• Hardware used in this book
• Software used in this book
• Summary
• Chapter 2. Learning About Toolchains
• What is a toolchain?
• Types of toolchain - native versus cross toolchain
• Choosing the C library
• Finding a toolchain
• Anatomy of a 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
• Summary
• Chapter 3. All About Bootloaders
• What does a bootloader do?
• The boot sequence
• Booting with UEFI firmware
• Moving from bootloader to kernel
• Introducing device trees
• Choosing a bootloader
• U-Boot
• Barebox
• Summary
• Chapter 4. Porting and Configuring the Kernel
• What does the kernel do?
• Choosing a kernel
• Building the kernel
• Compiling
• Cleaning kernel sources
• Booting your kernel
• Porting Linux to a new board
• Additional reading
• Summary
• Chapter 5. Building a Root Filesystem
• What should be in the root filesystem?
• Programs for the root filesystem
• Libraries for the root filesystem
• Device nodes
• The proc and sysfs filesystems
• Kernel modules
• Transfering the root filesystem to the target
• Creating a boot ramdisk
• The init program
• Configuring user accounts
• Starting a daemon process
• A better way of managing device nodes
• Configuring the network
• Creating filesystem images with device tables
• Mounting the root filesystem using NFS
• Using TFTP to load the kernel
• Additional reading
• Summary
• Chapter 6. Selecting a Build System
• No more rolling your own embedded Linux
• Build systems
• Package formats and package managers
• Buildroot
• The Yocto Project
• Further reading
• Summary
• Chapter 7. Creating a Storage Strategy
• Storage options
• 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
• Temporary filesystems
• Making the root filesystem read-only
• Filesystem choices
• Updating in the field
• Further reading
• Summary
• Chapter 8. Introducing Device Drivers
• The role of device drivers
• Character devices
• Block devices
• Network devices
• Finding out about drivers at runtime
• Finding the right device driver
• Device drivers in user-space
• Writing a kernel device driver
• Loading kernel modules
• Discovering hardware configuration
• Additional reading
• Summary
• Chapter 9. Starting up - the init Program
• After the kernel has booted
• Introducing the init programs
• BusyBox init
• System V init
• systemd
• Further reading
• Summary
• Chapter 10. Learning About Processes and Threads
• Process or thread?
• Processes
• Threads
• Scheduling
• Further reading
• Summary
• Chapter 11. Managing Memory
• Virtual memory basics
• Kernel space memory layout
• User space memory layout
• Process memory map
• Swap
• Mapping memory with mmap
• How much memory does my application use?
• Per-process memory usage
• Identifying memory leaks
• Running out of memory
• Further reading
• Summary
• Chapter 12. Debugging with GDB
• The GNU debugger
• Preparing to debug
• Debugging applications using GDB
• Remote debugging using gdbserver
• Starting to debug
• Debugging shared libraries
• Just-in-time debugging
• Debugging forks and threads
• Core files
• GDB user interfaces
• Debugging kernel code
• Additional reading
• Summary
• Chapter 13. Profiling and Tracing
• The observer effect
• Beginning to profile
• Profiling with top
• Introducing perf
• Other profilers: OProfile and gprof
• Tracing events
• Introducing Ftrace
• Using LTTng
• Using Valgrind for application profiling
• Callgrind
• Helgrind
• Using strace to show system calls
• Summary
• Chapter 14. Real-time Programming
• What is real-time?
• Identifying the sources of non-determinism
• Understanding scheduling latency
• Kernel preemption
• The real-time Linux kernel (PREEMPT_RT)
• Threaded interrupt handlers
• Preemptible kernel locks
• Getting the PREEMPT_RT patches
• High resolution timers
• Avoiding page faults in a real-time application
• Interrupt shielding
• Measuring scheduling latencies
• Further reading
• Summary
• Index 更新時間：2021-07-30 09:45:30