Yocto Project Embedded Linux Development

Install and validate the selected release’s Ubuntu 22.04 host packages, locale, filesystem, Git, and shell requirements.

Estimate build storage consumption and design a 100 GB workspace strategy using shared download and shared-state directories plus staged cleanup.

Clone the selected Poky branch and initialize an isolated build environment with oe-init-build-env.

Classify the source, build, downloads, shared-state, temporary work, and deployment directories as persistent, reproducible, or safely disposable.

Set BB_NUMBER_THREADS and PARALLEL_MAKE conservatively from the host’s CPU and 16 GB RAM constraints.

Select and configure the QEMU ARM machine, Poky distribution, and core-image-minimal target without modifying upstream metadata.

Build core-image-minimal and interpret BitBake’s parsing, scheduling, execution, and shared-state progress.

Locate a failed task’s console diagnostics, log, and generated run script, then identify its immediate cause.

Map the deployed kernel, root filesystem, boot metadata, and image manifest to their runtime roles.

Boot the generated image with runqemu and interact with its serial console.

Inspect the running target’s kernel, mounts, processes, memory, packages, and network interfaces.

Configure repeatable QEMU networking and SSH access for automated deployment and target-side testing.

Change one image configuration variable, rebuild, and identify which work BitBake reused.

Interpret recipe filenames and the SUMMARY, HOMEPAGE, LICENSE, PV, PR, and SECTION metadata fields.

Explain how FILESPATH, WORKDIR, UNPACKDIR, S, and B locate sources throughout a recipe.

Create a recipe skeleton for a local C source file supplied through SRC_URI, then execute and inspect its fetch and unpack tasks.

Fetch a public Git repository with SRC_URI and pin SRCREV to an immutable commit.

Derive a recipe version from source-control metadata without sacrificing reproducibility.

Configure LIC_FILES_CHKSUM and diagnose a license checksum change.

Add and refresh a source patch through SRC_URI with auditable patch metadata.

Diagnose representative fetch or unpack failures involving mirrors, revisions, checksums, credentials, and unexpected source layouts.

Apply BitBake’s weak, immediate, deferred, append, prepend, and removal assignment operators correctly.

Predict when nested variable references expand during metadata parsing and task execution.

Apply machine, distribution, class, and package overrides using current override syntax.

Use bitbake -e to trace a variable’s final value, expansion history, and contributing metadata files.

Write equivalent shell and Python BitBake functions that consume datastore variables.

Explain how inherit and INHERIT introduce classes, functions, variables, and tasks into metadata.

Set task flags that control working directories, cleanup, network access, and stamping behavior.

Add a custom task with explicit ordering and dependencies, then confirm its position in the execution graph.

Trace the default recipe pipeline from do_fetch through do_package and identify each task’s outputs.

Use BitBake task graphs and dependency data to distinguish task-order edges from build dependencies.

Inspect generated run scripts, exported environments, and logs for a shell or Python task.

Implement do_compile and do_install for a simple Makefile-free C program using Yocto’s cross tools.

Convert a suitable recipe to inherit autotools and verify out-of-tree configuration and staged installation.

Adapt the Git-backed application recipe to inherit cmake, honor Yocto’s toolchain configuration, and install into the destination directory.

Control optional build features with PACKAGECONFIG and verify the resulting configure arguments and dependencies.

Trace how recipe dependencies populate per-recipe sysroots for cross-compilation.

Distinguish DEPENDS, RDEPENDS, RRECOMMENDS, PROVIDES, and RPROVIDES by build-time and runtime effects.

Trace installed files from ${D} through package splitting, package-feed generation, and inclusion in an image root filesystem.

Split installed files into main, development, debug, configuration, and custom output packages with FILES overrides.

Resolve an installed-but-not-shipped QA error by assigning every staged file to an appropriate package.

Classify and fix representative ELF and packaging QA findings involving ldflags, dev-so, and already-stripped binaries.

Classify and fix representative contamination and dependency QA findings involving buildpaths and file-rdeps.

Use pkgdata utilities to identify a file’s owning package and inspect runtime package relationships.

Create a packagegroup, add it to an image, and verify its packages and dependencies on the QEMU target.

Create a custom application layer with bitbake-layers and validate its generated structure.

Explain how BBFILE_COLLECTIONS, BBFILE_PATTERN, BBFILE_PRIORITY, LAYERDEPENDS, and LAYERSERIES_COMPAT govern integration, including why layer priority is not a universal override for variable assignments.

Create a small bbclass that centralizes reusable behavior for multiple recipes.

Determine recipe selection when layer priority, recipe version, DEFAULT_PREFERENCE, and PREFERRED_VERSION interact.

Add a version-matched bbappend without copying or editing the upstream recipe.

Use FILESEXTRAPATHS in a bbappend to inject a patch or configuration file from the custom layer.

Scope bbappend changes with machine and distribution overrides so they affect only intended targets.

Use bitbake-layers diagnostics to locate active recipes, appends, overlays, dependencies, and flattened metadata.

Create a custom image recipe using the appropriate core-image class or an explicitly required upstream image recipe.

Distinguish IMAGE_INSTALL, CORE_IMAGE_EXTRA_INSTALL, IMAGE_FEATURES, and packagegroups as image-composition mechanisms.

Define a custom distribution configuration without altering Poky’s reference distribution.

Reconcile DISTRO_FEATURES, MACHINE_FEATURES, COMBINED_FEATURES, and feature backfilling for a target policy.

Select package format, init system, libc, and virtual providers through explicit distribution policy.

Create a Wic image layout with named partitions and verify the generated partition table.

Generate license manifests and SPDX output, then trace an image package back to its source license.

Enable build history and interpret changes in package versions, dependencies, files, and image size.

Trace the selected QEMU machine’s tune settings, kernel provider and revision, configuration inputs, boot path, and deployed image formats as a BSP contract.

Create a custom BSP layer and a derived QEMU machine configuration without copying or modifying the upstream machine file.

Use kernel menuconfig and diffconfig to isolate a deliberate kernel configuration change.

Persist a kernel configuration fragment through a bbappend and verify that the option reaches the built kernel.

Diagnose a kernel configuration fragment that is overridden, invalid, or incompatible with its dependencies.

Write a recipe for an out-of-tree kernel module and load the resulting module on the QEMU target.

Modify and compile a device-tree source for an ARM QEMU experiment, then deploy the resulting DTB.

Boot with the modified device tree and validate the described hardware through boot logs and /proc/device-tree.

Diagnose a nothing-PROVIDES or unbuildable dependency chain by tracing provider and version selection.

Choose correctly among rerunning a task, forcing a task, clean, cleansstate, and cleanall during diagnosis.

Explain how base hashes, task hashes, dependency hashes, unihashes, and hash equivalence determine task reuse.

Use BitBake signature data and bitbake-diffsigs to identify the metadata that changed a task hash.

Differentiate legitimate signature invalidation, host-environment contamination, configuration drift, and a corrupt shared-state object through controlled cache and rebuild tests.

Trace an ignored override to its active OVERRIDES value and exact datastore assignment history.

Read generated dependency graphs to identify the minimal recipe or task responsible for an unexpected rebuild.

Resolve a configuration conflict by tracing its source and changing only the owning custom layer.

Explain how the devtool workspace layer changes recipe selection during iterative development.

Use devtool add to turn an external application source tree into an initial recipe.

Use devtool modify to extract and prepare the source of an existing upstream recipe.

Build a workspace recipe with devtool and deploy its output to a networked QEMU target.

Edit workspace source in a host IDE and validate the rebuilt change on the emulator.

Compare devtool update-recipe and devtool finish, then publish patches and metadata to the custom layer.

Distinguish a standard SDK from an extensible SDK by contents, update model, and intended workflow.

Generate, install, and initialize an extensible SDK, then cross-build a small application with it.

Integrate an application and its systemd service into the custom image, then verify enablement, startup ordering, logs, and restart behavior.

Safely interrupt and resume a BitBake build while identifying which task results remain reusable.

Establish a release baseline by pinning layer revisions and recording build configuration and image manifests.

Run Yocto’s CVE checking workflow and triage a representative finding as fixed, patched, configuration-dependent, or requiring remediation.

Express an image build and basic QEMU smoke test as repeatable continuous-integration steps.

Use devtool to extract an unfamiliar upstream application and locate an assigned defect in its source.

Patch the defect in a host IDE, rebuild it, deploy it, and capture evidence that the fix works in QEMU.

Finish the tested change into the custom layer, rebuild without the workspace, and produce a reviewable handoff containing the patch, metadata, licenses, and build evidence.