Bringing Arm Virtual Machines to IBM s390 Hardware: A Q&A Overview

Recent developments in the Linux kernel community have opened the door for running Arm-based virtual machines (VMs) on IBM s390 (System/390) hardware with near-native performance. A patch set from Steffen Eiden and colleagues lays the groundwork for hardware-assisted emulation of Arm CPUs on s390 platforms. While version two of the patches addresses minor issues, the core approach remains unchanged. Arm maintainers have welcomed the initiative, though discussions continue on how to structure cross-architecture collaboration to avoid maintainability challenges. This Q&A explores the key aspects of this advancement, from technical details to potential impact. Jump to What is this patch set about?, Who contributed to it?, or How does hardware-assisted emulation work?

What is this patch set about?

The patch set, submitted by Steffen Eiden and others, introduces support for hardware-assisted emulation of Arm CPUs on IBM s390 systems. This means that instead of relying purely on software emulation (which is slow), the patches utilize hardware features of the s390 architecture to accelerate Arm instruction execution. The goal is to allow Arm-based virtual machines to run on s390 hosts at speeds close to native Arm hardware. Version two of the patches fixes several minor bugs and improves stability, but the overall design remains consistent with the initial proposal. This development is significant because it bridges two distinct CPU architectures, enabling greater flexibility in virtualized environments—for instance, data centers with s390 servers could run Arm workloads without dedicated Arm hardware.

Bringing Arm Virtual Machines to IBM s390 Hardware: A Q&A Overview

Who contributed to this work?

The patch set is primarily the work of Steffen Eiden and a group of collaborators. While the specific names of all contributors are not detailed in the original announcement, the patches were posted to the Linux kernel mailing list for review. The effort involves expertise from both the s390 and Arm communities, as the patches touch core virtualization infrastructure. The Arm maintainers, responsible for overseeing the Arm architecture code in the kernel, have expressed positive reception towards the concept, acknowledging its potential value. However, they emphasize the need for careful planning to ensure that the integration does not create long-term maintainability problems. The collaboration between the two architecture teams will be crucial for final acceptance.

How does hardware-assisted emulation work on s390?

Hardware-assisted emulation leverages specific features of the host CPU to accelerate the execution of guest instructions. In this case, the s390 host uses its virtualization extensions (like the SIE (Start Interpretive Execution) facility) to intercept and emulate Arm instructions. The patches add a new virtualization layer that translates Arm system-level operations into s390-compatible operations, while allowing the host hardware to directly handle performance-critical tasks. This approach is far more efficient than pure software emulation (e.g., QEMU without KVM), as it reduces the overhead of decoding and executing each guest instruction. The result is near-native performance for Arm VMs running on s390 hosts, provided the workload does not rely on Arm-specific hardware features not yet emulated.

What was the response from Arm maintainers?

The Arm maintainers have welcomed the patch set, recognizing its potential to expand the ecosystem. However, they have raised concerns about maintainability. The patches introduce Arm architecture code into the s390 virtualization path, which blurs traditional boundaries. The maintainers want to ensure that any changes made for s390 do not inadvertently break Arm-specific functionality or create extra burden for those maintaining Arm KVM code. To address this, they are discussing interface boundaries and abstraction layers. For instance, they propose defining clear APIs between the architecture-specific and cross-architecture code, so that future changes on either side do not require constant coordination. Once these structural details are resolved, the patches can move toward inclusion in the mainline kernel.

What are the potential benefits of this technology?

The primary benefit is transparency: data centers running s390 servers could seamlessly run Arm-based virtual machines without additional hardware. This enables workload consolidation, as Arm-native applications (e.g., from the growing ecosystem of Arm server chips) can be deployed on existing s390 infrastructure. It also saves costs by avoiding the need for dedicated Arm servers. Additionally, it fosters cross-architecture innovation, allowing developers to test and deploy software across different CPU families from a single host. The near-native performance means that compute-intensive Arm workloads like AI inference or containerized microservices can run efficiently. For cloud providers, this flexibility could lead to new service offerings and better resource utilization.

What challenges remain before adoption?

Several hurdles must be overcome. First, the collaboration structure between s390 and Arm maintainers needs formalization to prevent future conflicts. Second, the patches require thorough testing to ensure that Arm VMs behave correctly under various workloads, especially those interacting with paravirtualized devices. Third, performance tuning is needed—while hardware assistance improves speed, there may still be bottlenecks in translating memory mappings or interrupt handling. Fourth, the emulation completeness must be vetted: not all Arm instructions or system registers may be supported in the initial implementation. Finally, community acceptance and review cycles take time; version three or more of the patches may be necessary. Despite these challenges, the overall trajectory is positive, and the patches could land in a future kernel release if the maintainability concerns are resolved.

How does this compare to existing cross-architecture virtualization?

Existing solutions for cross-architecture virtualization (e.g., running x86 VMs on ARM or vice versa) typically rely on full software emulation, which is slow (often 10-100x slower than native). In contrast, hardware-assisted emulation on s390 aims for near-native speeds by using host CPU features. Another approach is binary translation, used by tools like QEMU's user-mode emulation, but it still incurs significant overhead. The key difference here is that the patch set focuses on system-level virtualization—running a full Arm OS with KVM—rather than just user-space emulation. This is closer to how Intel’s VT-x enables running x86 VMs on x86 hardware, but applied across architectures. If successful, it could serve as a model for other cross-architecture combinations, such as running RISC-V VMs on x86 hosts with similar hardware assistance.