ppc64
pseries, ppc64el names for users for contributors
64-bit POWER: ten little-endian Ubuntu systems named ppc64el, run by qemu-system-ppc64 on QEMU's pseries machine with a POWER9 CPU and its own SLOF firmware, all devices on PCI; a ppc64le host counts as ppc64 and runs them under KVM with four vCPUs, anywhere else TCG emulates them on one.
On the map: architectures
▶ Watch this deck — 9 scenes, ~6 min
Worth seeing first
- Six architectures, six QEMU machines — the machine, CPU and accelerator choices every architecture shares
01 POWER, little-endian
Ten Ubuntu systems, 14.04 to 26.10, all little-endian and named .ppc64el: image-garden make ubuntu-cloud-24.04.ppc64el.run.
Say your software ships for IBM's POWER servers, or someone reports a failure there that you can't reproduce on a PC. image-garden runs 64-bit POWER on QEMU's pseries machine, and the systems there are Ubuntu's: ten releases, from 14.04 on. Ubuntu builds them little-endian, so the running example is named ubuntu-cloud-24.04.ppc64el. You build it with one make command for its .run script, like any other system. On a PC it's emulated, so give it time. This deck shows the three spellings of its name, the machine, what emulation costs, the installs that bring it, and the gotchas, starting with what POWER doesn't test.
Details and sources
Details
- Ubuntu on ppc64, "systems named
.ppc64el": 14.04, 16.04, 18.04, 20.04, 22.04, 24.04, 25.04, 25.10, 26.04, 26.10 (README.md:692-697). No other distribution has a ppc64 system, and there is no big-endian ppc64 system. - They are little-endian: "a ppc64le host runs the ppc64 (little-endian) systems natively" (mk/000-garden.mk:14-16).
- The release notes that added the architecture: "Currently all systems emulate a virtual Power 9 processor in a P-Series machine" (NEWS:624-628).
for contributors
In the data
- The sections run from data/ubuntu.ini:24-28 (14.04) to data/ubuntu.ini:422-426 (26.10); the running example is data/ubuntu.ini:264-268. All have
Arch=ppc64and noBoot; no other INI file hasArch=ppc64(counted at the commit: 10 sections).
Read more
02 Where the spellings meet in the code for contributors in place of the general version
[ubuntu-cloud-24.04.ppc64el] has Arch=ppc64; GARDEN_HOST_ARCH maps ppc64le to ppc64; define-instance takes the architecture from Arch.
Inside, the three spellings meet in a few places. The section is named for Ubuntu, ubuntu-cloud-24.04.ppc64el, but says Arch=ppc64. rulegen.py only checks that the name and the URL contain the Arch value, and both do. Arch picks the ppc64 rules and decides when a system joins make all. To match it on a POWER host, GARDEN_HOST_ARCH is uname -m with ppc64le replaced by ppc64, and the native CPU count follows that name. Named instances read their base's Arch from the systems metadata rather than the suffix of its name, so they get the pseries command line too.
Details and sources
Details
[ubuntu-cloud-24.04.ppc64el]hasArch=ppc64(data/ubuntu.ini:264-268). rulegen.py requires the section name to contain theArchvalue ("Suspicious image") and, for architectures other than x86\_64 and aarch64, the URL too ("Suspicious URL") (rulegen.py:396-416).all::andfetchcompareGARDEN_ARCHwith theArchvalue (rulegen.py:453-459, rulegen.py:480-484); ppc64 sections getruleset_ppc64(rulegen.py:707-724, rulegen.py:820-821).GARDEN_HOST_ARCH := $(patsubst ppc64le,ppc64,$(shell uname -m)), the default ofGARDEN_ARCH(mk/000-garden.mk:14-18); the native vCPU count is set onQEMU_SMP_followed by that name upper-cased (mk/010-qemu.mk:5-6).define-instancetakes the QEMU architecture from the base's_SYSTEM_archmetadata, written by rulegen.py fromArch, and compares it withGARDEN_ARCHforall::(mk/020-instances.mk:53-65).- Known discrepancy: define-instance without an arch suffix finds no base on a POWER host. When the base is given without a suffix,
define-instanceappendsGARDEN_ARCH,ppc64there, and looks forubuntu-cloud-24.04.ppc64, which has no metadata: the instance gets no boot type and no.runor.qcow2rule (mk/020-instances.mk:31-39, mk/020-instances.mk:84-146). Derived from the code, not run.
Read more
03 ppc64, ppc64el, ppc64le general version
qemu-system-ppc64 and the qemu-ppc64 component, the system ubuntu-cloud-24.04.ppc64el, and a host whose uname -m says ppc64le, which image-garden counts as ppc64.
One architecture, three spellings. QEMU calls it ppc64: that's the emulator, and the snap's component. Ubuntu calls its little-endian port ppc64el, and that's the system name, so you make ubuntu-cloud-24.04.ppc64el .run, allocate that same name, and define named instances of it. A POWER host's kernel says ppc64le, from uname -m. image-garden treats such a host as ppc64, so make all there builds the ppc64el systems and gives them four CPUs. Your own scripts are another matter: anything that pastes uname -m onto a system name asks for ppc64le, which names no system.
Details and sources
Details
- The emulator is
qemu-system-ppc64and the snap's componentqemu-ppc64(mk/010-qemu-ppc64.mk:3, snap/snapcraft.yaml:87-92); the system is namedubuntu-cloud-24.04.ppc64el(data/ubuntu.ini:264-268). - On a host whose
uname -misppc64le, image-garden usesppc64as the host architecture: "On a ppc64le host the ppc64 systems are native: "all" makes them and they get the native vCPU count" (NEWS:19-20, mk/000-garden.mk:14-18). - "Named instances of the ppc64 systems (SYSTEM.ppc64el) can be run" (NEWS:10-11); see named instances.
- The README's spread example appends
$(uname -m)to the system name (README.md:740-745), which on a POWER host givesppc64le; see the gotchas.
Read more
04 The pseries machine
qemu-system-ppc64 -machine pseries -cpu power9, -smp 1 (4 on POWER), -m 2048; every device on PCI; QEMU's SLOF boots the disk with bootindex=0.
The .run script starts QEMU's ppc64 emulator on pseries, the paravirtualised POWER machine that IBM's hypervisors present to their guests, with a POWER9 CPU. It gets one CPU, or four on a POWER host, and two gigabytes. Unlike s390x, everything here sits on PCI: the disk, asked for as plain virtio-blk, becomes a virtio PCI disk, beside the network card and the random number generator. There's no firmware to install or copy: the machine loads SLOF, its own Open Firmware, from QEMU's data files, and SLOF boots the disk marked as boot index zero. The provisioning boot adds the seed as a second virtio disk.
Details and sources
Details
QEMU_SYSTEM_PPC64_MACHINE = pseries,QEMU_CPU_PPC64 = power9,QEMU_SMP_PPC64 = 1,-netdev userwithvirtio-net-pci, and the disk-device virtio-blk,drive=drive0,bootindex=0; no firmware option (mk/010-qemu-ppc64.mk:3-21).-m 2048,-nographicand-device virtio-rng-pciare common to every architecture (mk/010-qemu.mk:5-13, mk/010-qemu.mk:45).- The snap's ppc64 component carries
efi-virtio.rom,slof.bin,u-boot-sam460.bin,vgabios-stdvga.bin,vgabios-virtio.bin,vof.binandvof-nvram.bin(snap/snapcraft.yaml:409-411). - That pseries loads SLOF by default, that SLOF boots the device with the lowest boot index, and that QEMU resolves
virtio-blktovirtio-blk-pcion this machine are QEMU's behaviour (derived).
for contributors
In the rules
- ppc64 boots only
platform, the default withoutBoot(rulegen.py:300-333).ruleset_ppc64adds the seed to the provisioning boot as-device virtio-blk,drive=drive1(rulegen.py:707-724).
Read more
05 KVM on POWER, TCG elsewhere general version
On a ppc64le host with KVM: accel=kvm:tcg and -smp 4. Elsewhere TCG and -smp 1; one image took up to 9.8 minutes to make and boot on x86_64.
On a POWER host with KVM, the guest runs close to native speed, and since image-garden counts a ppc64le host as ppc64, it gets four CPUs there. Everywhere else, the .run script finds only TCG, and QEMU translates every POWER instruction, on one CPU. To give you a feel for it, making and booting one of these images once has taken up to ten minutes on an x86_64 machine. So set long timeouts, and for your own runs, QEMU_SMP_OPTION gives an emulated guest more CPUs.
Details and sources
Details
- The
.runscript asksqemu-system-ppc64 -accel helpand usesaccel=kvm:tcgwhenkvmis listed, elseaccel=tcg(mk/010-qemu-ppc64.mk:31, mk/010-qemu-ppc64.mk:38). - ppc64 guests get 1 vCPU, and 4 on a host whose
uname -misppc64le(mk/010-qemu-ppc64.mk:6, mk/010-qemu.mk:5-6, mk/000-garden.mk:14-18). The README lists ppc64le hosts as tier 3, "Native where KVM is available" (README.md:389-396). - The 9.8 minutes is the longest time recorded for one ppc64el image, made and booted once with
-smp 2on an x86\_64 machine (.gitlab-ci.yml:993-1002). - Under KVM,
-cpu power9needs a host that can run a POWER9 guest, POWER9 or later in compatibility mode;QEMU_CPU_PPC64can be set on the make command line or in.image-garden.mk(derived).
Read more
06 How image-garden's CI tests ppc64el for contributors in place of the general version
Stage ppc64el: two jobs on x86_64 runners with ARCH: ppc64el, GARDEN_TEST_BOOT_ONLY, -smp 2, 40 minutes per system, allow_failure: true.
On a POWER host with KVM the guest runs natively, with four CPUs, since a ppc64le host counts as ppc64. image-garden's own pipeline has no such host, so it tests these systems under TCG, in a stage named ppc64el on x86_64 runners, with ARCH set to ppc64el: two jobs of five Ubuntu releases each. They only make and boot every image once, with -smp 2, give each system forty minutes, run on version tags or by hand, and may fail without holding anything up. The comments record about twenty-six and twenty-nine minutes per job, and up to ten for a single image.
Details and sources
Details
- Every system job sets
QEMU_SMP_OPTION: -smp 2andQEMU_MEM_OPTION: -m 1024(.gitlab-ci.yml:568-569);.systems-emulatedruns on x86\_64 runners taggedqemu-emulated,GARDEN_TEST_BOOT_ONLY: "1",GARDEN_CI_SYSTEM_TIMEOUT: 40m,allow_failure: true, manual outside version tags (.gitlab-ci.yml:663-690). ppc64el: [ubuntu 1/2](14.04 to 22.04, 80 minutes, "25.9 minutes on novigrad; calvin took up to 9.4 for one") andppc64el: [ubuntu 2/2](24.04 to 26.10, 85 minutes, "28.5 minutes on novigrad; calvin took up to 9.8 for one"), both withARCH: ppc64el(.gitlab-ci.yml:982-1002).tests/ci/run-systems.shknowsppc64elas an architecture suffix and makesSYSTEM.ARCH.run(tests/ci/run-systems.sh:38, tests/ci/run-systems.sh:62-72). The CI installs Ubuntu'sqemu-system-ppcpackage (.gitlab-ci.yml:292-310).
Read more
07 Snap, container or packages
Snap: snap install image-garden+qemu-ppc64. Container: ppc64-softmmu, no prefix. Ubuntu: qemu-system-ppc.
Every install can run it. In the snap, QEMU for ppc64 is a component: snap install image-garden+qemu-ppc64. On a PC you add it by hand, as the snap only installs your host's own. It brings the emulator, SLOF and the other files its machines load. Forget it, and you find out after the image has downloaded: the provisioning boot stops with a notice that names the command. The container builds QEMU with ppc64 among its targets, and needs no firmware prefix for it. On a distribution, install its POWER QEMU, which on Ubuntu is the package called qemu-system-ppc, without the sixty-four.
Details and sources
Details
- The
qemu-ppc64component: "This component contains the ppc64 64-bit system emulator (QEMU)" (snap/snapcraft.yaml:87-92), withqemu-system-ppc64, the keymaps,efi-virtio.rom,slof.bin,u-boot-sam460.bin,vgabios-stdvga.bin,vgabios-virtio.bin,vof.binandvof-nvram.bin(snap/snapcraft.yaml:409-411). - The install hook installs the component for the host's architecture and
+pkgproxy(snap/hooks/install:6-14); on an x86\_64 host the ppc64 component is added by hand (README.md:309-324). - Without it, the snap's stand-in for
qemu-system-ppc64prints "It seems that the component with QEMU ppc64 is not installed" andsnap install image-garden+qemu-ppc64, and exits 1 (qemu-stubs/qemu-system-ppc64:9-31). The first QEMU to run is the provisioning boot, after the download. - The container's QEMU target list includes
ppc64-softmmu(Dockerfile:33); it setsGARDEN_*_PREFIXonly for the four efi architectures (Dockerfile:98-102). - On Ubuntu the emulator is in the
qemu-system-ppcpackage. Distribution packages of image-garden may be older than the upstream release (the maintainer's statement).
for contributors
In the tree
- The install and post-refresh hooks name the host's component
qemu-$(uname -m)with_made-(snap/hooks/install:7, snap/hooks/post-refresh:11). On a POWER host that isqemu-ppc64le, a component the snap does not have. Whether the snap is published for POWER is not in the tree; suspected, not run. - The first QEMU to run is the
.qcow2rule's provisioning boot (rulegen.py:716-723). image-garden's CI installsqemu-system-ppc(.gitlab-ci.yml:292-310).
Read more
08 Gotchas, and what POWER doesn't test
Little-endian, like a PC. Watch for 64 KiB pages, unsigned char, and uname -m giving ppc64le: spread backends need ARCH=ppc64el, instances the full base name.
First, what ppc64 doesn't test. Every system here is little-endian, so byte-order mistakes pass just as they do on a PC; for big-endian, use s390x. What POWER does catch is different. Ubuntu's kernels there use sixty-four kilobyte pages, so code that assumes four kilobytes gets its mappings wrong. Plain char is unsigned, too. And the name trips scripts: a spread backend that appends uname -m asks a POWER host for a ppc64le system, which doesn't exist. Set ARCH to ppc64el for such a backend. And a named instance there needs its base's full name, ending in ppc64el.
Details and sources
Details
- Every ppc64 system is Ubuntu's little-endian ppc64el (mk/000-garden.mk:14-16), so byte-order assumptions are not tested here; s390x is the big-endian architecture.
- Ubuntu's ppc64el kernels use 64 KiB pages, and plain
charis unsigned in the POWER Linux ABI (derived: general knowledge, not in image-garden's tree). Usesysconf(_SC_PAGESIZE)rather than 4096. - The README's spread backend appends
$(uname -m)(README.md:740-745); image-garden's ownspread.yamlappends$ARCH, defaulting touname -m(spread.yaml:43-47). On a POWER hostuname -misppc64le; setARCH=ppc64el, or use the system name with its suffix. - Known discrepancy: define-instance without an arch suffix finds no base on a POWER host. Given
ubuntu-cloud-24.04alone,define-instanceappendsppc64there and finds no such system (mk/020-instances.mk:31-39); give the fullubuntu-cloud-24.04.ppc64el. Derived from the code, not run.
for contributors
In image-garden's CI
- The ppc64el jobs set
ARCH: ppc64el, andtests/ci/run-systems.shlistsppc64elamong its architectures (.gitlab-ci.yml:982-1002, tests/ci/run-systems.sh:38).
Read more
09 Where to go from here
Next: six architectures, s390x, Ubuntu cloud images, named instances, spread names, snap components and the .run script.
So ppc64 is one machine with its own firmware, three spellings of one name and ten little-endian Ubuntu systems. From here, the architectures deck sets it beside the other five machines, and the s390x deck covers the big-endian one, for the tests POWER can't do. The Ubuntu deck shows the releases and what each holds. The instances and spread names decks show how names and architectures meet, the snap components deck how components install, and the run script deck how to give a slow guest more CPUs.
Details and sources
Read more
- Six architectures, s390x, Ubuntu cloud images.
- Named instances, spread names, snap components, the .run script.
- The other architectures: x86_64, aarch64, riscv64, loongarch64.
Read more
Basis of the statements on this page
Read in mk/010-qemu-ppc64.mk, mk/010-qemu.mk, mk/000-garden.mk, mk/020-instances.mk, rulegen.py, data/ubuntu.ini, snap/snapcraft.yaml, the snap's hooks, qemu-stubs/qemu-system-ppc64, the Dockerfile, spread.yaml, .gitlab-ci.yml, NEWS and the README of image-garden at the commit in garden.commit ("code"). The timings are the comments in .gitlab-ci.yml. What QEMU does with the device names and firmware on pseries, page sizes, the C ABI and KVM CPU compatibility are general knowledge ("derived"). Nothing was run for this page.
The ppc64 machine
| Fact | Value | Where |
|---|---|---|
| QEMU binary | qemu-system-ppc64; in the snap the image-garden.qemu-system-ppc64 app | QEMU_SYSTEM_PPC64 |
| Machine | pseries | QEMU_SYSTEM_PPC64_MACHINE |
| CPU | power9 | QEMU_CPU_PPC64 |
| vCPUs | 1, or 4 on a ppc64le host | QEMU_SMP_PPC64, QEMU_SMP_OPTION |
| Memory | 2048 MiB | QEMU_MEM_SIZE, QEMU_MEM_OPTION |
| Accelerator | kvm:tcg when QEMU lists KVM, else tcg | QEMU_ACCEL_MACHINE_PROP |
| Disk | -device virtio-blk,drive=drive0,bootindex=0, virtio-blk-pci (derived) | QEMU_STORAGE_OPTION |
| Seed (provisioning boot) | a second virtio-blk, media=cdrom | the .qcow2 rule |
| Network | -netdev user, -device virtio-net-pci | QEMU_NET_OPTION |
| Random numbers | -device virtio-rng-pci | QEMU_RNG_OPTION |
| Display | -nographic | QEMU_DISPLAY_OPTION |
| Boot | platform: no firmware files; QEMU's SLOF (derived) | |
| Snap component | qemu-ppc64: qemu-system-ppc64, keymaps, efi-virtio.rom, slof.bin, u-boot-sam460.bin, vgabios-stdvga.bin, vgabios-virtio.bin, vof.bin, vof-nvram.bin | snap/snapcraft.yaml |
| Container | QEMU built with ppc64-softmmu; no prefix variable | Dockerfile |
| Ubuntu package | qemu-system-ppc | |
| Byte order | little-endian (all systems are ppc64el) |
Sources: mk/010-qemu-ppc64.mk:3-21, mk/010-qemu.mk:5-13, mk/000-garden.mk:14-18, snap/snapcraft.yaml:409-411, Dockerfile:33.
The ten systems
| System | Image |
|---|---|
ubuntu-cloud-14.04.ppc64el | trusty-server-cloudimg-ppc64el-disk1.img |
ubuntu-cloud-16.04.ppc64el | xenial-server-cloudimg-ppc64el-disk1.img |
ubuntu-cloud-18.04.ppc64el | bionic-server-cloudimg-ppc64el.img |
ubuntu-cloud-20.04.ppc64el | focal-server-cloudimg-ppc64el.img |
ubuntu-cloud-22.04.ppc64el | jammy-server-cloudimg-ppc64el.img |
ubuntu-cloud-24.04.ppc64el | noble-server-cloudimg-ppc64el.img |
ubuntu-cloud-25.04.ppc64el | ubuntu-25.04-server-cloudimg-ppc64el.img |
ubuntu-cloud-25.10.ppc64el | questing-server-cloudimg-ppc64el.img |
ubuntu-cloud-26.04.ppc64el | resolute-server-cloudimg-ppc64el.img |
ubuntu-cloud-26.10.ppc64el | stonking-server-cloudimg-ppc64el.img |
All from cloud-images.ubuntu.com, checked against the release's SHA256SUMS, all booting platform. See Ubuntu cloud images and the support matrix.
Three spellings
| Spelling | Where you meet it |
|---|---|
ppc64 | the emulator qemu-system-ppc64, the snap component qemu-ppc64, QEMU_SMP_PPC64, QEMU_CPU_PPC64 |
ppc64el | system names: image-garden make ubuntu-cloud-24.04.ppc64el.run, image-garden allocate ubuntu-cloud-24.04.ppc64el, the base of a named instance, ARCH for a spread backend |
ppc64le | uname -m on a POWER host; image-garden treats that host as ppc64 |
for contributors
Inside: Arch, GARDEN_HOST_ARCH and instances
- The sections say
Arch=ppc64; rulegen.py checks that the section name and URL containppc64(rulegen.py:396-416) and gives themruleset_ppc64(rulegen.py:707-724). GARDEN_HOST_ARCHmapsppc64letoppc64and is the defaultGARDEN_ARCH(mk/000-garden.mk:14-18), soall::andfetchmatch the ppc64 systems on a POWER host andQEMU_SMP_PPC64is 4 there (mk/010-qemu.mk:5-6).define-instancetakes the QEMU architecture from the base'sArch(mk/020-instances.mk:53-65).
The .run command line
What ubuntu-cloud-24.04.ppc64el.run runs with every default, outside the snap, on an x86\_64 host:
qemu-system-ppc64 -cpu power9 -machine pseries,accel=tcg \ -m 2048 -smp 1 -nographic \ -drive file=ubuntu-cloud-24.04.ppc64el.qcow2,if=none,format=qcow2,id=drive0,media=disk,cache=writeback,discard=unmap \ -device virtio-blk,drive=drive0,bootindex=0 \ -device virtio-rng-pci \ -netdev user,id=netdev0 -device virtio-net-pci,netdev=netdev0,id=net0
-netdev user also takes QEMU_NETDEV_USER_EXTRA, which allocate sets to forward SSH (image-garden:1107), and the pkgproxy bridge when one is in use; see the .run script.
for contributors
In image-garden's CI
| Job | Systems | Timeout | Recorded time |
|---|---|---|---|
ppc64el: [ubuntu 1/2] | 14.04, 16.04, 18.04, 20.04, 22.04 | 80m | 25.9 minutes; up to 9.4 for one |
ppc64el: [ubuntu 2/2] | 24.04, 25.04, 25.10, 26.04, 26.10 | 85m | 28.5 minutes; up to 9.8 for one |
Both run on x86\_64 runners tagged qemu-emulated with ARCH: ppc64el, boot each image once with -smp 2 and -m 1024, 40 minutes per system, allow_failure: true (.gitlab-ci.yml:663-690, .gitlab-ci.yml:982-1002).
Porting notes (derived)
- Byte order is the same as on x86\_64: test big-endian code on s390x.
- Ubuntu's ppc64el kernels use 64 KiB pages: ask
sysconf(_SC_PAGESIZE), do not assume 4096. - Plain
charis unsigned on POWER.
Roads from here
SYSTEMS · distributions
- Ubuntu cloud images — the Ubuntu releases and their systems, ppc64el among them
ARCHITECTURES · machines and firmware
- Six architectures, six QEMU machines — the other machines, and why emulation is slow
- s390x — the big-endian architecture, for the byte-order tests ppc64 cannot do
RUNTIME · make rules and the CLI
- Named instances — named instances, which now work for ppc64el systems
- The .run script — more CPUs or memory for an emulated guest
SPREAD · tests
- spread names and garden names — how spread names map onto system names and architectures
SNAP · snap-only features
- Snap components — how the snap's per-architecture QEMU components install