Linux is being used more and more on embedded systems driven by increasingly complex devices and a greater requirement for connectivity & multimedia. Working with Linux for embedded systems can be difficult, with a vast array of choices available for tools and software. Developing With Embedded Linux is a 4-day course providing the practical skills and knowledge required to work with Linux in this environment.
The course provides an overview of what an embedded Linux system is comprised of and provides practical information about how to work with each of the components. At each stage there is a strong focus on what tools are available in Linux to understand and debug problems. How to configure an embedded Linux system is considered in detail, looking at the changes that need to be made as a project moves from a development phase into a product. The aim is to equip attendees with the skills they need to develop and maintain their embedded Linux based products in an efficient and effective way.
Workshops comprise approximately 50% of class time and are based around carefully designed exercises to reinforce and challenge the extent of learning.
The course mainly uses Linux open source tools with a discussion of some of the available commercial solutions where appropriate.
Course Overview Video
What will you learn?
An understanding of the structure of an embedded Linux system and how to work with the component parts
Practical information about developing, analysing and debugging kernel and user space applications using a wide range of freely available Linux tools
How to configure embedded Linux on the target, including the filesystem and the booting process
Pre-requisites
Completion of Linux Fundamentals training or equivalent basic knowledge of using Linux as a host operating system
Experience of working with embedded systems (e.g. using RTOS or bare machine)
Some familiarity with C programming is useful
Hardware
This is a hands-on training course and labs are conducted on a real target board.
For scheduled public courses the actual target board provided during the course may vary dependent on the location.
Target boards currently deployed include an NXP® i.MX6SX board featuring Arm® Cortex®-A9 and Cortex-M4 cores and boards based on the AMD Zynq™-7000 All Programmable SoC, featuring a dual Arm Cortex-A9 processor:
Doulos course materials are renowned for being the most comprehensive and user friendly available. Their unique style, content and coverage has made them sought after resources in their own right. The materials include fully indexed class notes creating a complete reference manual.
Structure and Content
Introduction
Course Objectives
Linux Background
Open-Source Software
Licensing
Embedded Linux Distributions
Development platforms
Host to target communications
Console command and version control
Exercises:
Booting a standard image
Establishing target communications
Exploring the target filesystem
Working with the Linux Kernel
Scheduling, real-time and memory
Kernel configuration
Building and booting the kernel
Board support
Kernel modules
Exercises:
Configuring and building the kernel
Creating a kernel module
Debugging the Linux Kernel
Kernel logs & printk
JTAG
KGDB/KDB
Exercises:
Using kernel logs
Using KGDB/KDB to debug a kernel module
Building Applications
Compiling on the target
Cross-compiling
Static and shared libraries
Using a portable build system (e.g. Autotools)
Exercises:
Cross-compiling
Creating static and shared libraries
Configuring and compiling an Autotools application
Debugging Applications
Compiling for debugging
Target debugging
Cross debugging
Other user space tools
Debugging user space seg faults
Exercises:
Target debugging
Cross-debugging a seg fault
Finding memory leaks with Valgrind
Generating and using core dumps
Linux Applications
How a Linux application can be structured
Managing processes and threads
Inter-process communications
Interfacing with the kernel
Exercises:
Simple IPC
Threads and processes
Configuring Filesystems
Filesystem contents
Init programs
BusyBox
Device management
Exercises:
Adding a daemon to init
Configuring and compiling BusyBox
Filesystem Locations
NFS
RAM filesystems
Block-based filesystems
Flash filesystems (JFFS2, UBIFS)
Exercises:
Creating an initramfs
Creating an early user space filesystem
Writing a UBIFS into flash
Configuring the Bootloader
The bootloader
Bootloader choices
Working with U-Boot
Porting U-Boot to a new board
Exercises:
Working with the U-Boot shell
Flashing a kernel image in U-Boot
Trace & Profile
Linux trace technology
SysProf
OProfile
FTrace
Perf
Other Tools
Use case examples
Exercises:
Investigating scp behaviour with trace & profile tools
