Yocto Project Embedded Linux Development

Explain how metadata, configuration, tasks, and shared state produce deterministic build artifacts.

Select a maintained Yocto LTS branch and use its matching documentation and release notes.

Validate an Ubuntu 22.04 host against the selected release’s package, locale, filesystem, and shell requirements.

Estimate build storage consumption and configure a cleanup strategy suitable for a 100 GB workspace.

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

Explain the purposes of source, build, downloads, shared-state, temporary, and deployment directories.

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

Identify the machine, distribution, and image selections that define a BitBake build target.

Configure an ARM QEMU machine in local.conf without modifying upstream metadata.

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

Locate task logs and diagnose a failed task from its console error and log files.

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.

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

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.

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

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

Create a minimal recipe that builds a local C source file supplied through SRC_URI.

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.

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

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

Inspect fetch and unpack outputs to verify mirrors, revisions, checksums, and source layout.

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.

Create a CMake-based recipe that honors Yocto’s toolchain file and installs into the destination directory.

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

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

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

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

Install recipe outputs into D using standard target filesystem variables rather than host paths.

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.

Diagnose file-rdeps, dev-so, buildpaths, ldflags, and already-stripped QA findings without disabling checks blindly.

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 layer integration.

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.

Apply machine-, distribution-, class-, and package-specific overrides at the correct metadata scope.

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

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

Create a custom image recipe that inherits an appropriate base image and adds project content.

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.

Explain how machine configuration, tune settings, virtual/kernel, bootloader choices, and image formats form a BSP contract.

Identify the selected kernel provider, source revision, configuration inputs, and deployed outputs for the QEMU machine.

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.

Use task logs, task environments, and generated scripts to reproduce the exact context of a failed task.

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, and signatures determine task reuse.

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

Diagnose unexpected shared-state misses caused by host environment leakage or configuration differences.

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.

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.

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

Integrate an application and its systemd service into the custom image and verify service startup.

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.

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.