HFTKernel 7.3.x release notes.

Timely progress after io_uring drain barriers

A standalone drain request now clears the drain state when its completion is flushed and no other deferred work remains. For io-wq execution, that transition happens under the ring lock before the completion becomes visible to userspace.

Requests submitted after the completed barrier can proceed without waiting for the worker to release its final request reference. Linked drain requests retain their ordering requirements.

This makes completion-driven I/O pipelines more predictable for applications using drain barriers.

Reliable poll wakeups and multishot completion

An atomic compare-and-exchange now coordinates poll ownership release with concurrent retry notifications. Pending wakeups remain visible, allowing processing to continue without depending on an unrelated event.

Multishot poll also updates the shared reference counter correctly on hangup. The final event pass can complete without unnecessary repeated looping, improving connection-lifecycle handling in asynchronous applications.

Precise completion-queue timeouts on PREEMPT_RT

For RT and deadline tasks on PREEMPT_RT, io_uring completion-queue timeout callbacks run in hard-interrupt context. Wakeup delivery no longer depends on scheduling the lower-priority timer thread.

In the upstream Jetson Orin Nano test, backported to Linux 6.18.39-rt, maximum lateness fell from 1,040 µs to 18 µs across 40,000 deadlines under competing SCHED_FIFO load. All wakeups stayed within 100 µs after the change.

Consistent handling of large provided receive buffers

For non-bundled receive operations that derive their length from a provided buffer, io_uring caps the selected transfer length at MAX_RW_COUNT.

This keeps the length valid through the signed return path, including provided buffers of 2 GiB or larger, while following the existing transfer-size limit. It strengthens receive-buffer handling for applications using large reusable regions.

Better-coordinated asynchronous worker shutdown

The io-wq exit path applies a memory barrier after publishing its exit flag. Shutdown and concurrent worker-creation task work observe the required ordering, including on weakly ordered architectures.

This strengthens orderly teardown and restart of services that use io_uring worker pools.

Cancellation of IORING_OP_WAITID requests is also idempotent: repeated attempts recognize the existing cancellation state without accumulating additional references. This keeps asynchronous process-supervision requests consistent during cancellation.

Less unnecessary work during PID-namespace teardown

During namespace cleanup, the process reaper masks task-work notification wakeups while waiting for child termination and PID release.

It can sleep until the relevant lifecycle event occurs rather than repeatedly re-entering its wait path. This reduces avoidable CPU activity in the affected container-shutdown and livepatch interactions.

Reliable per-CPU IRQ visibility on large hosts

/proc/interrupts now emits its CPU header whenever the first record is rendered, including retries after the sequence buffer grows.

The CPU-to-counter layout remains intact on high-core-count systems. This supports dependable IRQ parsing, placement verification, and monitoring of isolated and housekeeping CPUs.

Cleaner tracing configuration and teardown

Histogram setup now removes automatically created field-variable triggers when the overall command fails. Active tracing matches the accepted configuration, with temporary instrumentation cleaned up rather than left counting events.

Field-variable histogram cleanup retains the stable event-file reference instead of depending on another histogram's lifetime. This improves repeated creation, modification, and removal of diagnostic sessions.

Event-filter parsing also rejects incomplete logical expressions before they reach execution. This strengthens automated tracefs and perf tracepoint configuration.

More complete postmortem diagnostics

Core-dump collection is protected from TIF_NOTIFY_SIGNAL interruptions while transferring data through pipes and sockets. Notifications from io_uring and other task-work producers no longer interrupt those collection paths.

This preserves diagnostic data for detailed analysis of application state, mappings, and outstanding I/O.

Consistent DAMON quota validation

DAMOS quota goals are validated in the DAMON core before being applied. Zero target values are rejected through the common commit path, and the error is propagated to callers.

For deployments using DAMON-based memory management, this provides a consistent boundary for quota-policy configuration.

Reliable out-of-tree DMA benchmark builds

dma_map_benchmark now builds in the selected output directory when O= is specified.

The benchmark fits cleanly into build pipelines that separate source trees from generated tools, supporting repeatable preparation of DMA diagnostics.

Supported operating systems and installation

HFTKernel supports 24 OS targets across Ubuntu, Debian, RHEL-compatible platforms, AlmaLinux, Rocky Linux, CentOS Stream, Fedora, Amazon Linux, Arch Linux, NixOS-compatible deployments, ALT Linux p11 / Simply Linux 11, and Astra Linux 1.8. Amazon Linux 2023 uses the Cloud profile.

Install with one command:

curl -fsSL https://hftkernel.com/install.sh | sudo bash

The installer selects the matching operating-system package and deployment profile and verifies package integrity.

Release focus

The Linux 7.3.1 baseline strengthens I/O progress, real-time timeout delivery, process lifecycle management, and diagnostic consistency. These changes support HFTKernel's goal of a predictable, measurable host around latency-sensitive applications.

Prefaulted vDSO data for predictable application startup

The generic vDSO data mapping can now be populated by mlockall(). Removing its VM_IO flag allows the memory-preparation phase to establish the corresponding page-table entries before latency-sensitive processing begins.

For applications using vDSO-assisted time reads, this moves an avoidable first-touch page fault into startup preparation. The upstream author observed approximately 20 µs for the complete page-fault exception path on the test machine.

This strengthens the preparation of trading engines, timestamp consumers, and measurement processes that explicitly prefault their working sets.

Less LRU-lock contention during memory reclaim

Classic LRU reclaim now derives anonymous and file scan-balance costs from vmstat counters. Cost sampling and decay use a dedicated per-lruvec lock instead of repeatedly acquiring the lock that protects LRU list operations. Hierarchy aggregation also replaces repeated parent-level cost updates.

In the upstream 176-core, 256 GB memory-pressure test, aggregate LRU-lock wait decreased from approximately 4.23 seconds to 1.66 seconds over a 30-second recording window, a 61% reduction, with similar scan and reclaim rates.

For classic-LRU deployments, this reduces contention between reclaim bookkeeping and the operations that actually manage pages.

Stronger executable-code retention with MGLRU

MGLRU promotes mapped executable file folios after their first observed use. Both page-table aging and reference checking recognize executable mappings when updating page state.

This gives recently used application code and shared-library code stronger protection from reclaim. It supports more consistent code residency for services running with MGLRU under memory pressure.

Less unnecessary pressure-accounting work in cgroup v2

The vmpressure subsystem skips the cgroup-v1 userspace notification path when running under cgroup v2. Reclaim avoids unused accounting, locking, workqueue submission, and parent walks.

The in-kernel TCP/SCTP socket-pressure path remains active, and cgroup-v2 userspace pressure monitoring continues through PSI. This removes redundant infrastructure work while retaining the pressure signals used by networking and service management.

Shorter workqueue critical sections

Workqueue processing selects the worker to wake while holding pool->lock, then performs the wakeup after releasing it. Scheduler wakeup operations no longer extend the shared pool critical section in the affected enqueue and chained-work paths.

In an upstream NVIDIA Grace ARM64 microbenchmark using NUMA-scoped unbound workqueues, throughput increased from 719,794 to 794,049 work items per second, with 10.3% lower P95 enqueue latency.

This improves the handling of contended background work on housekeeping CPUs and in supporting infrastructure.

More responsive scheduler-managed services

Fair-class cgroup scheduling moves to a single task-selection runqueue per CPU while retaining group-weight distribution. EEVDF also improves scheduling for short-slice tasks, and NOHZ balancing prefers fully idle cores.

These changes are relevant to scheduler-managed gateways, monitoring, orchestration, and housekeeping services. Explicit CPU affinity remains the placement mechanism for dedicated trading threads.

More scalable io_uring zero-copy receive

The io_uring zero-copy receive subsystem gains dynamic memory-area provisioning and coordinated refill improvements. Large-page refill scales with the backing allocation, compatible refill entries are coalesced, and the refill-ring head and tail occupy separate cache lines. Tail caching further reduces shared-state accesses.

These changes improve receive-memory management and reduce refill overhead for applications using io_uring ZCRX, including high-rate market data and network-processing workloads.

CXL-assisted Solarflare transmit support in the upstream baseline

Linux 7.3 brings together the CXL Type-2 infrastructure and the Solarflare driver integration for compatible SFC9100-family devices. CONFIG_SFC_CXL enables the driver path for CTPIO over CXL.mem, with compatible CXL hardware and CXL-aware firmware.

The driver verifies CXL device capabilities, creates a 256 MiB CTPIO memory region, and maps it with write-combining semantics. This provides kernel enablement for a CXL-assisted host-to-NIC transmit path.

For a matching HFTKernel Hardware configuration, the integration combines CONFIG_SFC, CONFIG_CXL_BUS, and CONFIG_SFC_CXL with a compatible server, adapter, and firmware. This creates a focused hardware-optimization option for latency-sensitive transmission.

Expanded hardware-clock control

The ZL3073x DPLL driver gains PTP hardware-clock support, exposing time reads, time adjustment, frequency adjustment, and phase adjustment through the appropriate callbacks. Available operations follow the channel’s current state, including NCO operation and reference tracking.

This expands the hardware timing options available through standard Linux interfaces and makes supported timing devices easier to integrate into clock-management infrastructure.

More scalable cloud network management

Selected software network drivers, including veth, ipvlan, and tunnels, gain per-network-namespace device unregistration. Routing-rule updates also move away from the global RTNL lock. These changes reduce shared serialization during network lifecycle and routing-policy operations.

BIG TCP support extends to UDP tunnels such as VXLAN and Geneve. Larger internal segmentation batches provide an additional efficiency option for bulk data distribution and replay over supported overlays while preserving the configured on-wire MTU.

More useful multicast diagnostics

RTM_GETMULTICAST reports a per-group user count. Monitoring software can inspect multicast-group usage through netlink, improving visibility into subscription state on hosts receiving multicast market data.

More efficient allocation profiling

Memory allocation profiling gains a binary ioctl interface for /proc/allocinfo. Module, function, file, and line filters can be applied before per-CPU counters are aggregated, so diagnostic queries process only matching allocation sites.

In the upstream Intel Xeon Platinum 8481C test with 224 logical CPUs, a specific-file query reduced system CPU time from 22 ms to 1 ms. This makes targeted memory investigations lighter and better suited to automated collection.

The new pgrotate_anon and pgrotate_file counters add visibility into reclaim work that does not immediately free pages. They support both classic LRU and MGLRU diagnostics.

Release focus

The Linux 7.3 baseline advances three priorities for HFTKernel: prepare more state before the workload starts, reduce contention in shared kernel paths, and expose better control over networking, memory, and timing.