Bringing Arm Virtual Machines to s390: Hardware-Assisted Emulation Advances

A recent patch set from Steffen Eiden and colleagues lays the foundation for hardware-assisted emulation of Arm CPUs on s390 systems. This development could enable s390 hosts to run Arm-based virtual machines at near-native speeds, a significant step toward cross-architecture virtualization. The patches have garnered attention from the Arm maintainers, though discussions remain about collaboration structures to ensure long-term maintainability. Below, we explore key questions about this technology and its implications.

What is this patch set about?

The patch set introduces support for hardware-assisted Arm CPU emulation on IBM's s390 architecture. Traditionally, running a virtual machine built for one CPU architecture on a different host requires full software emulation, which is slow. This work leverages hardware features in s390 processors to accelerate the emulation of Arm instructions, bringing performance much closer to native execution. The patches are designed to integrate with existing virtualization frameworks, allowing s390 hosts to launch Arm virtual machines transparently—users would not need to know or care about the underlying CPU architecture.

How does version two of the patch set differ from the first?

The second iteration of the patch set addresses a handful of smaller issues identified during initial review. According to the patch authors, the changes are relatively minor and do not alter the core approach. The fixes improve stability and compatibility, but the overall design remains unchanged from the first version. The focus has been on refining details such as error handling and edge cases, ensuring the patches are ready for upstream integration without introducing regressions in existing s390 or Arm virtualization paths.

How have Arm maintainers received these patches?

The Arm maintainers have welcomed the patch set positively, recognizing its potential to expand the reach of Arm virtualization. However, they have raised concerns about how the collaboration between architectures should be structured. The key issue is preventing future maintainability problems on the Arm side—changes to s390 emulation code must not inadvertently complicate Arm's own virtualization maintenance. Once these structural discussions are resolved, the patches are expected to proceed toward inclusion in the mainline kernel.

What are the main maintainability concerns raised?

The primary concern revolves around code organization and ownership. When two different architectures share emulation logic, changes made for one could break the other. Arm maintainers want to ensure that any shared code paths are clearly defined, with proper abstraction layers, so that future modifications to s390 acceleration do not require constant oversight from the Arm team. This could involve creating a common interface for hardware-assisted emulation or dedicating a separate subsystem. The goal is to avoid situations where a patch intended to improve s390 performance inadvertently introduces bugs or performance regressions for Arm-native virtualization.

What impact could this have on virtualization workloads?

If successfully integrated, this patch set would allow s390 hosts to run Arm virtual machines at nearly native speeds. This is particularly valuable for cloud providers and data centers that maintain heterogeneous hardware. For example, an organization with s390 mainframes could seamlessly deploy Arm-based workloads without needing separate physical Arm servers. The technology also opens the door to better resource utilization, as s390 systems often have spare capacity that could be used for Arm VMs. Additionally, it simplifies testing and development—developers can work on Arm software using familiar s390 infrastructure without performance penalties.

How will the collaboration between architectures be structured?

Details are still being negotiated, but the proposed approach involves creating a shared layer in the kernel that handles the interface between the s390 hardware acceleration and the Arm emulation core. This abstracted layer would be maintained jointly by both architecture teams, with clear ownership boundaries. The patch authors have indicated willingness to adjust the code structure based on Arm maintainers' feedback. The ultimate goal is a model where each architecture can independently evolve its acceleration support while still benefiting from the same fundamental emulation logic. Once finalized, this collaboration structure could serve as a blueprint for future cross-architecture virtualization efforts.