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 a minimal embedded system and booting it
    6. Contents of the resulting filesystem image
    7. Parallel builds
    8. Full and partial rebuilds
  2. Design goals of Buildroot
  3. Key Decisions
    1. C library: glibc, uClibc, or musl?
    2. Init system: busybox vs sysVinit vs systemd
    3. Managing device nodes in /dev
    4. Selecting additional packages
  4. Understanding Build Instructions
    1. Syntax of Kconfig (Config.in) files
    2. Features of GNU Make utilized by Buildroot Makefiles
    3. Style guide for Config.in and *.mk files
    4. Adding 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. Analyzing Build Results
    1. Identifying what consumed significant build time
    2. Identifying what consumed significant disk space
    3. Understanding why a specific package was built
  6. Organizing 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. Viewing build logs
  8. Addressing Common Cross-Compilation Issues
    1. Writing software that is compatible with cross-compilers
  9. Workflow for Kernel Developers
    1. How the kernel boots on an embedded system
    2. Changing configuration options and adding patches
    3. Module loading mechanisms
  10. Creating 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 licenses

Requirements

  • Participants must have 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 GNU Make, Autotools, and identify other existing build systems.
  • Ideally, have maintained at least one Linux package, either as an upstream author or within a traditional Linux desktop distribution.
  • Previous experience with embedded development is not required and does not substitute for the knowledge of traditional Linux desktops outlined above.
 7 Hours

Number of participants


Price per participant

Upcoming Courses

Related Categories