Merge branch 'glibc-hwcaps' into 'main'

populate-initrd: Ensure all hwcaps library variants are installed

See merge request plymouth/plymouth!474

populate-initrd: Ensure all hwcaps library variants are installed

Handle glibc-hwcaps shared libraries specially by ensuring all
architecture-specific variants of the library are installed, not just
the variant being used on the current architecture. Otherwise, the
initrd might fail to work when built on a system with a different
CPU microarchitecture (for example, x86-64-v3 vs x86-64-v4) than that of
the system it's installed on.

Merge branch 'kmsg-overflow-recovery' into 'main'

ply-kmsg-reader: Recover from /dev/kmsg overflow

Closes #341

See merge request plymouth/plymouth!473

tests: Cover kernel message overflow recovery

The kmsg reader now keeps its descriptor and watch after EPIPE while
clearing them for terminal reads and real disconnects. Event-loop coverage
exercises readiness without FIONREAD.

The kmsg tests cover both teardown paths but not recoverable overflow. A
stale or prematurely released watch can return without a targeted failure.

This commit drives EPIPE through a reader with a real event-loop watch,
verifies that both stored handles remain live, then stops the reader to
prove the watch remains usable.

Together, the lifecycle, readiness, and overflow tests cover the reported
path from notification through shutdown. The series preserves
kernel-message delivery without leaving a dangling watch.

ply-kmsg-reader: Recover from overwritten messages

The event loop now delivers /dev/kmsg readiness even when error bits
accompany it. The reader safely resets its state for terminal results.

/dev/kmsg uses EPIPE to report that unread records were overwritten and
moves the cursor to the oldest available record. Treating that result as
terminal stops delivery of later kernel messages.

This commit recognizes EPIPE as a recoverable overflow indication and
leaves the descriptor plus its watch active. Level-triggered readiness then
schedules another read at the updated cursor.

The final commit will verify that overflow preserves a live watch through a
subsequent stop.

tests: Cover ready descriptors without FIONREAD

The event loop now dispatches requested status for descriptors that reject
FIONREAD while retaining disconnects for unmatched error or hangup events.

The event-loop tests do not exercise a ready descriptor where the ioctl is
unavailable. A failed probe can return to the disconnect path without a
targeted test failure.

This commit uses a reaped pidfd, which reports readiness with a hangup and
rejects FIONREAD, to verify that the readiness callback runs before the
disconnect callback.

The next commit will keep the kmsg watch active after read reports an
overwritten record. The final commit will cover that recovery path.

ply-event-loop: Dispatch ready descriptors without FIONREAD

The kmsg reader now invalidates its state after terminal reads and genuine
disconnects, with tests for both paths. The event loop probes error and
hangup events with FIONREAD.

Some descriptors report a requested epoll status with EPOLLERR or EPOLLHUP
without implementing FIONREAD. Treating an ioctl failure as a disconnect
prevents /dev/kmsg from observing overflow status.

This commit continues overflow recovery by recording whether the requested
status matched before the disconnect probe. It dispatches the status
callback when FIONREAD is unavailable and retains disconnects for unmatched
events.

The next commit will cover readiness without FIONREAD. Later commits will
keep the kmsg watch active when read reports an overwritten record.

tests: Cover timeouts stopping ready descriptors

The event loop now ignores epoll results for sources removed by an expired
timeout before descriptor dispatch.

The unit suite does not arrange for a descriptor hangup and a
watch-stopping timeout to become pending together. The double-removal
assertion can return without a focused failure if dispatch ordering
regresses.

This commit closes a watched socket peer, lets a timeout expire, and
processes both pending conditions. The test verifies that the timeout
removes the watch without invoking either descriptor callback.

Subsequent commits will deliver requested readiness when FIONREAD is
unavailable and recover after /dev/kmsg overflow.

ply-event-loop: Ignore events for stopped sources

The event loop holds references to sources returned by epoll while it runs
expired timeout handlers before descriptor callbacks.

A timeout can stop the final watch for a ready source during that interval.
The source leaves the polling set, but the queued event still reaches
disconnect processing and attempts to remove the source a second time.

This commit skips queued events whose source is no longer in the polling
set. Exit requests still stop descriptor dispatch at the same point.

The next commit will cover a timeout stopping a ready source. Later commits
will preserve recoverable /dev/kmsg error readiness.

tests: Cover kmsg reader disconnect cleanup

The kmsg reader has coverage for terminal read cleanup and now receives a
disconnect callback that invalidates its stored resources.

The callback is not exercised through the event loop. A change in hangup
dispatch or callback registration can leave the stored watch dangling
without failing tests.

This commit closes one end of a watched socket and processes the resulting
hangup. It verifies that the callback closes the source descriptor, clears
the watch, and leaves a repeated stop harmless.

With both lifecycle exits covered, subsequent commits will preserve the
reader across recoverable /dev/kmsg overflow.

ply-kmsg-reader: Reset state after disconnects

The kmsg reader now funnels terminal read results through its stop routine.
Unit coverage verifies that its stored descriptor and watch become
inactive.

Event-loop disconnects take a different path. The event loop frees the
watch after notifying clients, but the reader has no callback and retains
the released address for later stop.

This commit handles disconnect notifications by clearing the stored watch,
closing the source descriptor, and marking it inactive before the event
loop frees its copy.

The next commit will exercise a real hangup. Later commits will keep
overflow readiness on the recoverable read path.

tests: Cover terminal kmsg reader cleanup

The kernel message reader now routes terminal read results through its stop
routine so its watch and descriptor fields become inactive.

The test suite has no exercise that creates a real event-loop watch, forces
a terminal read result, then invokes stop again. A regression can
reintroduce a stale handle without a failure.

This commit registers a kmsg reader unit target with controlled open and
read calls. The test verifies that a terminal read closes the descriptor,
clears the watch, and leaves repeated stop safe.

The next commit will synchronize stored state when the event loop reports a
disconnect. A later test will cover that path.

ply-kmsg-reader: Reset state after terminal reads

The kernel message reader owns an event-loop watch and the descriptor used
to consume /dev/kmsg. Its stop routine releases both resources and marks
their stored fields inactive.

A terminal read bypasses that routine and releases the resources directly.
The stored watch and descriptor still appear active, so later session
teardown can use freed memory or close a reused descriptor.

This commit begins making kernel overflow handling safe by routing terminal
read results through the reader stop routine. The routine invalidates both
fields after releasing their resources.

The next commit will cover terminal read cleanup. Later commits will
synchronize event-loop disconnects and resume after kernel message
overflow.

Merge branch 'fix-prompt-cancel-on-hangup' into 'main'

ply-boot-server: cancel pending prompts when requesting client disconnects

Closes #126 and #125

See merge request plymouth/plymouth!393

ply-boot-server: also cancel prompts on partial-request teardown

disconnect() can run after a prompt was already queued, call hangup handler here as well.

tests: add regression test for prompt cancellation on client disconnect

Verify that connection_hangup_handler fires before drop_reference (guards
against the use-after-free in issue #125) and that the server remains
responsive after a client disconnect so a second password request is
queued normally (guards against the hang in issue #126).

The scenario is driven once from main(), which hands its observations to
the ply-test.h cases so results are reported as TAP like the rest of the
suite.  The test needs root for the SO_PEERCRED uid check and reports its
cases as skips when running unprivileged.

ply-boot-server: cancel pending prompts when requesting client disconnects

When a client that sent a password or question request disconnects before
the prompt is answered — for example because a TPM or FIDO2 token unlocked
the volume in the background — Plymouth keeps the password dialog on screen.
The use-after-free in this scenario was already fixed for #125 (9f892393,
which ref-counts the connection and guards the answer callbacks with
->disconnected).  What remains is that nothing cancels the pending
entry_trigger, so the prompt stays drawn until the user types a passphrase
or plymouthd exits (issue #126).

Add a connection_hangup_handler callback to ply_boot_server_t, fired in
ply_boot_connection_on_hangup before drop_reference so the caller still
gets a valid connection pointer.  Wire it up in main.c as
on_connection_hangup(), which walks entry_triggers and keystroke_triggers
and pulls any trigger whose connection matches the one that just
disconnected, dismissing its prompt.

Pass the originating connection pointer through ask_for_password_handler,
ask_question_handler, and watch_for_keystroke_handler so callers can match
triggers back to the connection that requested them.

Closes #126

Merge branch 'test-plan/52-qemu-xkbcommon' into 'main'

ci: Install xkbcommon for QEMU boot validation

See merge request plymouth/plymouth!472

ci: Install xkbcommon for QEMU boot validation

The on-demand QEMU job builds Plymouth in a minimal Fedora environment
before assembling an initramfs and booting it in a virtual machine.

Plymouth requires xkbcommon even when its optional Pango, GTK, FreeType,
and DRM integrations are disabled. The job installs keyboard data without
the development package that exports xkbcommon to pkg-config, so Meson
stops during dependency discovery.

This commit resolves that missing dependency by installing
libxkbcommon-devel in the QEMU job Fedora environment.

The QEMU workflow can now progress beyond Meson dependency discovery toward
its initramfs boot validation.

Merge branch 'test-plan/51-qemu-manual' into 'main'

ci: Make QEMU boot validation on demand

See merge request plymouth/plymouth!471

ci: Make QEMU boot validation on demand

The QEMU initramfs job has a working Fedora build layout and runs only in
pipelines created by a project schedule.

The project has no pipeline schedules. The virtual-machine check should run
only when someone explicitly requests it.

This commit makes the QEMU job an optional manual action that does not
block the surrounding pipeline.

QEMU boot validation is now available from the pipeline UI without
recurring execution or ordinary pipeline cost.

Merge branch 'test-plan/50-qemu-install-layout' into 'main'

ci: Match QEMU build paths to the guest image

See merge request plymouth/plymouth!470

ci: Match QEMU build paths to the guest image

The scheduled QEMU job builds Plymouth before assembling a minimal guest
with configuration, data, and plugins installed under /usr.

Meson defaults to /usr/local, so the built daemon searches there while the
harness populates /usr. It misses DeviceTimeout and aborts while
registering device discovery.

This commit resolves that path mismatch by configuring the QEMU build with
a /usr prefix and lib64 library directory.

The resulting initramfs boots under QEMU software emulation and reaches
PLYMOUTH_QEMU_PASS.

Merge branch 'test-plan/49-qemu-boot-ci' into 'main'

ci: Boot Plymouth in QEMU on a schedule

See merge request plymouth/plymouth!469

ci: Schedule an initramfs boot in QEMU

The QEMU boot harness can validate the built daemon and client against a
real kernel, but no pipeline currently supplies its kernel and emulator
dependencies or invokes it regularly.

Running a virtual machine in every merge-request pipeline would add
substantial package setup and software-emulation time to the fast feedback
path. Leaving the harness entirely manual would allow early-boot
integration failures to linger.

This commit adds a schedule-only Fedora job that builds Plymouth, checks
the harness scripts, installs a packaged kernel, and performs the initramfs
boot with QEMU software emulation.

The scheduled job completes the planned virtual-machine coverage without
slowing merge-request pipelines.

tests: Boot Plymouth in a minimal QEMU guest

The executable tests run the daemon and client on the build host. They do
not enter an initramfs with a real kernel console, virtual terminal, device
file system, and dynamically loaded splash plugin.

Host execution can miss absent runtime libraries or data, early-boot
directory requirements, virtual-terminal acquisition failures, and
daemon/client lifecycle problems that appear only before the root file
system starts.

This commit assembles a minimal initramfs from the current build and its
resolved dependencies, boots it with QEMU software emulation, and drives
the details splash through status, message, visibility, and quit requests.

The next commit will run the virtual-machine boot harness in a scheduled
Fedora continuous integration job.

Merge branch 'test-plan/48-image-generated-input' into 'main'

tests: Stress image file loading

See merge request plymouth/plymouth!468

tests: Stress image file loading

Image loading has fixed valid and malformed PNG and BMP examples but no
comparable range of generated files.

Truncation and mutation can combine signatures, dimensions, offsets, chunk
metadata, and pixel bytes in too many ways for individual fixtures.

This commit loads 512 bounded inputs and checks dimensions and data from
every successful decode. Instrumented jobs run the same cases.

Generated image coverage remains independently attributable from the other
generated-input targets.

Merge branch 'test-plan/47-terminal-generated-input' into 'main'

tests: Stress terminal stream parsing

See merge request plymouth/plymouth!467

tests: Stress terminal stream parsing

The terminal emulator has fixed examples for control sequences, wrapping,
UTF-8, malformed input, and selected read boundaries.

Console bytes can combine parsing states and arrive at many more
boundaries. Rendering must not depend on how one stream is divided.

This commit generates 2,048 bounded streams, parses each whole and in
varying chunks, and compares every rendered character and style.

Generated terminal coverage remains independently attributable from the
other generated-input targets.

Merge branch 'test-plan/46-script-generated-input' into 'main'

tests: Stress script token scanning

See merge request plymouth/plymouth!466

tests: Stress script token scanning

The script scanner has fixed examples for tokens, comments, malformed
literals, incomplete constructs, and integer limits.

Arbitrary bytes can combine with quotes, numbers, nested comments, and
abrupt endings in too many ways for individual examples.

This commit scans 2,048 bounded inputs, limits token counts by input
length, and requires every scan to reach an error or the end.

Generated script coverage remains independently attributable from the other
generated-input targets.

Merge branch 'test-plan/45-key-file-generated-input' into 'main'

tests: Stress key file parsing

See merge request plymouth/plymouth!465

tests: Stress key file parsing

Key-file behavior has fixed examples for grouped and groupless settings,
typed values, repeated keys, and whitespace boundaries.

Truncated files, embedded bytes, and damaged sections can expose parsing
loops or ownership errors outside those examples.

This commit generates 512 bounded key files, loads each one in grouped and
groupless modes, and exercises the public value accessors.

Generated key-file coverage remains independently attributable from the
other generated-input targets.

Merge branch 'test-plan/44-command-generated-input' into 'main'

tests: Stress command argument parsing

See merge request plymouth/plymouth!464

tests: Stress command argument parsing

The command parser has fixed examples for each option type, integer limit,
subcommand, and help path.

Known examples do not cover unusual mixtures of valid, unknown, empty,
joined, separated, and lightly corrupted arguments.

This commit generates 2,048 argument sets, parses each set twice with fresh
objects, and compares every option value and set marker.

Generated command-line coverage remains independently attributable from
other generated-input targets.

tests: Provide repeatable generated input sequences

The test suite uses fixed examples to exercise parsers and decoders.

Fixed examples cover known boundaries but sample few byte and token
combinations. Uncontrolled randomness would make failures hard to repeat.

This commit adds a small 32-bit generator whose seed determines every
value, range selection, and byte sequence.

The command-parser stress target is its first consumer; later targets can
reuse the helper without adding another generator.

Merge branch 'test-plan/43-repeat-ci' into 'main'

ci: Repeat unit tests twenty times

See merge request plymouth/plymouth!463

ci: Repeat unit tests twenty times

Each ordinary merge request job executes the unit suite only once.

Intermittent ordering failures therefore get one chance to appear even in
event loops, protocol callbacks, triggers, and plugin idling.

This commit adds a Fedora job that builds once and executes every unit test
twenty times.

Repeated execution now has its own failure signal, separate from ordinary,
instrumented, and coverage builds.

Merge branch 'test-plan/42-coverage-ci' into 'main'

ci: Report exercised production source lines

See merge request plymouth/plymouth!462

ci: Report exercised production source lines

The test suite runs in merge request pipelines, but its source coverage is
not visible.

Without a coverage report, developers cannot distinguish exercised changes
from production paths reached only during normal boots.

This commit adds a compiler-instrumented Fedora build, prints its exercised
line percentage, and publishes a Cobertura report.

Line coverage remains independent of runtime instrumentation and repeated
test execution.

Merge branch 'test-plan/41-sanitizer-ci' into 'main'

ci: Check memory access and undefined behavior

See merge request plymouth/plymouth!461

ci: Check memory access and undefined behavior

Merge request pipelines compile Plymouth and run its test suite on Fedora
and Debian.

Ordinary builds do not reliably expose invalid memory access or C
operations with undefined results.

This commit adds a Fedora job with memory-access and undefined-operation
instrumentation and stops at the first report.

Leak detection remains disabled because loaded modules and process-lifetime
global data deliberately survive until exit.

Merge branch 'test-plan/40-fd-escrow' into 'main'

tests: Cover file descriptor escrow

See merge request plymouth/plymouth!460

tests: Cover file descriptor escrow signal handling

The escrow executable test verifies that the helper marks its process name
before entering the shutdown wait loop.

The marker alone does not keep the process alive. The helper also promises
to ignore the normal termination signal so open display file descriptors
remain held until poweroff finishes.

This commit completes escrow executable coverage by sending that signal
after observing the marker and requiring the same child process to remain
alive for forced test cleanup.

The escrow series now verifies both parts of its shutdown-survival
contract: process marking and normal termination resistance.

tests: Cover file descriptor escrow process marking

The file descriptor escrow helper changes the first byte of its process
name before waiting indefinitely during system shutdown.

No executable test verifies that systemd can distinguish that helper from
ordinary processes during the transition away from the initial filesystem.

This commit begins escrow executable coverage by starting the built helper,
polling its process metadata for the leading survival marker, and
guaranteeing child cleanup on every test exit.

The final commit will verify that the marked helper also ignores the normal
termination signal as intended.

Merge branch 'test-plan/39-control-client-cli' into 'main'

tests: Cover control client command line

See merge request plymouth/plymouth!459

tests: Cover control client plugin path query

The linked control client help test verifies its global options and command
families without contacting a running daemon.

The plugin-directory query is another daemon-independent exit path. Its
compiled installation value and output stream are not exercised by help
generation.

This commit completes client executable coverage by passing the configured
plugin directory into the test and comparing it with the query's exact
standard output while requiring empty standard error.

The control client series now covers both command discovery and its
build-time splash plugin directory query.

tests: Cover control client help output

The control client exposes global options plus commands for modes, boot
state, prompts, messages, progress, activation, and shutdown.

The parser tests do not execute the linked client or verify its complete
registered command surface. A missing command or incorrectly routed help
message can therefore escape continuous integration.

This commit begins client executable coverage by running its help path,
checking every global option and command family, and requiring empty
standard error with a successful exit.

The final commit will verify the client's daemon-independent query for the
configured splash plugin directory.

Merge branch 'test-plan/38-daemon-cli' into 'main'

plymouthd: Cover command line behavior

See merge request plymouth/plymouth!458

tests: Cover daemon option rejection

The daemon executable test verifies the successful help path and its
complete public option list.

Malformed command lines take a different path through the parser. Their
usage exit status and output streams are not covered by successful help
checks.

This commit covers that rejection path by passing an unknown option and
requiring the standard usage status, empty standard output, and usage text
on standard error.

Daemon executable coverage now includes both successful option discovery
and deterministic command-line rejection.

tests: Cover daemon help output

The daemon help now lists every supported operating mode alongside all of
its global command-line options.

The parser unit tests do not execute the linked daemon. Option
registration, output routing, exit status, and the final help text can
diverge from lower-level parser behavior without detection.

This commit completes daemon help coverage by running the built executable,
requiring a successful exit with empty standard error, and checking every
option plus the exact supported mode list.

The next commit will cover deterministic rejection of invalid daemon
options.

plymouthd: List every supported mode in help

The daemon accepts seven named operating modes through its command line and
maps each name to a matching splash state.

The help text lists only boot and shutdown. Boot is not an accepted name,
while reboot, update, upgrade, firmware, and reset modes are absent, so
users cannot derive valid input from the executable itself.

This commit resolves that misleading option description by listing all
seven accepted names exactly as the daemon parses them.

The following commits will run the built daemon's help and parse-failure
paths to keep its complete command-line surface accurate.

Merge branch 'test-plan/37-splash-plugin' into 'main'

tests: Cover splash plugin lifecycle

See merge request plymouth/plymouth!457

tests: Cover splash idle completion

The splash tests cover theme loading, attached-device cleanup, mode
transitions, boot state, messages, prompts, progress, and plugin
destruction.

Idle completion crosses a separate asynchronous boundary. The plugin
signals an internal completion object, and the wrapper must schedule the
caller on its event loop without losing or duplicating that signal.

This commit completes splash orchestration coverage by having the fake
plugin report idle immediately, running the event loop with a watchdog, and
verifying one caller notification before teardown.

The splash plugin series now covers loading, attachment ownership, runtime
delegation, mode changes, asynchronous completion, and cleanup.

tests: Cover splash runtime delegation

The splash tests load the fake theme and verify that attached keyboards and
displays are removed before the plugin is destroyed.

Runtime calls remain unchecked after loading. Mode changes, boot state,
messages, prompts, binary output, progress, and input validation can be
forwarded with missing or altered arguments.

This commit verifies runtime delegation by exercising each public state and
prompt operation, checking exact recorded values, and confirming that
repeating the current mode does not show the splash again.

The final commit will verify that plugin-reported idle completion reaches
the caller through the event loop.

tests: Cover splash attachment cleanup

The test tree has a theme-backed splash module that records keyboard, pixel
display, text display, and plugin lifetime operations.

No test loads that theme or verifies ownership at shutdown. A splash can
leave attached devices registered or skip plugin destruction without
continuous integration observing the stale references.

This commit verifies theme loading and cleanup by attaching a real
pseudoterminal-backed text display, a fake-renderer pixel display, and a
keyboard before freeing the splash and checking every removal.

Subsequent commits will drive boot-state callbacks, mode changes, prompts,
validation, progress, and asynchronous idle completion.

tests: Build a controllable splash plugin

The splash wrapper loads the module named by a theme file and delegates
display attachment, boot state, prompts, progress, and shutdown through its
plugin interface.

The test suite has no theme-backed module that records those calls. Theme
loading, plugin lifetime, event-loop completion, and the broad callback
surface therefore cannot be checked without a real theme.

This commit begins splash orchestration coverage by building a fake module
with fixed theme data and recorded arguments for every plugin operation.

Subsequent commits will verify attached-device cleanup, runtime callback
forwarding, mode transitions, and asynchronous idle completion.

Merge branch 'test-plan/36-daemon-policy' into 'main'

plymouthd: Isolate and cover startup policy

See merge request plymouth/plymouth!456

tests: Cover daemon startup policy

Daemon modes and firmware-framebuffer settings have ordered fallback rules.

A precedence reversal can change boot behavior without producing a parse
failure.

This commit checks every mode name, invalid input, configuration and kernel
argument precedence, disk encryption, and resulting device flags.

Startup policy now has isolated coverage independent of daemon executable
and plugin-lifecycle tests.

plymouthd: Use private startup policy

Mode names are decoded twice, and firmware-framebuffer precedence spans
configuration, kernel arguments, and device flags.

Those branches must retain their current ordering.

This commit routes each decision through the private policy while leaving
file access, tracing, and fallback behavior in the daemon.

The next commit will cover the policy tables and precedence boundaries.

meson: Link daemon through policy dependency

The private policy archive is not included in the daemon link.

Startup cannot adopt its decisions until the dependency is available.

This commit adds the private policy object to the daemon dependencies.

The next commit will replace duplicated startup decisions with it.

meson: Add private daemon policy dependency

Mode parsing and firmware-framebuffer precedence live in daemon startup.

Direct tests otherwise require process setup and host kernel arguments.

This commit adds pure private decisions for modes, configuration order,
kernel-argument order, and device flags.

The next commit will link the daemon through the policy dependency.

Merge branch 'test-plan/35-label-plugin' into 'main'

ply-label: Cover plugin orchestration

See merge request plymouth/plymouth!455

tests: Cover live label plugin operations

The label tests verify that settings cached before first use reach the fake
module, and freeing a loaded label now destroys its plugin control.

Operations issued after the control becomes visible remain unchecked.
Drawing coordinates, rich text spans, visibility changes, live styling, and
final destruction can regress independently of cached replay.

This commit completes label orchestration coverage by showing a control,
forwarding live text and style changes, drawing a bounded area, hiding the
control, and checking its single destruction.

The label test series now covers lazy module loading, cached property
replay, live interface delegation, visibility, drawing, and teardown.

ply-label: Destroy unloaded plugin controls

The label wrapper lazily creates a plugin control, replays cached settings
to it, and closes the rendering module when the label is freed.

Module unloading skips the interface's control destruction function. Every
loaded label therefore leaves the plugin's text layout and drawing state
allocated.

This commit resolves that lifetime leak by destroying a created control
before closing its module and clearing the saved control pointer.

The final commit will exercise visible label operations and verify that the
fake control is destroyed exactly once.

tests: Cover label settings before plugin loading

Labels cache text, font, alignment, width, and either color format until
the fake rendering module creates its control on first use.

No test verifies that the complete cached state reaches a lazily loaded
module. A setter can silently lose its value before first drawing without
any font or display hardware exposing the regression in continuous
integration.

This commit verifies lazy property replay by configuring a label before
loading, requesting its dimensions, and checking every value recorded by
the fake module.

Subsequent commits will release the created plugin control and cover
operations forwarded after the label is visible.

ply-label: Preserve hexadecimal colors before loading

Labels cache text, font, alignment, width, and direct color settings until
their rendering module is loaded on first use.

The hexadecimal color setter bypasses that cache. A color chosen before
first use is discarded, so the module receives the default white color when
it eventually creates the control.

This commit resolves that lost setting by routing converted hexadecimal
components through the direct color setter, which stores them before
forwarding them to a loaded control.

The next commit will verify that every pre-load label setting reaches the
fake module when lazy loading occurs.

tests: Build a controllable label plugin

The graphics library loads a label module on first use and forwards text
layout, drawing, visibility, and styling through its control interface.

The test suite has no font-library-independent module that records those
operations. Lazy property replay and control lifetime therefore cannot be
checked deterministically.

This commit begins label orchestration coverage by building a fake
Pango-named module that records control settings, draw geometry, visibility
changes, dimensions, and destruction.

Subsequent commits will preserve pre-load hexadecimal colors, release
plugin controls, and exercise both cached and live label operations.

ply-label: Allow private plugin directory selection

Label loading tries two modules under a compiled production directory.

Integration tests need isolated fake modules and deterministic fallback
ordering.

This commit adds a hidden constructor that stores a plugin directory while
the public constructor keeps the configured production path.

The private path seam enables fake-module orchestration without changing
the public label interface.

meson: Link graphics through label dependency

The graphics library still compiles label handling directly.

Tests would otherwise exercise a second build of the module loader.

This commit moves the production label object into the private archive and
links that exact object into the graphics library.

The next commit will add private label plugin directory selection.

meson: Add private label dependency

Label integration tests need the production module loader with test label
plugins.

Compiling another source copy would weaken production-object coverage.

This commit builds label handling as a private archive and declares it for
later tests.

The next commit will make the graphics library consume that archive.

Merge branch 'test-plan/34-renderer-plugin' into 'main'

ply-renderer: Cover plugin orchestration

See merge request plymouth/plymouth!454

tests: Cover renderer plugin orchestration

The splash core has a fake frame-buffer module whose backend records
interface calls, and renderer unloading now destroys that backend.

No registered test drives the wrapper through the module. Plugin path
selection, device setup, lazy mapping, input forwarding, panel data, and
teardown can still change without detection.

This commit completes renderer orchestration coverage by loading the fake
module from the build tree and exercising every public renderer operation
before checking device closure and backend destruction.

The renderer test series now covers module loading, interface delegation,
state transitions, and the complete successful lifetime.

ply-renderer: Destroy unloaded plugin backends

The renderer wrapper loads a module, creates its backend object, and closes
the rendering device before unloading the module.

Module unloading skips the interface's backend destruction function. Every
renderer lifetime therefore leaves plugin-owned buffers, lists, and device
state allocated.

This commit resolves that lifetime leak by destroying a created backend
before closing its module and clearing the saved backend pointer.

The final commit will exercise the renderer interface through the fake
module and verify that backend destruction happens exactly once.

tests: Build a controllable renderer plugin

The splash core selects renderer modules by device type and delegates
display operations through each module's backend interface.

The test suite has no hardware-independent renderer module that records
those calls. Renderer loading, operation forwarding, and object lifetime
therefore cannot be checked deterministically.

This commit begins renderer orchestration coverage by building a fake
frame-buffer module whose backend records every interface operation and
provides fixed display, input, and panel data.

Subsequent commits will dispose of the plugin-created backend object and
drive the complete renderer interface through the fake module.

ply-renderer: Allow private plugin directory selection

Renderer plugin paths are compiled directly into the open routine.

Integration tests need an isolated directory containing fake renderer
backends.

This commit adds a hidden constructor that stores a plugin directory while
the public constructor retains the configured production path.

The private path seam enables fake-module orchestration without changing
the public renderer interface.

meson: Link splash core through renderer dependency

The splash core still compiles renderer code directly into the shared
library.

Tests would therefore use a separately compiled copy of the loader.

This commit moves the production renderer object into the private archive
and links that exact object into the splash core.

The next commit will add a private constructor for plugin directories.

meson: Add private renderer dependency

Renderer integration tests need the production loader with a test plugin
directory.

Recompiling the source in each test could diverge from the installed core.

This commit builds the renderer once as a private archive and declares a
dependency for later tests.

The next commit will make the splash core consume that archive.

Merge branch 'test-plan/33-boot-logo-metadata' into 'main'

tests: Cover boot logo metadata

See merge request plymouth/plymouth!453

tests: Cover boot logo metadata files

Firmware logo metadata combines a status orientation with horizontal and
vertical offsets.

Missing files and malformed integers must suppress the firmware background.

This commit checks all four rotations, signed offsets, trailing garbage,
overflow, missing entries, and a missing directory.

The filesystem-reader series is complete; plugin directories follow.

two-step: Use private boot logo metadata reader

Firmware-logo setup opens and parses status and offset files inside the
rendering plugin.

Image placement still needs the resulting offsets and rotation.

This commit delegates metadata loading to the private reader and shares one
system directory constant with the firmware image path.

The next commit will cover metadata directories with fixtures.

meson: Link two-step plugin through boot logo metadata

The private boot-logo reader is not part of the two-step plugin link.

Plugin adoption requires the reader and splash-core types it consumes.

This commit adds the metadata dependency to the installed two-step plugin
without exposing reader symbols.

The next commit will move firmware metadata parsing into the reader.

meson: Add private boot logo metadata dependency

The two-step plugin reads three fixed Boot Graphics Resource Table files
while preparing a view.

Tests cannot supply logo offsets or orientation values.

This commit adds a path-taking private reader with strict integer parsing
and explicit orientation mapping.

The next commit will link the two-step plugin through the reader.

Merge branch 'test-plan/format-test-plan' into 'main'

style: Apply project formatting to test plan files

See merge request plymouth/plymouth!451

style: Apply project formatting to test plan files

The test plan has added coverage across library, protocol, console, and script components, together with a few private interfaces used by those tests.

Several added files do not match the C layout enforced by the Fedora merge request job. The automated formatter rejects those files before that job reaches the build and test steps.

This commit resolves the formatting failures by applying the Fedora 37 Uncrustify 0.75.1 rules to every file reported by the failed pipelines. It changes spacing, alignment, and loop braces without altering test assertions or runtime behavior.

The test-plan files now match the repository's enforced layout, leaving the merge request pipeline to validate behavior instead of stopping at formatting.

Merge branch 'test-plan/ci-allow-format-fixes' into 'main'

ci: Allow formatting corrections

See merge request plymouth/plymouth!452

ci: Allow formatting corrections

The Fedora merge request job formats both the target branch and proposed
branch, then compares the two formatter patches.

The comparison currently rejects every difference between those patches.
Removing an existing formatting defect therefore fails in the same way as
introducing a new one.

This commit resolves that asymmetry by rejecting only forward patches from
submitted source to formatter output. Reverse patches describe formatter
changes that the branch has removed, so the job now accepts them.

The check continues to reject newly introduced formatting defects while
permitting formatter-only corrections.

ci: Install cpio in Debian jobs

The Fedora merge request job installs cpio before running Plymouth's
functional tests. The Debian job uses an independent package list for its
unstable container.

The Debian job still lacks cpio, so the generate-initrd test exits before
it can exercise archive creation and the pipeline cannot validate the full
suite.

This commit resolves that remaining test dependency by adding cpio to the
Debian job's package installation.

Both ordinary merge request environments now provide the archive tool
required by the initrd functional coverage.

ci: Install cpio in Fedora jobs

The Fedora merge request job installs the tools needed to configure, build,
and exercise Plymouth in its Fedora 37 container.

The generate-initrd functional test invokes cpio, but the container does
not install that program. The test therefore stops with exit status 127
before the Fedora job can validate the full suite.

This commit addresses that missing test dependency by adding cpio to the
Fedora job's package installation.

The final commit will provide the same dependency to the Debian merge
request job.

Merge branch 'test-plan/32-secure-boot' into 'main'

tests: Cover Secure Boot state

See merge request plymouth/plymouth!450

tests: Cover Secure Boot variable boundaries

The firmware variable combines four attribute bytes with one state byte.

Short input, extra data, unknown states, and missing files must all report
Secure Boot as disabled.

This commit checks enabled and disabled values plus every file-size
boundary around the required five bytes.

The Secure Boot series is complete; firmware logo metadata comes next.

ply-utils: Use private Secure Boot reader

Secure Boot detection reads and interprets the firmware variable beside its
process-wide cache.

The fixed path prevents direct coverage of malformed variable sizes.

This commit delegates file validation to the private reader while retaining
the existing cached public result.

The next commit will cover firmware-variable contents with fixtures.

meson: Link libply through Secure Boot reader

The private firmware-variable reader is built outside the utility library.

Secure Boot detection cannot adopt it until libply includes its object.

This commit links the reader into libply while retaining hidden symbol
visibility.

The next commit will route cached Secure Boot detection through it.

meson: Add private Secure Boot reader dependency

Secure Boot detection opens one fixed firmware variable inside the utility
module.

Tests cannot provide enabled, disabled, or malformed variable contents.

This commit adds a path-taking private reader that accepts only the
documented five-byte firmware format.

The next commit will link the utility library through the reader.

Merge branch 'test-plan/31-active-console' into 'main'

tests: Cover active console discovery

See merge request plymouth/plymouth!449

tests: Cover active console file parsing

Kernel console names may use several whitespace forms and may omit a final
newline.

Empty or unavailable system files must not create terminal names.

This commit checks token order, trailing-name handling, whitespace-only
contents, and empty or missing paths.

The active-console series is complete; Secure Boot state follows.

ply-device-manager: Use active console reader

Active-console discovery mixes bounded file reads and whitespace parsing
with terminal creation.

Only terminal creation and serial-console classification need manager
state.

This commit delegates file loading and name tokenization to the private
reader while retaining device decisions in the manager.

The next commit will cover console-file boundaries with fixtures.

meson: Link splash core through active console reader

The active-console reader remains outside the installed splash core.

Device-manager adoption requires the reader archive and utility dependency.

This commit links both private filesystem readers into the splash core
without exporting their symbols.

The next commit will delegate active-console tokenization to the reader.

meson: Add private active console dependency

The device manager tokenizes the fixed active-console system file while
creating terminal objects.

Tests cannot provide console contents without opening host devices.

This commit adds a path-taking reader that returns console names through a
private dependency.

The next commit will link the splash core through the console reader.