Book Image

Embedded Linux Development Using Yocto Project Cookbook - Second Edition

By : Alex Gonzalez
Book Image

Embedded Linux Development Using Yocto Project Cookbook - Second Edition

By: Alex Gonzalez

Overview of this book

The Yocto Project has become the de facto distribution build framework for reliable and robust embedded systems with a reduced time to market.You'll get started by working on a build system where you set up Yocto, create a build directory, and learn how to debug it. Then, you'll explore everything about the BSP layer, from creating a custom layer to debugging device tree issues. In addition to this, you’ll learn how to add a new software layer, packages, data, scripts, and configuration files to your system. You will then cover topics based on application development, such as using the Software Development Kit and how to use the Yocto project in various development environments. Toward the end, you will learn how to debug, trace, and profile a running system. This second edition has been updated to include new content based on the latest Yocto release.

Related Content you might be interested in

Current Title:

Small book image
Embedded Linux Development Using Yocto Project Cookbook - Second Edition
Alex Gonzalez
Jan, 2018 | 456 pages
Small book image
Embedded Linux Development using Yocto Projects
Otavio Salvador | Daiane Angolini
Nov, 2017 | 162 pages
Small book image
Embedded Linux Development Using Yocto Project
Otavio Salvador | Daiane Angolini
Apr, 2023 | 196 pages
Small book image
Mastering Embedded Linux Programming
Frank Vasquez | Chris Simmonds
May, 2021 | 758 pages
Table of Contents (13 chapters)
Title Page
Title Page
Dedication
Dedication
Packt Upsell
Packt Upsell
Foreword
Foreword
Contributors
Contributors
Preface
Preface
Free Chapter
1
The Build System
The Build System
Introduction
Setting up the host system
Installing Poky
Creating a build directory
Building your first image
Explaining the NXP Yocto ecosystem
Installing support for NXP hardware
Building Wandboard images
Using the Toaster web interface
Running a Toaster Docker container
Configuring network booting for a development setup
Using Docker as a Yocto build system container
Sharing downloads
Sharing the shared state cache
Setting up a package feed
Using build history
Working with build statistics
Debugging the build system
2
The BSP Layer
The BSP Layer
Introduction
Creating a custom BSP layer
Adding a custom kernel and bootloader
Building the U-Boot bootloader
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
3
The Software Layer
The Software Layer
Introduction
Exploring an image's contents
Adding a new software layer
Selecting a specific package version and provider
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 size
Memory-based root filesystems
Securing the root filesystem
Releasing software
Analyzing your system for compliance
Working with open source and proprietary code
4
Application Development
Application Development
Introduction
Introducing toolchains
Preparing an SDK
Using the extensible SDK
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 a web browser application
Adding Python applications
Integrating the Open Java Development Kit
Integrating Java applications
Integrating Node.js applications
Running Docker application containers
5
Debugging, Tracing, and Profiling
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 LTTng
Using blktrace
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Installing package installation scripts

The supported package formats, .rpm, .ipk, and .deb, support the addition of installation scripts that can be run at different times during a package installation process. In this recipe, we will see how to install them.

Getting ready

There are different types of installation script:

  • Pre-installation scripts (pkg_preinst): These are called before the package is unpacked
  • Post-installation scripts (pkg_postinst): These are called after the package is unpacked, and dependencies will be configured
  • Pre-removal scripts (pkg_prerm): These are called with installed or at least partially installed packages
  • Post-removal scripts (pkg_postrm): These are called after the package's files have been removed or replaced

How to do it...

An example snippet showing the installation of a pre-installation script in a recipe is as follows:

pkg_preinst_${PN} () { 
    # Shell commands 
}

All installation scripts work in the same way, with the exception that post-installation scripts...

Previous Section
End of Section 12
Next Section