5 Key Insights into Hardware-Assisted Arm Virtual Machines on s390

The world of virtualization is taking an unexpected turn with a new patch set from Steffen Eiden and colleagues, which lays the foundation for running Arm-based virtual machines (VMs) on s390 hosts with hardware assistance. This innovative approach promises near-native performance while leveraging the unique capabilities of IBM's mainframe architecture. In this article, we break down the five most important things you need to know about this development, from the technical breakthrough to the collaboration challenges ahead. Whether you're a kernel developer or a virtualization enthusiast, these insights will help you understand the impact of bringing Arm VMs to s390.

1. The Groundbreaking Patch Set

The core of this advancement is a patch set, now in its second version, submitted by Steffen Eiden and several contributors. This code introduces hardware-assisted emulation of Arm CPUs on s390 systems, a feat previously considered impractical due to the architectural differences between the two platforms. The second version fixes minor issues from the first, but the fundamental approach remains unchanged: it enables the s390 hypervisor to directly execute Arm instructions using built-in hardware capabilities. This bypasses the need for traditional full software emulation, drastically reducing overhead. The patch set is relatively small and focused, targeting the KVM subsystem to allow Arm VMs to be launched transparently on s390 hosts. For a deeper dive into the technical details, check out item 3.

2. Welcomed by Arm Maintainers

The response from the Arm architecture maintainers has been notably positive. They see this patch set as a promising step toward cross-architecture virtualization, but they have raised an important caveat: the collaboration structure between s390 and Arm must be clearly defined to avoid maintenance headaches down the line. The Arm maintainers are concerned about potential code duplication and complexity if every architecture tries to emulate another. They suggest a shared framework that abstracts common emulation patterns, allowing Arm to focus on its own optimizations while s390 can reuse components. This discussion is ongoing, but the initial reception indicates that the path forward is viable with proper governance. The outcome will likely shape how future cross-architecture emulation efforts are organized.

3. How Hardware Assistance Works

Hardware-assisted emulation leverages specific CPU features on s390 that can interpret Arm instruction sets at a low level. Unlike pure software emulation, which translates every instruction in software (often resulting in orders-of-magnitude performance hits), this method uses microcoded assistance or dedicated execution units within the s390 processor. The patch set modifies KVM to detect Arm VM requests and route them to this hardware path. The result is near-native performance for Arm workloads running on s390, a game-changer for data centers that want to consolidate diverse workloads on mainframe hardware. For the technical background on why this is significant, revisit item 1. The approach is still experimental, but early benchmarks show promise.

4. Maintainability Challenges and Solutions

One of the primary hurdles identified is ensuring that the Arm emulation code does not become a burden for Arm maintainers. The patch set introduces architecture-specific hooks that could conflict with future Arm kernel changes. To mitigate this, the proposal includes isolating the emulation layer behind clear APIs, so that Arm's own code remains untouched. Additionally, the s390 team must commit to keeping their emulation logic updated as Arm evolves. The Arm maintainers have suggested creating a common emulation library that multiple architectures can share, reducing duplication. This structure would allow s390 to stay aligned with Arm developments without requiring extensive cross-architecture knowledge. The discussion is a model for how to handle similar cross-pollination in the kernel community.

5. Implications for Virtualization and Data Centers

If merged, this patch set could revolutionize how data centers operate. s390 mainframes are known for their reliability and scalability, while Arm processors dominate in energy efficiency and are increasingly used in cloud environments. By allowing Arm VMs to run natively on s390, organizations could migrate existing Arm-based microservices to mainframe infrastructure without rewriting them. This enables hybrid architectures where the mainframe handles heavy lifting and Arm VMs provide flexibility. The technology also opens the door to other cross-architecture emulations, though each would require similar groundwork. The near-native speed means performance is no longer a barrier, making this a practical solution for multi-architecture cloud deployments. The next steps involve finalizing the collaboration model (see item 2) and testing with real-world Arm workloads.

In conclusion, Steffen Eiden's patch set marks an exciting milestone in virtualization. While challenges remain—especially around maintainability and collaboration—the potential to run Arm VMs at near-native speeds on s390 is a significant technical achievement. As the kernel community works through the details, we can expect to see this feature mature and possibly pave the way for other architectural bridges. For now, keep an eye on the KVM mailing list for the next version of the patch set. The future of cross-architecture virtualization is being written, one instruction at a time.