In early April, IBM surprised the tech world by announcing a collaboration with Arm to develop “dual architecture hardware. The first concrete result of this partnership is a set of Linux kernel patches that enable ARM64 virtualization acceleration on IBM Z servers. As April draws to a close, IBM has released a second iteration of these patches, which allow AArch64 software to run on IBM s390 systems using the Kernel-based Virtual Machine (KVM). This Q&A explores the details, significance, and next steps of this development.
What is the IBM-Arm collaboration about and what are “dual architecture” hardware?
IBM and Arm announced they are working together to create hardware that can natively run both IBM Z’s proprietary architecture (s390) and Arm’s 64-bit (AArch64) instruction set. “Dual architecture” means a single server platform that supports two different CPU architectures simultaneously. For example, future IBM Z machines could host processors that understand both s390 and Arm instructions, or they could use a combination of dedicated chips. The goal is to let enterprise customers run Arm-native workloads without needing separate Arm servers, taking advantage of IBM Z’s legendary reliability and security while tapping into Arm’s energy efficiency and ecosystem. The first fruits of this collaboration are software-based: Linux kernel patches that use KVM to virtualize an Arm environment on top of s390 hardware.
What are the new Linux kernel patches and what do they do?
The patches, now in their second iteration, add support for ARM64 virtualization acceleration on IBM Z (s390) systems. They modify the KVM (Kernel-based Virtual Machine) hypervisor within the Linux kernel to expose virtual Arm CPU features to guest operating systems. Specifically, they enable the host (s390) to trap and emulate AArch64 instructions, manage page tables for Arm guests, and handle interrupts as if the guest were running on native Arm hardware. This allows standard AArch64 Linux distributions and applications to run as virtual machines on IBM Z servers. The patches are part of the upstream Linux kernel development process, where they undergo review before being merged into the mainline kernel.
How does KVM enable ARM64 software to run on IBM Z (s390) servers?
KVM turns the Linux kernel into a Type-1 hypervisor. On s390, KVM normally virtualizes s390 guests. With these patches, KVM gains a new “machine type” that emulates an ARM64 system. When a user launches a virtual machine with an ARM64 guest, KVM uses hardware virtualization features of the s390 processor (like the z/VM or LPAR support) to create an isolated environment. Inside that environment, the patches implement instruction emulation: every AArch64 instruction that the guest tries to execute is trapped by the hypervisor, decoded, and emulated using the host’s s390 instruction set. Memory management is handled by mapping guest ARM page tables to host ones. Device emulation (storage, network, etc.) uses QEMU, which has been updated to run on s390 and present virtual Arm peripherals. The result is a functional, albeit slower, ARM64 virtual machine running on IBM Z.
Why is this development significant for enterprise computing?
IBM Z mainframes are the gold standard for mission-critical workloads requiring high availability, security, and massive I/O throughput. Arm processors, on the other hand, offer superior power efficiency and are increasingly popular in cloud-native environments (e.g., AWS Graviton, Ampere Altra). By enabling ARM64 VMs on s390, IBM bridges these worlds. Enterprises can consolidate Arm workloads onto their existing mainframes, reducing hardware footprint and operational costs. It also opens the door to running containerized Arm applications in a mainframe-grade environment. For software vendors, it simplifies testing: they can validate Arm code on s390 without needing separate Arm hardware. Additionally, this aligns with IBM’s hybrid cloud strategy, allowing seamless workload portability between on-premises Z systems and public cloud Arm instances. The patches represent a strategic move to keep mainframes relevant in the Arm-dominated future of cloud computing.
What challenges are involved in running ARM64 virtualization on s390?
The biggest challenge is performance. Emulating one CPU architecture on another is inherently slower than native execution, because every guest instruction must be trapped, decoded, and emulated. The patches use hardware acceleration where possible (e.g., nested page tables), but many AArch64 instructions still require software emulation. Another challenge is feature completeness: not all Arm CPU features (e.g., SVE, cryptographic extensions) may be supported initially. The patches also introduce complexity in the KVM codebase, requiring thorough testing to avoid regressions for s390 guests. Additionally, device emulation via QEMU must be accurate to avoid guest bugs. Finally, the dual-architecture hardware that IBM and Arm announced is still in development; current patches rely purely on emulation on existing s390 systems. Once physical hardware with both architectures appears, performance will improve dramatically, but software emulation is the only option today.
What is the current status of these patches and what can we expect next?
As of late April, IBM has posted version 2 of the ARM64 KVM acceleration patches to the Linux kernel mailing list. This second iteration addresses feedback from the first review, fixing issues and adding support for more advanced Arm features, such as virtualization extensions (VE) and generic timers. The patches are still considered experimental and are not yet merged into the mainline kernel. The next steps include further code review from the KVM and ARM maintainers, additional rounds of patching, and eventually inclusion in a future Linux kernel release (possibly 6.1 or later). Once merged, distribution vendors like Red Hat and SUSE may backport it to their enterprise kernels. IBM also continues to work on the dual-architecture hardware; expect announcements about silicon prototypes in the next 12–18 months. In the meantime, developers can experiment with these patches to test Arm workloads on IBM Z.