Transparent Arm Virtual Machines on s390: A Q&A on Hardware-Assisted Emulation

Recent developments in the Linux virtualization ecosystem have introduced a promising approach to running Arm-based virtual machines on s390 (IBM Z) hardware at near-native speeds. A patch set spearheaded by Steffen Eiden and colleagues lays the groundwork for hardware-assisted emulation of Arm CPUs on s390 CPUs. While version two of the patch set addresses minor issues, the core concept remains unchanged. The Arm architecture maintainers have welcomed the initiative, though discussions continue on structuring cross-architecture collaboration to avoid long-term maintainability challenges. Below, we explore six key questions about this work.

Table of Contents

• What is the recent patch set from Steffen Eiden about?
• Who are the key developers and maintainers involved?
• What are the main improvements in version two of the patch set?
• Why is cross-architecture collaboration important for maintainability?
• How would this technology benefit virtual machine performance on s390?
• What are the next steps before the patches can be merged?

What is the recent patch set from Steffen Eiden about?

This patch set introduces initial support for hardware-assisted emulation of Arm CPU architectures on s390 (System/390) hardware. Traditionally, running an Arm virtual machine on an s390 host required full software emulation, which is slow and resource-intensive. The new approach leverages hardware features in s390 CPUs to accelerate Arm instruction execution, targeting near-native performance for Arm guest VMs. The patches modify the KVM (Kernel-based Virtual Machine) subsystem to recognize Arm as a supported guest architecture on s390, enabling the host to offload certain operations directly to the physical CPU. While still at an early stage, this capability could fundamentally change how heterogeneous virtualized environments are built, allowing users to transparently deploy Arm workloads without needing dedicated Arm hardware.

Who are the key developers and maintainers involved?

The effort is led by Steffen Eiden from IBM, along with several other contributors who are part of the broader Linux virtualization community. On the receiving end, the Arm architecture maintainers have expressed a positive reception to the patch set. However, the Arm side is particularly concerned with ensuring that any cross-architecture code does not introduce maintainability burdens. Key figures such as Catalin Marinas and Will Deacon (Arm maintainers) are likely to be involved in the ongoing discussions. The collaboration also involves KVM maintainers like Paolo Bonzini, who oversee the common hypervisor code that this patch set touches. The goal is to reach a consensus on how to share code between architectures while keeping the Arm-specific part clean and manageable.

What are the main improvements in version two of the patch set?

Version two of the patch set, posted recently, addresses several smaller problems that were identified in the initial submission. These fixes include corrections to memory mapping inconsistencies, adjustments to interrupt handling for Arm guest contexts, and refinements in how the s390 host exposes Arm CPU features to the guest. Additionally, the patch set has been rebased onto the latest kernel tree to avoid conflicts with other ongoing developments. According to Steffen Eiden, the second version does not differ dramatically from the first—it is more a cleanup and stabilization round. The fundamental approach remains the same: using existing s390 hardware virtualization extensions to intercept and emulate Arm-specific instructions. These improvements have helped build confidence among the Arm maintainers that the implementation is on the right track.

Why is cross-architecture collaboration important for maintainability?

A major concern, especially from the Arm maintainers, is that adding s390-specific code paths inside the Arm KVM module could create long-term maintenance overhead. If every architecture start adding emulation for every other architecture, the hypervisor codebase would become a tangled web of conditional definitions. Therefore, the discussion centers around designing a clean abstraction layer that allows s390 to emulate Arm without polluting Arm's own code. Possible solutions include introducing a generic guest architecture interface or isolating the emulation logic in a separate s390-specific directory. The maintainers want to ensure that future changes to Arm KVM do not inadvertently break the s390 emulation. A well-structured collaboration agreement would prevent duplicated efforts and keep the codebase modular. This is why the Arm maintainers are pushing for a structured approach before merging the patches.

How would this technology benefit virtual machine performance on s390?

Currently, running an Arm VM on s390 requires full software emulation (e.g., using QEMU's TCG), which is orders of magnitude slower than native execution. The hardware-assisted approach changes this by allowing the s390 host CPU to handle certain Arm instructions directly, dramatically reducing the overhead of translation. With these patches, the gap between native Arm and emulated Arm on s390 could shrink to near-zero for many workloads, especially those that are compute-heavy. This means that organizations invested in s390 infrastructure could seamlessly run Arm applications (e.g., for testing or IoT workloads) without maintaining separate Arm clusters. The technology also paves the way for transparent migration of Arm VMs, potentially lowering cost and complexity in heterogeneous data centers. However, the full benefit will only materialize after the patches are integrated and further optimized in subsequent releases.

What are the next steps before the patches can be merged?

The primary obstacle to merging is resolving the maintainability concerns raised by the Arm architecture maintainers. Both sides are in discussions to define a code-sharing model that satisfies the Arm community's need for clean, self-contained code while allowing s390 to reuse existing Arm KVM infrastructure. Once an agreement is reached, the patches will likely undergo additional review cycles, focusing on areas such as thread safety, hot-plug capabilities, and compliance with Arm architecture specifications. The next version (v3) is expected to incorporate feedback from these discussions. If all goes well, the patches could be queued for inclusion in an upcoming Linux kernel merge window. In the meantime, interested developers can test the current patches on their s390 systems and provide feedback to help accelerate the process.