4 days (In-Person) 8 hours per day or 5 sessions (Live Online) 6 hours per session
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 provides 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
Format of Live Online Training
The format of Live ONLINE training from Doulos is focused on delivery of a single 6 hour intensive session per day. This includes live tuition and class interaction with the Doulos subject matter expert during the full scope of each session.
Labs are incorporated within the 6 hour sessions with the Doulos lab platform providing individual (private) tutor support at all times for each delegate. On occasion, labs may require time outside of the 6 hour session to complete. Additional lab material is available in some subjects for individuals to reinforce their understanding of the course content.
Hardware
A QEMU software solution is used which emulates real hardware and most of the labs are identical. The QEMU emulator can be booted and interacted with like a real hardware target using virtualized serial and ethernet connections.
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
