Dates Offered (click on the desired date to register):

This course is currently not scheduled for the near future.

Course Number:  LIN10

Course Description: 

This course is designed for participants with the basic Embedded Linux experience, or those who have taken the Embedded Linux or Fast Track to Embedded Linux courses that JHL offers. This is a fast paced, hands-on course that will get you quickly up to speed in how to design, create and implement drivers for character devices, block devices, and network interfaces. The participants will also learn the fundamentals of the Linux kernel, how it works, its components, memory management, file system, kernel debugging, and more. Further, participants will learn how to make the Linux kernel Real-time, as well as programming in real-time for Linux and how to create small Linux embedded systems with a Graphical Interface. GUI development using Nano-X and QT is covered in this course. The course will use ARM or MIPS (depending on your environment) development tool kits and boards for in-class labs.

Objectives: 

• Build a driver (character, USB, block or network)


• Build and load Kernel modules


• Debug a Kernel driver


• Understand portability issues


• Describe the Kernel Debugging Techniques


• Describe MTD Subsystems


• Describe the Linux kernel


• Use the Linux kernel


• Work with the Linux kernel


• Describe how threads work on the Linux Kernel


• Perform kernel debugging


• Describe Linux Real-time


• Use development tools


• Create processes and threads


• Describe the Linux Scheduler and Real Time Scheduler


• Describe the File Systems for embedded devices


• Describe Inter-Process/Threads Communications


• Configure and Install a GUI for the Embedded system


•  Describe device interfaces


• Create an embedded system with a GUI, a kernel, a file  system and some applications.

Benefits: 

This is an intense, hands-on, instructor led class. Course materials include real world exercises and examples, courseware, CD, and a textbook. Development boards are supplied.

Target Audience: 

Linux system developers, software engineers, programmers/developers tasked with learning how to enhance their embedded systems under Linux.

Prerequisites: 

Practical experience in C programming, 6-months practical experience using Linux including JHL’s course Fast Track to Embedded Linux or Embedded Linux or equal work related experience.

 

Course Length:  5 Days

CourseTopics:

Embedded Linux Kernels
BSPs and SDKs
Introduction to the Linux Kernel
                Linux Kernel: From the Embedded Perspective
                Basic Kernel Capabilities
                The Kernel
                Classes of devices and modules
                Security issues
                Version Numbering
Elements of the Kernel
                Processes, Task Switching, and Scheduling
                Unix Processes
                Address Spaces and Privilege Levels
                Page Tables
                Allocation of Physical Memory
                Timing
                Device Drivers, Block, and Character Devices
                Networks
                Filesystems
                Module and Hotplugging
                Caching
                List Handing
                Object Management and Reference Counting
                Data Types
Process Management and Scheduling
                Process Priorities
                Process Life Cycle
                Process Representation
                Process Management System Calls
                The Completely Fair Scheduling Class
                The Real-Time Scheduling Class
                Scheduler Enhancements
Memory Management
                Page Tables
                Initialization of Memory Management
                Management of Physical Memory
Virtual Process Memory 
                Virtual Process Address Space
                Principle of Memory Mappings
                Data Structures
                Operation on Regions
                Address Spaces
                Memory Mapping
Correction of Userspace Page Faults
Kernel Page Faults
Device Drivers
                I/O Architecture
                Access to Devices
                Association with the Filesystem
Building and Running Modules
                Using Modules
                Modules versus applications
                Compiling and loading 
                The kernel symbol table
                Initialization and shutdown
                Using resources
                Automatic and manual configuration
                Working in the user space
Char Drivers
                Design framework
                File operations
                The file structure
Enhance Char Drivers Operations
                ioctl
                Blocking I/O
                Select
                Asynchronous Notification
                Seeking a device
                Access control on a device file
Inter-process communication
                Synchronization in the kernel
                Communication via files
                Pipes
                Debugging using ptrace
System V IPC
                IPC with sockets   
The Linux file system
                Basic principles
                                Partitions
                                Mounting a File System
                Ext3, Ext4, JFFS2, YAFFS
                cramfs
                The representation of the file system in the kernel
                Filesystems without Persistem Storage
                                The proc Filesystem
                                Simple Filesystems
                                Sysfs
                MTD Subsystem
                                Enabling MTD Services
                                MTD Basics
                                Configuring MTD on your Target
                                MTD Partitions
                                Redboot Partition Table Partitioning
                                Kernel Command-Line Partitioning
                                Mapping Driver
                                Flash Chip Driver
                                Board Specific Initialization
                MTD Utilities
                                JFFS2 Root File Systems
                                UBI File System
                                YAFFS File Systems
Building and Running Modules Part II
                Time intervals in the kernel
                Knowing the current time
                Delaying execution
                Task queues 
                Kernel timers
                kmalloc function
                get_free_page
                vmalloc
Hardware Management
                Using I/O ports
                Using the parallel port
                                Preparing the parallel port
                Accessing memory on device boards
                Accessing the text-mode video buffer
                Interrupt handling
                                Installing an interrupt handler
                                Implementing a Handler
                                Interrupt sharing
                                Interrupt device I/O
                                Race Condition
Advanced modularization and Kerneld
                Loading modules on demand
                Version control in modules
                Persistent storage across Unload/Load
Basic Debugging Review
Embedded Application Debugging
                GDB and the GDB Server Debugger
                Debugging with printk and LTTng
                KGDB and KDB
                System Logs
                Crash Dumps and Post-Mortem Debugging
                Remote (Cross) Debugging
                Debugging with Shared Libraries
                Debugging Multiple Task
                Debugging Bootloader
                Kernel Probes
                Kexec and Kdump
                Kernel Profiling
DebugFS
                Configuring DebugFS
                DebugFS Capabilities
Advanced Logging
                LogFS
                Using logwatch and Swatch
                Using syslogd and syslog-ng
Kernel Hacking
                Configuring Kernel Hacking
                Kernel Hacking Capabilities
Profiling
                Basic Profiling
                Gprof and Oprofile
                Performace Counters
Measuring Embedded Linux Performance
                Ideas on Performance Measurement
                Common Considerations
                Bootloader Optimizations
                Boot Time Measurements
Addressing Performance Problems
                Types of Performance Problems
Using Performance Tools to Find Areas for improvements
Improving I/O and Device Driver Performance
Universal Serial Bus
Udev
Busybox and Linux Initialization
Using Busybox
                Configuring and Installing Busybox
Linux Real-Time
                Linux Real-Time Overview
                Real-Time Kernels
                                Soft Real Time
                                Hard Real Time
                Configuring Real-Time Kernels
                Development Tools
                Process and Thread Creation
                Linux Scheduler, Real-Time Scheduler
                Accessing Files
                Accessing Devices
                System Clock and Timer
                Inter-Process/Thread Synchronization
                Real-Time Kernel Path
                                Real-Time Features
                                O(I) Scheduler
                                Creating a Real-Time Process
Using Graphics Interfaces with Embedded Linux
                Windows Systems
                Configuring Window Systems
                Nano-X, QT, etc,
                Touch Screen devices
Bootloader
                U-Boot Boot loader
                Installing and configuring U-Boot
                Testing a New U-Boot
                Creating a Flash File System
Creating a entire system from start to end
Deploying Embedded Linux
Configuring your embedded system
Choosing and Building the Root Filesystem
Useful Embedded Filesystems
Choosing a GUI