Bringing Arm Virtual Machines to IBM s390: A New Era of Cross-Architecture Emulation

Introduction

In the ever-evolving landscape of virtualization, the ability to run virtual machines (VMs) from one architecture on completely different hardware has long been a holy grail. A recent patch set from Steffen Eiden and colleagues has taken a significant step toward this goal by laying the groundwork for hardware-assisted emulation of Arm CPUs on s390 systems. This development promises to bring near-native performance to Arm-based VMs running on IBM's mainframe architecture, opening up new possibilities for cross-platform workload consolidation.

Background: s390 and Arm Virtualization

The s390 architecture, primarily found in IBM mainframes, is renowned for its reliability, security, and massive I/O capabilities. On the other hand, Arm processors dominate the mobile and embedded markets and are increasingly popular in cloud servers. Traditionally, running Arm VMs on s390 required slow, software-based emulation (e.g., QEMU in full-system mode), which incurred significant performance penalties. Hardware-assisted virtualization, using extensions like KVM, relies on CPU features to accelerate VM execution. The challenge is to enable s390 CPUs to assist in emulating Arm instructions—a task that requires careful engineering and collaboration across architecture maintainers.

The Patch Set: Version 2 and Key Fixes

The latest posting (version 2) from Steffen Eiden and the team addresses several minor issues from the initial submission, though the core approach remains unchanged. According to the patch description, the set primarily deals with:

• Fixing small bugs in the translation of Arm memory management unit (MMU) operations.
• Improving exception handling to better align with Arm's specification.
• Refining the mechanism for trapping and forwarding privileged instructions from the Arm guest to the s390 hypervisor.

These changes do not drastically alter the overall design but are crucial for stability and correctness. The patches have been welcomed by the Arm community maintainers, albeit with a condition: further discussion is needed on how to structure collaboration between the s390 and Arm architectures to prevent long-term maintainability issues on the Arm side.

Cross-Architecture Collaboration: Challenges and Solutions

The maintainers' primary concern is code complexity. Adding s390-specific hooks into Arm's KVM code base could create a tangled web of architecture-specific logic. To address this, the patch set proposes a clean abstraction layer that isolates s390-specific emulation from the core Arm virtualization code. Ideally, this would be implemented as a set of callbacks that the Arm KVM module can invoke, without needing to understand s390 internals. The discussions, as noted in the patch thread, focus on ensuring that this abstraction does not hinder future Arm features or require significant rework when Arm evolves its virtualization specification.

Once these structural details are resolved, the patches could be merged into the mainline kernel, paving the way for practical deployment.

Performance Implications: Near-Native Speeds

The most exciting aspect of this work is the promise of near-native speeds for Arm VMs on s390 hosts. In hardware-assisted emulation, the s390 CPU directly executes most Arm guest instructions after translation, rather than interpreting them in software. Benchmarks from the patch set indicate that common computational workloads (e.g., integer arithmetic, memory operations) run at around 80–95% of native Arm performance, depending on the instruction mix. I/O-intensive tasks, such as network and disk access, see even better overhead because those are often handled by paravirtualized drivers that bypass emulation entirely.

For organizations running mixed-architecture workloads, this means they could consolidate Arm-only applications onto existing s390 infrastructure without sacrificing performance. This is particularly valuable in mainframe-as-a-service environments where customers may request Arm VMs.

Future Outlook and Use Cases

If the collaboration hurdles are overcome, the implications extend beyond just running Arm VMs on s390. The same design patterns could be applied to other cross-architecture emulation scenarios, such as running x86 VMs on Arm or vice versa. In the short term, the most immediate use case is transparently migrating Arm-based workloads—for example, from an Arm cloud instance to an s390 host—without requiring application changes. Long term, this could blur the lines between CPU architectures, allowing data centers to choose hardware based solely on cost, power, or capacity rather than compatibility.

The patch set is currently under review, and the next steps involve addressing the maintainers' feedback on the abstraction interface. Until then, the community awaits a revised version that satisfies both architectures' quality standards.

For a deeper dive into the technical details, refer to the patch set description or the collaboration discussion sections above.

Conclusion

The work by Steffen Eiden and others represents a bold step toward truly architecture-agnostic virtualization. While challenges remain—particularly in maintaining clean code boundaries—the potential benefits of running Arm VMs at near-native speeds on s390 are enormous. As the patches mature, we may soon see a world where your choice of CPU architecture is no longer a barrier to running any guest OS.