最新章節(jié)
- Index
- Summary
- Further reading
- Measuring scheduling latencies
- Interrupt shielding
- Avoiding page faults in a real-time application
品牌：中圖公司
上架時(shí)間：2021-07-30 09:37:54
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Index 更新時(shí)間：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
- 版權(quán)頁(yè)
- 封面
- 封面
- 版權(quán)頁(yè)
- 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 更新時(shí)間：2021-07-30 09:45:30
