9. Debugging with the Yocto Project | Embedded Linux Development with Yocto Project

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Embedded Linux Development with Yocto Project

By : Otavio Salvador

3.9 (20)

Embedded Linux Development with Yocto Project

3.9 (20)

By: Otavio Salvador

Overview of this book

A practical tutorial guide which introduces you to the basics of Yocto Project, and also helps you with its real hardware use to boost your Embedded Linux-based project. If you are an embedded systems enthusiast and willing to learn about compelling features offered by the Yocto Project, then this book is for you. With prior experience in the embedded Linux domain, you can make the most of this book to efficiently create custom Linux-based systems.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Meeting the Yocto Project

1. Meeting the Yocto Project

What is the Yocto Project?

Delineating the Yocto Project

Understanding Poky

The alliance of OpenEmbedded Project and Yocto Project

Summary

2. Baking Our Poky-based System

2. Baking Our Poky-based System

Configuring a host system

Downloading the Poky source code

Preparing the build environment

Knowing the local.conf file

Building a target image

Running images in QEMU

Summary

3. Using Hob to Bake an Image

3. Using Hob to Bake an Image

Building an image using Hob

Customizing an image with Hob

Summary

4. Grasping the BitBake Tool

4. Grasping the BitBake Tool

Understanding the BitBake tool

Exploring metadata

Parsing metadata

Dependencies

Preferring and providing recipes

Fetching the source code

Understanding BitBake's tasks

Generating a root filesystem image

Summary

5. Detailing the Temporary Build Directory

5. Detailing the Temporary Build Directory

Detailing the build directory

Constructing the build directory

Exploring the temporary build directory

Understanding the work directory

Understanding the sysroot directories

Summary

6. Assimilating Packaging Support

6. Assimilating Packaging Support

Using supported package formats

Understanding shared state cache

Explaining package versioning

Package feeds

Summary

7. Diving into BitBake Metadata

7. Diving into BitBake Metadata

Using metadata

Working with metadata

Summary

8. Developing with the Yocto Project

8. Developing with the Yocto Project

Deciphering the software development kit

Working with the Poky SDK

Developing applications on the target

Integrating with Eclipse

Summary

9. Debugging with the Yocto Project

9. Debugging with the Yocto Project

Differentiating metadata and application debugging

Tracking image, package, and SDK contents

Debugging packaging

Logging information during task execution

Utilizing a development shell

Using the GNU Project Debugger for debugging

Summary

10. Exploring External Layers

10. Exploring External Layers

Powering flexibility with layers

Detailing the layer's source code

Adding meta layers

Summary

11. Creating Custom Layers

11. Creating Custom Layers

Making a new layer

Adding metadata to the layer

Creating an image

Adding a package recipe

Writing a machine definition

Using a custom distribution

Machine features versus distro features

Understanding the variables scope

Summary

12. Customizing Existing Recipes

12. Customizing Existing Recipes

Common use cases

Adding extra options to recipes based on Autoconf

Applying a patch

Adding extra files to the existing packages

Changing recipe feature configuration

Customizing BusyBox

Customizing the linux-yocto framework

Summary

13. Achieving GPL Compliance

13. Achieving GPL Compliance

Understanding copyleft

Managing software licensing with Poky

Using Poky to achieve copyleft compliance

Summary

14. Booting Our Custom Embedded Linux

14. Booting Our Custom Embedded Linux

Exploring the Wandboard

Discovering Freescale ARM BSP

Using Wandboard with the Yocto Project

Building an image for Wandboard

Booting Wandboard from the SD card

Summary

A. References

A. References

Index

Index

Customer Reviews

3.9 (20)

5 star

40%

4 star

20%

3 star

35%

2 star

0%

1 star

5%

Utilizing a development shell

When editing packages or debugging build failures, a development shell can be a useful tool. When we use devshell, source files are extracted into the working directory, patches are applied, a new terminal is opened, and files are placed in the working directory.

In the new terminal, all the environment variables needed for the build are still defined, so we can use commands such as configure and make. The commands execute just as if the build system was executing them.

The following command is an example that uses devshell on a target named linux-yocto:

$: bitbake linux-yocto -c devshell

This allow us to rework the Linux kernel source code and build it in place, to avoid building it from scratch in our development machine, and change its code as needed.

Tip

It is important to bear in mind that all changes made inside devshell are not persistent between builds; thus, we must be careful to record any change that is important, prior to leaving it.

As we have the source...

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Embedded Linux Development with Yocto Project

Search

Your notes and bookmarks