Embedded Linux and Yocto Engineering

Navigate the Linux filesystem hierarchy and locate configuration, device, log, and executable files from the command line.

Construct shell pipelines using redirection, grep, find, sed, awk, and xargs to inspect build artifacts and logs.

Configure Linux users, groups, ownership, permissions, sudo access, and executable files for a development workspace.

Install and verify host development packages with APT while monitoring filesystem capacity and inode usage.

Inspect processes, signals, systemd units, and journal logs to diagnose a failed host service.

Configure an Ethernet interface and diagnose DNS, routing, ports, and SSH connectivity with standard Linux tools.

Use Git to clone, branch, commit, rebase, create patches, and recover a working tree during an embedded-software change.

Build a multi-file C application with Make and diagnose a runtime defect using GDB.

Trace the hardware sequence from reset and boot-strap sampling through Boot ROM, PMIC and clock initialization, and DDR availability.

Distinguish build, host, and target systems and select an ARM64 ABI, C library, and cross-toolchain for a stated product constraint.

Inspect an ARM64 ELF file with file, readelf, objdump, and nm to identify its ABI, sections, symbols, interpreter, and shared dependencies.

Assemble a minimal BusyBox root filesystem with essential directories, configuration files, and an init process.

Trace an ARM SoC boot chain from Boot ROM through TPL or SPL, U-Boot Proper, the Linux kernel, and PID 1.

Configure a U-Boot environment and boot command that load a kernel, DTB, and initramfs from a specified storage device.

Trace memblock, buddy, and SLUB initialization together with driver-model population, kernel-thread creation, and root-filesystem mounting.

Configure and build a bootable Buildroot image for QEMU using an external toolchain and BusyBox userspace.

Produce a Buildroot SDK and use it to cross-build an application outside the Buildroot source tree.

Explain the roles and relationships of the Yocto Project, OpenEmbedded-Core, BitBake, Poky, distributions, machines, recipes, and layers.

Prepare an Ubuntu build host and initialize a release-compatible Poky build environment with oe-init-build-env.

Configure bblayers.conf and local.conf to select layers, machine, distribution, package format, downloads, and shared-state locations.

Build and boot a minimal QEMU image and identify the commands and artifacts required to reproduce the result.

Locate sources, task work directories, sysroots, package data, logs, stamps, shared state, and deployed images in a Yocto workspace.

Use BitBake commands to enumerate recipes, providers, tasks, dependency graphs, and active layer metadata.

Explain how task signatures determine shared-state reuse and demonstrate a cache hit after a metadata-preserving rebuild.

Tune thread counts, disk monitoring, cleanup, and download or shared-state storage for a 16 GB development host.

Predict the value of a BitBake variable after deferred, immediate, weak-default, append, prepend, remove, and override operations.

Use bitbake -e and datastore history to identify which metadata assignment produced an unexpected variable value.

Trace a recipe through fetch, unpack, patch, configure, compile, install, package, and package-write tasks.

Add a custom BitBake task with explicit ordering and implement a shell or Python pre-function for an existing task.

Write a recipe for a locally developed C application using SRC_URI, licensing checksums, reproducible source revisioning, and a raw Makefile.

Write a CMake-based recipe that obtains build-time dependencies from a recipe sysroot and declares correct runtime dependencies.

Package a versioned shared library into runtime and development outputs while resolving FILES, unversioned-so, RPATH, and installed-but-not-shipped QA errors.

Diagnose a failed recipe using log.do_*, run.do_*, devshell, forced single-task execution, and oe-pkgdata-util.

Create a custom layer with valid collection patterns, priority, dependencies, release compatibility, and yocto-check-layer results.

Extend an upstream recipe with a bbappend, FILESEXTRAPATHS, and a source patch without modifying the supplying layer.

Factor shared metadata into a bbclass or include file and expose an optional feature through PACKAGECONFIG.

Define a custom distribution that selects init system, C library, package format, and deliberate DISTRO_FEATURES.

Create a custom image and packagegroup that install the gateway software stack without relying on ad hoc IMAGE_INSTALL changes.

Configure deterministic users, groups, filesystem permissions, image sizing, and WIC or ext4 output in image metadata.

Generate a standard SDK and use its sysroots and environment script to build and remotely debug an application with gdbserver.

Use an extensible SDK and devtool to add, modify, build, deploy, and finish a recipe-backed source change.

Map the AM62x boot flow, memory, peripherals, debug interfaces, and boot media to the gateway board schematic and technical reference manual.

Create an AM62x machine configuration with correct tuning, serial console, machine features, image types, and virtual kernel or bootloader providers.

Flash a vendor-reference image, capture a serial boot baseline, and verify storage, Ethernet, USB, and basic peripheral enumeration.

Apply a kernel configuration fragment through Yocto and prove that the requested option is present in the deployed kernel.

Modify and validate a device tree to enable one board peripheral with correct pin multiplexing, clocks, interrupts, and status.

Package and load a simple out-of-tree kernel module using a Yocto module recipe.

Apply a U-Boot configuration or board patch and verify its environment storage and boot-target behavior on the board.

Describe and inspect the AM62x TF-A, OP-TEE, SPL, U-Boot, kernel, and firmware image assembly, including FIT or vendor image packaging.

Draw the runtime data flow and trust boundaries for an AM62x gateway connecting CAN-FD, Ethernet, persistent storage, management, and update services.

Bring up a CAN-FD interface with SocketCAN and verify nominal bitrate, data bitrate, frame transmission, error counters, and bus-off recovery.

Configure Ethernet addressing, routing, VLAN separation, time synchronization, and firewall rules for a two-network gateway scenario.

Implement and package a supervised CAN-to-IP gateway service with structured logging, restart policy, and bounded resource usage.

Load firmware on an AM62x remote processor with remoteproc and exchange a test message through RPMsg.

Compare TensorFlow Lite, ONNX Runtime, and vendor acceleration options for an embedded telemetry or anomaly-detection workload.

Convert or quantize a small pretrained model and package its runtime, model file, and configuration in the Yocto image.

Benchmark CPU and available accelerator inference for latency, throughput, memory, and power-oriented trade-offs using a repeatable input pipeline.

Partition gateway data into immutable system content, volatile runtime state, persistent configuration, logs, credentials, and update metadata.

Configure a read-only root filesystem with tmpfs, bind mounts, or overlayfs and verify operation across an abrupt reboot.

Create a WIC layout containing boot assets, redundant rootfs slots, persistent data, and bootloader environment storage.

Implement U-Boot slot selection using bootcount, bootlimit, upgrade_available, and an explicit last-known-good state transition.

Configure RAUC system and slot metadata to match the generated partition layout and bootloader backend.

Create and verify an X.509-signed RAUC bundle, install it into the inactive slot, and inspect bundle verification evidence.

Connect application health, watchdog reset, boot-attempt accounting, and userspace mark-good logic to demonstrate automatic rollback.

Design a staged fleet rollout and recovery procedure covering interrupted downloads, incompatible versions, key rotation, and rescue access.

Produce a threat model for the gateway covering physical access, network entry points, update infrastructure, build systems, and privileged software.

Design a development and production key hierarchy with offline roots, signing roles, rotation, revocation, and controlled access.

Trace the AM62x hardware root of trust from ROM verification through TF-A, OP-TEE, SPL, and U-Boot without performing irreversible fuse operations.

Sign a FIT image containing kernel, DTB, and initramfs and demonstrate that U-Boot rejects a modified component.

Configure dm-verity metadata for an immutable root filesystem and diagnose a deliberate block-integrity failure.

Enable and verify selected compiler, linker, kernel, and filesystem hardening controls in a Yocto distribution.

Constrain the gateway service with systemd capabilities and namespaces, a seccomp policy, and a minimal mandatory-access-control rule set.

Run Yocto CVE checking, validate whether one reported issue affects the product configuration, and document its patch or risk disposition.

Convert stakeholder needs into measurable gateway quality-attribute scenarios for boot time, latency, availability, security, update safety, and serviceability.

Produce a system architecture with hardware and software boundaries, boot and data flows, storage layout, interfaces, and failure-containment regions.

Record and defend architecture decisions for build system, BSP ownership, update strategy, security boundary, persistence model, and hardware selection.

Define repository, layer, branch, version, upstreaming, and long-term-support policies for a multi-team Yocto product.

Demonstrate reproducible output comparison while controlling source timestamps, host paths, tool versions, and release metadata.

Create a CI pipeline design that uses shared downloads and state caches, performs clean builds, and preserves signed release artifacts and logs.

Author an oeqa-style runtime acceptance test plan for QEMU and real hardware covering boot, networking, CAN, updates, rollback, and security checks.

Assemble a release evidence pack containing manifests, SPDX SBOM, license sources, CVE dispositions, test results, recovery instructions, and an ISO 21434 or Cyber Resilience Act traceability summary.