
Linux: Embedded Development
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
All prices
More details
Other editions
Additional editions
Content
- Cover
- Copyright
- Credits
- Preface
- Table of Contents
- Module 1: Learning Embedded Linux Using the Yocto Project
- Chapter 1: Introduction
- Advantages of Linux and open source systems
- Embedded systems
- Introducing GNU/Linux
- Introduction to the Yocto Project
- Summary
- Chapter 2: Cross-compiling
- Introducing toolchains
- Components of toolchains
- Delving into C libraries
- Working with toolchains
- The Yocto Project reference
- Summary
- Chapter 3: Bootloaders
- The role of the bootloader
- Comparing various bootloaders
- Delving into the bootloader cycle
- The U-Boot bootloader
- The Yocto Project
- Summary
- Chapter 4: Linux Kernel
- The role of the Linux kernel
- Delving into the features of the Linux kernel
- Interrupts
- Timers
- Linux kernel interaction
- Kernel sources
- Devices and modules
- Debugging a kernel
- The Yocto Project reference
- Summary
- Chapter 5: The Linux Root Filesystem
- Interacting with the root filesystem
- Understanding BusyBox
- Minimal root filesystem
- The Yocto Project
- Summary
- Chapter 6: Components of the Yocto Project
- Poky
- Eclipse ADT plug-ins
- Hob and Toaster
- Autobuilder
- Lava
- Wic
- Summary
- Chapter 7: ADT Eclipse Plug-ins
- The Application Development Toolkit
- Eclipse IDE
- Summary
- Chapter 8: Hob, Toaster, and Autobuilder
- Hob
- Toaster
- Autobuilder
- Summary
- Chapter 9: Wic and Other Tools
- Swabber
- Wic
- LAVA
- Summary
- Chapter 10: Real-time
- Understanding GPOS and RTOS
- PREEMPT_RT
- Linux real-time applications
- Benchmarking
- Meta-realtime
- Summary
- Chapter 11: Security
- Security in Linux
- SELinux
- Grsecurity
- Security for the Yocto Project
- Meta-security and meta-selinux
- Summary
- Chapter 12: Virtualization
- Linux virtualization
- Virtualization support for the Yocto Project
- Summary
- Chapter 13: CGL and LSB
- Linux Standard Base
- Carrier grade options
- Specific support for the Yocto Project
- Summary
- Module 2: Embedded Linux Projects Using Yocto Project Cookbook
- Chapter 1: The Build System
- Introduction
- Setting up the host system
- Installing Poky
- 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 downloads
- Sharing the shared state cache
- Setting up a package feed
- Using build history
- Working with build statistics
- Debugging the build system
- Chapter 2: The BSP Layer
- Introduction
- 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
- Managing the device tree
- Debugging device tree issues
- Chapter 3: The Software Layer
- Introduction
- Exploring an image's contents
- Adding a new software layer
- Selecting a specific package version and providers
- Adding supported packages
- Adding new 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
- Releasing software
- Analyzing your system for compliance
- Working with open source and proprietary code
- Chapter 4: Application Development
- Introduction
- Preparing and using an SDK
- Using the Application Development Toolkit
- Using the Eclipse IDE
- Developing GTK+ applications
- Using the Qt Creator IDE
- Developing Qt applications
- Describing workflows for application development
- Working with GNU make
- 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
- Using Wayland
- Adding Python applications
- Integrating the Oracle Java Runtime Environment
- Integrating the Open Java Development Kit
- Integrating Java applications
- Chapter 5: Debugging, Tracing, and Profiling
- Introduction
- Analyzing core dumps
- Native GDB debugging
- Cross GDB debugging
- 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
- Using SystemTap
- Using OProfile
- Using LTTng
- Using blktrace
- Module 3: Mastering Embedded Linux Programming
- 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
- Bibliography
System requirements
File format: ePUB
Copy protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (not Kindle).
The file format ePub works well for novels and non-fiction books – i.e., „flowing” text without complex layout. On an e-reader or smartphone, line and page breaks automatically adjust to fit the small displays.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our ebook Help page.
File format: PDF
Copy-Protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our eBook Help page.