Why GPLv3 becomes a problem in embedded products
Open source is ubiquitous in embedded Linux - kernel, U-Boot, BusyBox, libraries, tools. Most components are under GPLv2 or permissive licenses (MIT, BSD), which are manageable: provide source, include license text, document changes. GPLv3 goes further and can collide with product requirements that are common in embedded.
The critical point is anti-Tivoization: for "User Products", GPLv3 requires that "Installation Information" be conveyed alongside the object code - everything needed to install and execute modified versions on the device. Shipping a device with a signed bootloader that only accepts your own images may make this requirement impossible to meet without giving up the security architecture. This is exactly where secure boot and GPLv3 rub against each other.
Then there are procurement and compliance sides: many customers and tenders require a complete license list, source offers, and proof that no problematic licenses are in the image. "We did not know" is not a strategy - GPLv3 components sneak in through dependencies, often in tools nobody consciously installed. This article shows a workflow that makes them visible before the product ships.
GPLv2 vs GPLv3: the practical differences
Both licenses are copyleft: anyone distributing a derived version must license it under the same license and convey the Corresponding Source. For embedded products this means concretely: offer the source of the GPL components (including your own changes), include license text, make build scripts and recipes accessible. That is very doable with Yocto - the effort lies in discipline, not in technology.
GPLv3 adds three essential tightenings: first, the anti-Tivoization clause (Installation Information for User Products), which directly concerns signed bootloaders. Second, an explicit patent license - anyone conveying GPLv3 code grants downstream a patent license on their essential patent claims covering the code; that can be relevant for patent-holding products. Third, stricter termination and compatibility rules: GPLv3 is compatible with more licenses (e.g. Apache-2.0), but violations terminate rights faster.
For practice this means: GPLv2 components are usually unproblematic as long as source and license text are conveyed cleanly. GPLv3 components need an additional assessment - not because they are "worse", but because their requirements can collide with product decisions (signed updates, locked bootloaders, patent strategy). That assessment is an architecture and legal question, not a pure build question. A rule of thumb for practice: convey GPLv2 components and document them cleanly; assess GPLv3 components against the product architecture first and only then include them. Reversing that order builds facts first and looks for justification afterwards - the most expensive path through compliance.
Where GPLv3 hides
The usual suspects are standard Unix tools: bash, coreutils, grep, sed, gawk, tar, gzip, findutils, less, readline, parted, dosfstools, cpio, bc, ed, time. Plus LGPLv3 libraries such as gmp, libunistring, libidn2 and libelf - LGPL is less strict but is also captured by many compliance rules. Dual-licensed packages (e.g. "GPLv2+ | LGPLv3+") count depending on interpretation.
Good to know: the Linux kernel is under GPLv2 (not v3), U-Boot under GPLv2+, BusyBox under GPLv2. A minimal image of kernel, U-Boot and BusyBox is therefore often GPLv3-free - the Yocto Project explicitly tests the GPLv3-free build configuration only for core-image-minimal. Anyone installing packages beyond that must check.
The sneaking-in happens through three mechanisms: IMAGE_INSTALL pulls a package directly; PACKAGECONFIG enables optional features that carry their own dependencies (a library suddenly needs readline); and RDEPENDS of an innocuous package drags in a GPLv3 tool at runtime. None of these is visible in the image recipe alone - only the generated license manifest shows the full transitive picture. That is why auditing the manifest, not the recipe, is the reliable method.
- Shell and basic tools: bash, coreutils, grep, sed, gawk, tar, gzip, findutils
- Editors and pagers: less, ed, nano (GPLv3+)
- Libraries: readline, gmp (LGPLv3), libunistring (LGPLv3), libidn2, libelf (LGPLv3)
- Filesystem and partition tools: parted, dosfstools, cpio
- Bootloaders: GRUB (GPLv3+) - U-Boot is GPLv2+
- Developer tools in the image: gdb, binutils, GCC runtime (GPLv3 with runtime exception)
The anti-Tivoization conflict in detail
GPLv3 §6 defines "Installation Information" as any methods, procedures, authorization keys or other information required to install and execute modified versions of a covered work in a User Product. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. A "User Product" is a consumer product - regardless of whether it also has commercial or industrial uses, unless such uses are the only significant mode of use.
For a device with a HAB-closed bootloader this means: if the bootloader only accepts manufacturer-signed images and the manufacturer does not release the signing keys, the user cannot install a modified GPLv3 component that is part of the verified chain. The FSF calls exactly this state "tivoization" - free software that becomes effectively non-free on the hardware. GPLv3 aims to prevent it; a secure-boot design that signs the entire chain can conflict with that.
There are ways out that do not replace legal advice but relax the architecture: first, the ROM exception - the requirement does not apply if neither the manufacturer nor any third party can install modified object code (e.g. hard-wired ROM). Second, separation: GPLv3 components run outside the signed, verified chain (e.g. as a separate application on a writable area), so their modification does not touch the boot chain. Third, deliberate compliance: provide Installation Information where the product model allows it. Which option fits depends on the device, the market and the risk appetite - a technical license analysis supplies the facts for that decision.
License tracking in Yocto
Yocto tracks licenses at recipe level: every recipe sets LICENSE (e.g. "MIT", "GPL-3.0-only") and LIC_FILES_CHECKSUM (path plus checksum of the license file in the source). The latter ensures the license does not change unnoticed between builds. Standard license texts live in meta/files/common-licenses; the names there are the canonical license strings.
During the image build, Yocto generates a license manifest under ${DEPLOY_DIR}/licenses/${SSTATE_PKGARCH}/<image>-<machine>.rootfs-<datestamp>/. It lists per package: name, version, recipe and license - the reliable basis for any audit. Alongside it sit the package manifest (which packages are actually in the image) and the file-level license manifest. Looking only at installed packages misses build dependencies - but for shipping, the image is what counts.
An often overlooked point: LIC_FILES_CHECKSUM is a change detector. If an upstream update changes the license file (e.g. from GPLv2 to GPLv3, or a new copyright), the build fails until the checksum is deliberately updated. That is not a nuisance but a safety feature: license changes cannot slip in silently. Whoever updates the checksum should document the change in the recipe comment or commit - keeping traceable when and why a package license situation shifted.
# Example excerpt from a license manifest:
PACKAGE NAME: bash
PACKAGE VERSION: 5.0
RECIPE NAME: bash
LICENSE: GPLv3+
PACKAGE NAME: u-boot
VERSION: 2024.01
RECIPE NAME: u-boot
LICENSE: GPLv2+Shipping license texts and source
GPLv2 and GPLv3 require license text and Corresponding Source to be conveyed. Yocto makes this easy: COPY_LIC_MANIFEST and COPY_LIC_DIRS place license texts into the image (/usr/share/common-licenses and /usr/share/license), LICENSE_CREATE_PACKAGE builds a separate package with an upgrade path for later-installed software. Note: all three together produce two copies of the license files - that is expected, not a bug.
For source there is the archiver class: it archives the original sources of the captured licenses (COPYLEFT_LICENSE_INCLUDE) including patches and build scripts. A source release should comprise the modified sources, the recipes/layers and the build configuration - satisfying the "compilation scripts and source modifications" requirement. Shipping the entire DL_DIR is an alternative, but coarse and often incompletely patched.
For the source offer itself the detail matters: GPLv2 and GPLv3 allow, as an alternative to direct conveyance, a written offer to provide the source on request (GPLv3 §6b: valid for at least three years, as long as the product is offered). For embedded products with long support periods this is often the more practical variant - the image stays lean, and the offer ships alongside the license documentation. What matters is that the offer remains redeemable: whoever archives the source must be able to keep it available across the entire support period.
# local.conf or distro.conf - license texts into the image
COPY_LIC_MANIFEST = "1"
COPY_LIC_DIRS = "1"
LICENSE_CREATE_PACKAGE = "1"
# Archive copyleft sources for the source offer
INHERIT += "archiver"
COPYLEFT_LICENSE_INCLUDE = "GPL* LGPL*"
ARCHIVER_MODE[src] = "patched"Excluding GPLv3 deliberately
To avoid GPLv3, set INCOMPATIBLE_LICENSE in the distro or local configuration - not in the image recipe (there it only acts locally). The setting affects the whole dependency tree: packages with a blacklisted license are not built, and the image fails if a dependency still needs them. That is exactly the desired effect - the build error lists the offending packages with their licenses and becomes a to-do list.
In practice: a GPLv3-free core-image-minimal is tested; beyond that you need replacements. BusyBox replaces many GNU utilities (grep, sed, tar, gzip, coreutils) in a GPLv2 variant; for bash there are alternatives like ash/dash. Some packages can be removed, others are hard dependencies - then compliance remains instead of avoidance. Important: INCOMPATIBLE_LICENSE is a build filter, not a legal free pass; the final image license list remains the truth.
Related but opposite is LICENSE_FLAGS_ACCEPTED (formerly LICENSE_FLAGS_WHITELIST): it permits packages with commercial or special license flags that are otherwise excluded by default. Both mechanisms belong in the distro configuration under version control, not in a local sandbox - reproducible builds are the prerequisite for any reliable license audit. Setting the flags only locally yields an image whose license situation changes silently with the next build.
# Distro/local.conf - exclude GPLv3 family build-wide
INCOMPATIBLE_LICENSE = "GPL-3.0* LGPL-3.0* AGPL-3.0*"
# Per-image variant:
INCOMPATIBLE_LICENSE:pn-my-image = "GPL-3.0* LGPL-3.0*"
# The build error becomes the audit list, e.g.:
# ERROR: my-image-1.0-r0 do_rootfs: Packages have blacklisted licenses:
# bash (GPLv3+), coreutils (GPLv3+), grep (GPLv3), tar (GPLv3), ...SPDX and the Software Bill of Materials
Modern Yocto releases can generate SPDX documents (create-spdx class): a machine-readable SBoM with components, versions, licenses and patches. This meets part of the compliance requirements (license texts and source offers remain separate) and incidentally provides the basis for vulnerability assessments - CVE matching needs component plus version, and that is exactly what the SBoM contains.
For products with long lifecycles (energy monitoring, medical technology, industrial), the SBoM is doubly valuable: it documents the shipping state completely and makes later security updates plannable. Anyone aiming for CRA conformity cannot avoid a maintained SBoM anyway.
The SPDX output comes at two levels: an image-level document (the full SBoM of the shipping state) and recipe-level packages. For license checking the image SBoM is authoritative because it shows the transitive closure; the recipe SBoM helps trace individual components. Both formats are machine-readable (SPDX JSON or tag-value) and can be diffed in CI pipelines - a new entry with a GPL-3.0 license stands out immediately instead of first appearing in a customer audit.
# Generate SPDX SBoM alongside the image
INHERIT += "create-spdx"A practical risk-scan workflow
In summary, this yields a repeatable workflow that can be anchored in CI:
The right timing is before every release - and once deeply before the first shipment of a new product. A release scan compares the current license state with the previous one and flags changes; the deep scan assesses each GPLv3/LGPLv3 component against the product architecture. Together they cover the two failure types: unnoticed new dependencies and overlooked architecture conflicts. Running only the release scan misses the conflict that was always there; running only the deep scan misses the change that arrived yesterday.
- Build with license manifest and SPDX generation - the actual state is documented.
- Classify: group the manifest by license family (GPLv2, GPLv3, LGPLv3, permissive, commercial).
- Trace: for each GPLv3/LGPLv3 component, check the recipe and dependency chain - who pulled it in?
- Assess: does the license collide with the product architecture (anti-Tivoization, signed updates)? Is the device a "User Product"?
- Decide: replace (BusyBox/alternatives), isolate (separate processes, clear boundaries) or ship compliant (Installation Information, source offer).
- Report: a written risk report with a go/no-go recommendation - the basis for legal and procurement decisions.
The workflow is deliberately conservative: it does not replace legal advice, but it makes visible the technical facts on which every legal assessment rests. Most surprises arise not from bad intent but from unnoticed dependencies - a build that hard-excludes GPLv3 and a manifest anyone can read take away their stage.
If you want the scan done externally once - say before a tender or a customer audit - the Yocto Risk Scan offer has a fixed scope: build and license scan, written risk report and go/no-go summary.
In CI, the cheap part is worth automating: generate the manifest and SPDX on every release build, diff the license families against the previous release, and flag any new GPLv3/LGPLv3 entry for review. That turns compliance from a one-off audit into a continuous guard - a new dependency cannot slip into a shipping image unnoticed. The deeper assessment (anti-Tivoization, product classification) stays a human decision, but it starts from a clean, current manifest instead of archaeology.
