Get in Touch

Course Outline

  1. Getting started
    1. Obtaining Buildroot
    2. Build system requirements
    3. Cross-compiler terminology: build, host, target, sysroot
    4. Selecting the correct target
    5. Building and booting a minimal embedded system
    6. Contents of the resulting filesystem image
    7. Parallel builds
    8. Full and partial rebuilds
  2. Design goals of Buildroot
  3. Key decisions to be made
    1. C library: glibc, uClibc, or musl?
    2. Init system: BusyBox, SysVinit, or systemd?
    3. Managing device nodes in /dev
    4. Selecting additional packages
  4. Understanding build instructions
    1. Syntax of Kconfig (Config.in) files
    2. GNU Make features used by Buildroot Makefiles
    3. Style guide for Config.in and *.mk files
    4. How to add a simple Autotools-based package
    5. Differences between staging and target directories
    6. The need for host packages
    7. Expressing dependencies and optional features
    8. Support for languages other than C and build systems other than Autotools
    9. Debugging Makefiles
    10. Rebuilding a single package
  5. Analysing build results
    1. What consumed the most build time?
    2. What occupied the most disk space?
    3. Why was this package built?
  6. Organising external package trees
  7. Workflow for application developers
    1. Using a local source directory
    2. Overriding build instructions
    3. Debugging your application
    4. Accelerating rebuilds
    5. Reviewing build logs
  8. Addressing common cross-compilation issues
    1. Writing cross-compiler-friendly software
  9. Workflow for kernel developers
    1. How the kernel boots on an embedded system
    2. Modifying configuration options and applying patches
    3. Module loading mechanisms
  10. Preparing a finished product
    1. Running daemons at startup
    2. Providing custom configuration files
    3. Available firmware update mechanisms
    4. Upgrading to a new Buildroot version
    5. Complying with open-source licences

Requirements

  • Participants must have previously built a kernel at least once for a traditional desktop (non-embedded) Linux system.
  • Understand the components that make up the Linux userspace on a desktop system.
  • Know how to generate and apply patches.
  • Be able to explain the concepts of GNU Make, Autotools, and other build systems.
  • Ideally, maintain at least one Linux package, either as an upstream author or within a traditional Linux desktop distribution.
  • Prior experience with embedded development is not required, but it does not replace the knowledge of traditional Linux desktops outlined above.
 7 Hours

Number of participants


Price per participant

Provisional Upcoming Courses (Require 5+ participants)

Related Categories