Skip to content

Commit e67a71b

Browse files
yuravkyuravk
committed
feat(gencloud): build the ppc64le images under QEMU TCG on an x86_64 runner
There are no POWER runners, so the ppc64le GenericCloud images (gencloud and gencloud_ext4) can now be built on the x86_64 metal runner with QEMU full-system emulation (TCG), as a leg of gencloud-build-test.yml (job build-ppc64le-tcg; input ppc64le, on by default so the scheduled builds include it). The Packer sources are the same ones Jenkins runs on a POWER host: boot ISO, GRUB boot command, kickstart, SSH and the ansible provisioning. Their KVM-specific settings become variables whose defaults keep the Jenkins build unchanged, and shared-steps passes the TCG values for arch=ppc64le: ppc64le_accelerator none -> tcg ppc64le_machine_type pseries,accel=kvm,kvm-type=HV -> pseries ppc64le_cpu_model (QEMU default) -> POWER9 ppc64le_console_log (unset) -> file streamed into the job log ppc64le_extra_kernel_args (empty) -> console=hvc0 ppc64le_grub_hold false -> true gencloud_boot_wait_ppc64le 8s -> 3s, ssh_timeout 3600s -> 4h What the runs taught, and how the leg deals with it: - The emulator is not Ubuntu 24.04's QEMU 8.2.2: under TCG it mis-emulates POWER9 vector loads/stores and the EL9/EL10 installer's Python dies at "Starting installer" (segfaults, corrupted objects; QEMU issue 1769). Reproduced on a test host; the same guest under QEMU 10.1.5 works. shared-steps builds a small Fedora 43 image with qemu-system-ppc-core and installs /usr/local/bin/qemu-system-ppc64-tcg, a wrapper that runs it with docker --network host (Packer's VNC and SSH-forward ports stay on the host loopback) and the current directory and root's Packer ISO cache mounted at their own paths; Packer gets it as qemu_binary. qemu-img stays the host's. - SLOF makes the VGA display the primary console when one exists (Packer needs it for the VNC keyboard), so anaconda would draw on an uncaptured screen. ppc64le_extra_kernel_args types console=hvc0 into GRUB; the ppc64le kickstarts' %post removes it again from /etc/default/grub and the boot entries, since anaconda copies the installer's console= arguments into the installed configuration, so the image's kernel command line is the same as from a POWER host. - The ISO's GRUB menu auto-boots after 5 s, about 8 s after the VM starts, so typing at a fixed delay is a race. ppc64le_grub_hold starts the boot command after 3 s with 30 s of once-a-second spacebar presses GRUB's menu ignores: the first one that reaches the menu stops the countdown. It then moves from the ISO's default entry ("Test this media & install", whose rd.live.check hashes the 1.5 GB ISO for the better part of an hour under emulation) to the plain "Install" entry before the usual edit sequence; the 9/10/Kitten boot commands become locals so they can reference the prefix and the extra arguments. SLOF keeps auto-booting, so the installed system comes up on its own. shared-steps also installs qemu-utils, tails the guest console during the build and dumps it on failure (killing a container Packer's kill of the wrapper would leave behind), and mounts partition 3 (PReP boot, /boot, /) for the offline validation. There is no in-job boot test: gencloud-test-steps needs KVM. The AWS CLI is now downloaded for the runner's own architecture (uname -m) instead of the image's. Measured on the c7i/c7a metal runners: 9.8 in 35 min, 10.2 in 31 min, Kitten in 30 min, 8.10 in 46 min. The images were compared with the Jenkins-built ones with libguestfs: same packages (newer errata only), same layout and configuration.
1 parent 18f7c14 commit e67a71b

17 files changed

Lines changed: 389 additions & 71 deletions

‎.github/actions/shared-steps/action.yml‎

Lines changed: 76 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ inputs:
99
description: 'AlmaLinux variant to build (e.g., 9, 10, kitten)'
1010
required: true
1111
arch:
12-
description: 'Target architecture (x86_64, aarch64, or s390x - the latter built under QEMU TCG on an x86_64 runner)'
12+
description: 'Target architecture (x86_64, aarch64, ppc64le or s390x - the last two built under QEMU TCG on an x86_64 runner)'
1313
required: true
1414
S3_ACCESS_KEY_ID:
1515
description: 'AWS S3 access key ID for uploading images'
@@ -107,6 +107,27 @@ runs:
107107
;;
108108
esac
109109
110+
# ppc64le has no runner of its own: its sources are built under QEMU
111+
# TCG full-system emulation on this x86_64 runner, with the emulator
112+
# wrapper the Install KVM step creates (a newer QEMU than Ubuntu's,
113+
# see there). Switch the sources from KVM-HV to TCG with a POWER9 CPU
114+
# (the EL10 baseline), capture the guest console for the job log, and
115+
# give the emulated SLOF / GRUB / anaconda / ansible-over-SSH chain
116+
# far more time.
117+
if [ "${{ inputs.arch }}" = "ppc64le" ]; then
118+
packer_opts="${packer_opts/\/usr\/bin\/qemu-system-ppc64le//usr/local/bin/qemu-system-ppc64-tcg}"
119+
packer_opts="${packer_opts} -var ppc64le_accelerator=tcg -var ppc64le_machine_type=pseries -var ppc64le_cpu_model=POWER9"
120+
packer_opts="${packer_opts} -var gencloud_boot_wait_ppc64le=3s -var ssh_timeout=4h"
121+
packer_opts="${packer_opts} -var ppc64le_console_log=${{ github.workspace }}/ppc64le-console.log"
122+
# SLOF makes the VGA display the primary console when one exists, so
123+
# without this anaconda draws on the (uncaptured) VGA console
124+
packer_opts="${packer_opts} -var ppc64le_extra_kernel_args=console=hvc0"
125+
# The ISO's GRUB menu auto-boots 5 s after it appears (about 8 s
126+
# after the VM starts here), so start typing early and hold the
127+
# menu with harmless keypresses (see local.ppc64le_boot_prefix)
128+
packer_opts="${packer_opts} -var ppc64le_grub_hold=true"
129+
fi
130+
110131
# Image type e.g. Azure, Vagrant Libvirt, ...
111132
image_type=$(echo ${{ inputs.type }} | sed -E 's/_/ /g;s/\b(.)/\u\1/g')
112133
@@ -165,6 +186,37 @@ runs:
165186
# s390x is emulated (TCG) - needs the s390x system emulator and
166187
# qemu-img for the blank target disk
167188
[ "${{ inputs.arch }}" = "s390x" ] && sudo apt-get -y install qemu-system-s390x qemu-utils
189+
# ppc64le is emulated (TCG). Ubuntu 24.04's QEMU 8.2.2 miscompiles
190+
# POWER9 vector loads/stores under TCG and the EL9/EL10 installer's
191+
# Python crashes at startup (segfaults and corrupted objects; QEMU
192+
# issue 1769). Fedora's QEMU 10.x does not, so run the emulator from
193+
# a Fedora container through a wrapper that Packer uses as
194+
# qemu_binary: host networking puts the VNC and SSH-forward ports
195+
# where Packer expects them, and the workspace and Packer's ISO
196+
# cache are mounted at their own paths so the arguments Packer
197+
# passes are valid inside. qemu-img (disk creation) is the host's.
198+
if [ "${{ inputs.arch }}" = "ppc64le" ]; then
199+
sudo apt-get -y install qemu-utils
200+
# (heredoc bodies sit at the step's base indent so their
201+
# terminators reach column 0 once YAML strips the indentation)
202+
docker build -q -t qemu-ppc64-tcg - <<'DOCKERFILE'
203+
FROM registry.fedoraproject.org/fedora:43
204+
RUN dnf -y -q install qemu-system-ppc-core && dnf -q clean all
205+
DOCKERFILE
206+
sudo tee /usr/local/bin/qemu-system-ppc64-tcg >/dev/null <<'WRAPPER'
207+
#!/bin/bash
208+
# QEMU ppc64 system emulator from the qemu-ppc64-tcg container (see
209+
# shared-steps). Packer runs it under sudo from the workspace, so the
210+
# current directory (relative output paths) and root's Packer ISO
211+
# cache (absolute paths) are what has to be visible inside.
212+
exec docker run --rm -i --network host --init \
213+
-v "${PWD}:${PWD}" -w "${PWD}" \
214+
-v /root/.cache/packer:/root/.cache/packer \
215+
qemu-ppc64-tcg qemu-system-ppc64 "$@"
216+
WRAPPER
217+
sudo chmod 0755 /usr/local/bin/qemu-system-ppc64-tcg
218+
docker run --rm qemu-ppc64-tcg qemu-system-ppc64 --version
219+
fi
168220
sudo adduser "$(id -un)" kvm
169221
;;
170222
rhel)
@@ -324,6 +376,16 @@ runs:
324376
sudo tail -n +1 -F "${boot_dir}/console.log" | sed -u 's/^/[s390x console] /' &
325377
console_tail=$!
326378
fi
379+
if [ "${{ inputs.arch }}" = "ppc64le" ]; then
380+
# A TCG build shows nothing between "Waiting for SSH" and the end of
381+
# the install, which can take an hour or more. Stream the guest's
382+
# serial console (SLOF, GRUB, anaconda) into the job log so a
383+
# stuck install is visible live.
384+
console_log=${{ github.workspace }}/ppc64le-console.log
385+
sudo touch "${console_log}"
386+
sudo tail -n +1 -F "${console_log}" | sed -u 's/^/[ppc64le console] /' &
387+
console_tail=$!
388+
fi
327389
sudo sh -c "/usr/bin/packer build ${{ env.PACKER_OPTS }} -only=${{ env.packer_source }} ."
328390
[ -n "${console_tail:-}" ] && { sleep 2; kill "${console_tail}" 2>/dev/null || true; }
329391
true
@@ -336,6 +398,15 @@ runs:
336398
boot_dir=$(echo 'var.s390x_boot_dir' | sudo /usr/bin/packer console . 2>/dev/null || echo s390x-boot)
337399
sudo tail -n 200 "${boot_dir}/console.log" 2>/dev/null || echo "[Debug] no console log at ${boot_dir}/console.log"
338400
401+
- name: Show the ppc64le installer console
402+
if: failure() && inputs.arch == 'ppc64le'
403+
shell: bash
404+
run: |
405+
# Last part of the guest console (SLOF/GRUB/anaconda output) of the failed build
406+
sudo tail -n 200 ${{ github.workspace }}/ppc64le-console.log 2>/dev/null || echo "[Debug] no console log"
407+
# Packer kills the wrapper, not the container behind it
408+
docker ps -q --filter ancestor=qemu-ppc64-tcg | xargs -r docker kill
409+
339410
- name: Locate image file, generate checksum
340411
shell: bash
341412
run: |
@@ -363,6 +434,7 @@ runs:
363434
x86_64*) partition=4 ;;
364435
aarch64*) partition=3 ;;
365436
s390x) partition=2 ;;
437+
ppc64le) partition=3 ;; # PReP boot, /boot, /
366438
*) false ;;
367439
esac
368440
@@ -574,7 +646,9 @@ runs:
574646
run: |
575647
# Install aws CLI
576648
if ! aws --version 2>/dev/null; then
577-
curl "https://awscli.amazonaws.com/awscli-exe-linux-${{ inputs.arch }}.zip" -o "awscliv2.zip"
649+
# The CLI runs on the runner, whose arch can differ from the image
650+
# arch (ppc64le images are built on an x86_64 runner)
651+
curl "https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip" -o "awscliv2.zip"
578652
unzip -qq awscliv2.zip
579653
sudo ./aws/install
580654
else

‎.github/workflows/gencloud-build-test.yml‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,14 @@ run-name: >-
2121
# It gets shared-steps' offline validation (release string, RPM arch,
2222
# package list) but no in-job boot test: gencloud-test-steps needs KVM.
2323
#
24+
# ppc64le (input ppc64le, on by default so scheduled runs build it too):
25+
# there are no POWER runners, so the ppc64le images are built on an x86_64
26+
# runner under QEMU TCG full-system emulation - the same Packer sources
27+
# Jenkins runs on a POWER host, switched to TCG through variables (see the
28+
# ppc64le_* variables). A run takes 30 to 50 minutes per image. It gets
29+
# shared-steps' offline validation (release string, RPM arch, package list)
30+
# but no in-job boot test: gencloud-test-steps needs KVM.
31+
#
2432
# Stage implementations live in composite actions:
2533
# .github/actions/shared-steps - Packer build (all clouds)
2634
# .github/actions/gencloud-test-steps - QEMU/KVM boot test of the local qcow2
@@ -57,6 +65,12 @@ on:
5765
type: boolean
5866
default: true
5967

68+
ppc64le:
69+
description: "Build ppc64le images under QEMU TCG emulation on an x86_64 self-hosted runner"
70+
required: true
71+
type: boolean
72+
default: true
73+
6074
store_as_artifact:
6175
description: "Store images to the workflow Artifacts"
6276
required: true
@@ -317,3 +331,55 @@ jobs:
317331
notify_mattermost: ${{ inputs.notify_mattermost }}
318332
MATTERMOST_WEBHOOK_URL: ${{ secrets.MATTERMOST_WEBHOOK_URL }}
319333
MATTERMOST_CHANNEL: ${{ vars.MATTERMOST_CHANNEL }}
334+
335+
build-ppc64le-tcg:
336+
name: ${{ inputs.version_major }} ${{ matrix.subtype }}-ppc64le build (TCG)
337+
permissions:
338+
id-token: write
339+
contents: read
340+
if: ${{ inputs.ppc64le }}
341+
needs: [init-data]
342+
# Same x86_64 metal runner as build-gh-hosted; KVM is irrelevant here -
343+
# the ppc64le guest runs under TCG, which is CPU-bound, so wall time is
344+
# hours. No in-job boot test (the test composite needs KVM);
345+
# shared-steps' offline validation runs instead.
346+
runs-on: >-
347+
${{
348+
github.repository_owner == 'AlmaLinux' &&
349+
format('runs-on={0}/family=c7i.metal-24xl+c7a.metal-48xl+*8gd.metal*/image=ubuntu24-full-x64/spot=false', github.run_id)
350+
||
351+
'ubuntu-24.04'
352+
}}
353+
timeout-minutes: 720
354+
strategy:
355+
fail-fast: false
356+
matrix:
357+
subtype: [gencloud, gencloud_ext4]
358+
359+
env:
360+
TIME_STAMP: ${{ needs.init-data.outputs.time_stamp }}
361+
DATE_STAMP: ${{ needs.init-data.outputs.date_stamp }}
362+
363+
steps:
364+
- name: Checkout ${{ github.action_repository }}
365+
uses: actions/checkout@v6
366+
367+
- uses: ./.github/actions/shared-steps
368+
name: ${{ inputs.version_major }} ${{ matrix.subtype }}-ppc64le image
369+
with:
370+
type: ${{ matrix.subtype }}
371+
variant: ${{ inputs.version_major }}
372+
arch: ppc64le
373+
S3_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
374+
S3_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
375+
AWS_REGION: ${{ vars.AWS_REGION }}
376+
AWS_S3_BUCKET: ${{ vars.AWS_S3_BUCKET }}
377+
MATTERMOST_WEBHOOK_URL: ${{ secrets.MATTERMOST_WEBHOOK_URL }}
378+
MATTERMOST_CHANNEL: ${{ vars.MATTERMOST_CHANNEL }}
379+
store_as_artifact: ${{ inputs.store_as_artifact }}
380+
upload_to_s3: ${{ inputs.upload_to_s3 }}
381+
notify_mattermost: ${{ inputs.notify_mattermost }}
382+
run_test: 'true'
383+
runner: ${{ github.repository_owner == 'AlmaLinux' && 'aws-ec2' || 'gh_hosted' }}
384+
env:
385+
PACKER_GITHUB_API_TOKEN: ${{ secrets.GIT_HUB_TOKEN }}

‎GENCLOUD_BUILD_TEST.md‎

Lines changed: 56 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,7 @@ The input set is identical to [`gencloud-build.yml`](BUILD_IMAGES.md):
5252
| `version_major` | `10` | `10-kitten`, `10`, `9`, `8`. |
5353
| `self-hosted` | `true` | If `false`, skip the aarch64 matrix entirely. |
5454
| `s390x` | `true` | Build s390x images under QEMU TCG emulation on an x86_64 self-hosted runner (40 to 90 minutes per run; offline validation only). See [s390x under TCG](#s390x-under-tcg-experimental). |
55+
| `ppc64le` | `true` | Build ppc64le images (`gencloud` and `gencloud_ext4`) under QEMU TCG emulation on an x86_64 self-hosted runner (30 to 50 minutes per image; offline validation only). See [ppc64le under TCG](#ppc64le-under-tcg-experimental). |
5556
| `store_as_artifact` | `false` | Upload images as workflow artifacts. |
5657
| `upload_to_s3` | `true` | Upload to S3 in parallel. The test no longer depends on it; when true, the job summary / Mattermost message link the public S3 URL, otherwise they show the filename only. |
5758
| `notify_mattermost` | `true` | Post per-image build and test notifications to Mattermost. |
@@ -65,8 +66,10 @@ init-data
6566
|- build-gh-hosted (x86_64 matrix: subtype x variant) -. shared-steps build,
6667
|- start-self-hosted-runner (fork EC2) | then gencloud-test-steps
6768
|- build-self-hosted (aarch64 matrix: subtype) -' in-job on the local qcow2
68-
'- build-s390x-tcg (s390x, default on) - shared-steps build under
69+
|- build-s390x-tcg (s390x, default on) - shared-steps build under
6970
TCG, offline validation only
71+
'- build-ppc64le-tcg (default on; ppc64le matrix: subtype) shared-steps build under
72+
TCG + offline validation only
7073
```
7174

7275
There is no collect / publish stage: because the test runs in-job, each
@@ -77,6 +80,7 @@ build matrix leg reports its own build+test result directly. The matrix:
7780
| `build-gh-hosted` | x86_64 | `subtype` in {`gencloud`, `gencloud_ext4`} x `variant` ({`10`,`10-v2`} for AL10/Kitten, else just the major) |
7881
| `build-self-hosted` | aarch64 | `subtype` in {`gencloud`, `gencloud_ext4`} |
7982
| `build-s390x-tcg` | s390x | `gencloud` only (no ext4 kickstart for s390x); runs only with `s390x=true` |
83+
| `build-ppc64le-tcg` | ppc64le (emulated) | `subtype` in {`gencloud`, `gencloud_ext4`}; on by default, skipped with `ppc64le=false` |
8084

8185
### Stage composite actions
8286

@@ -99,6 +103,7 @@ The change is backward-compatible - `gencloud-test.yml` keeps passing
99103
| `build-gh-hosted` | `c7i.metal-24xl+c7a.metal-48xl+*8gd.metal*`, `image=ubuntu24-full-x64` | `ubuntu-24.04` (GitHub-hosted, has nested `/dev/kvm`) |
100104
| `build-self-hosted` | `a1.metal`, `image=ubuntu24-full-arm64`, `volume=40g` | self-hosted EC2 `a1.metal` (`EC2_AMI_ID_AL9_AARCH64`) |
101105
| `build-s390x-tcg` | same x86_64 metal family as `build-gh-hosted` (KVM unused - TCG) | `ubuntu-24.04` |
106+
| `build-ppc64le-tcg` | same as `build-gh-hosted` (x86_64 metal; KVM unused, TCG is CPU-bound) | `ubuntu-24.04` |
102107

103108
Both org runners are bare metal, so `/dev/kvm` is present for the in-job
104109
QEMU test. The composite installs `qemu-system-*` + `cloud-image-utils`
@@ -151,6 +156,56 @@ instruction set; the source uses `-cpu max` so TCG exposes everything it
151156
implements, but if the installer hits an unimplemented facility the
152157
console log will show it.
153158

159+
## ppc64le under TCG (experimental)
160+
161+
There are no POWER runners, so the `build-ppc64le-tcg` job (on by default,
162+
`ppc64le=false` skips it) builds the ppc64le images on an x86_64 runner with QEMU's Tiny Code Generator
163+
(TCG): the guest CPU is emulated in software, the virtio disk and network
164+
stay paravirtual. It uses the **same Packer sources** Jenkins runs on a
165+
POWER host (boot ISO, GRUB boot command, kickstart, SSH + ansible), switched
166+
to emulation through variables that shared-steps passes on the command line:
167+
168+
| Variable | Jenkins / POWER default | GitHub (TCG) value |
169+
| :--- | :--- | :--- |
170+
| `ppc64le_accelerator` | `none` (KVM-HV comes from the machine type) | `tcg` |
171+
| `ppc64le_machine_type` | `pseries,accel=kvm,kvm-type=HV` | `pseries` |
172+
| `ppc64le_cpu_model` | empty (QEMU default = host CPU) | `POWER9` (EL10 baseline; fully implemented by TCG) |
173+
| `ppc64le_console_log` | empty | `<workspace>/ppc64le-console.log`, streamed into the job log as `[ppc64le console]` lines |
174+
| `ppc64le_extra_kernel_args` | empty | `console=hvc0`, typed at the end of the GRUB boot command. SLOF makes the VGA display the primary console when a VGA adapter exists (Packer needs one for the VNC keyboard), so without it anaconda draws its text UI on the uncaptured VGA console and hvc0 only shows a shell banner |
175+
| `ppc64le_grub_hold` | `false` | `true`: the boot command starts with 30 s of once-a-second keypresses GRUB's menu ignores, then moves up from the ISO's default entry ("Test this media & install", whose `rd.live.check` hashes the 1.5 GB ISO for the better part of an hour under emulation) to the plain "Install" entry before the usual edit sequence. The ISO's GRUB menu auto-boots after only 5 s and appears about 8 s after the VM starts, so typing at one fixed delay is a race (the first runs lost it and installed without the kickstart); the presses stop the countdown as soon as the menu is up. SLOF keeps auto-booting, so the reboot after the install comes up on its own |
176+
| `gencloud_boot_wait_ppc64le` | `8s` | `3s` (start the keypress hold before GRUB can appear) |
177+
| `ssh_timeout` | `3600s` | `4h` (the whole emulated install runs before SSH is up) |
178+
179+
The emulator is **not** Ubuntu 24.04's QEMU 8.2.2: under TCG it miscompiles
180+
POWER9 vector loads/stores, and the EL9/EL10 installer's Python crashes at
181+
"Starting installer" with segfaults or corrupted objects (reproduced on a
182+
test host; [QEMU issue 1769](https://gitlab.com/qemu-project/qemu/-/issues/1769)).
183+
shared-steps builds a small Fedora 43 container image with QEMU 10.x and
184+
installs `/usr/local/bin/qemu-system-ppc64-tcg`, a wrapper that runs
185+
`qemu-system-ppc64` in that container with host networking (Packer's VNC and
186+
SSH-forward ports stay on the host loopback) and the workspace and Packer's
187+
ISO cache mounted at their own paths; Packer gets it as `qemu_binary`. Disk
188+
images are still created by the host's `qemu-img`.
189+
190+
What the job does and does not do:
191+
192+
- Offline validation runs as for every arch (release string, `almalinux-release`
193+
arch, package list from the RPM database; root is partition 3: PReP boot,
194+
`/boot`, `/`).
195+
- **No in-job boot test**: `gencloud-test-steps` needs KVM.
196+
- Expect one to a few hours per image. Everything the guest does (SLOF,
197+
GRUB, anaconda, the ansible provisioning over SSH, the zero-fill of the
198+
disk) is CPU-emulated; the job timeout is 12 hours.
199+
200+
Tuning notes: SLOF and GRUB draw on the VGA console, so the captured
201+
console shows neither; the kernel's `Command line:` line is the first proof
202+
that the typed arguments (`inst.ks=...`, `console=hvc0`) arrived. If it
203+
lacks them, GRUB booted its default entry: check in the console when SLOF
204+
handed over to GRUB (`Trying to load`) against the 30 s keypress window
205+
that starts after `gencloud_boot_wait_ppc64le`. If the guest dies with an illegal instruction, the CPU
206+
model is too old for the kernel; POWER9 is the minimum for AlmaLinux 10 and
207+
Kitten.
208+
154209
## Required GitHub Configuration
155210

156211
### Secrets

‎SCHEDULED_BUILDS.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,9 @@ week.
6161
(not `10-kitten`) - the dispatcher translates.
6262
- `gencloud-build-test.yml`'s s390x leg (QEMU TCG on an x86_64 runner,
6363
40 to 90 minutes) is on by default, so scheduled runs build it too.
64+
- `gencloud-build-test.yml`'s ppc64le leg (QEMU TCG on an x86_64 runner,
65+
30 to 50 minutes per image) is on by default, so scheduled runs build it
66+
too.
6467
- `oci-build-release-test-publish.yml` has **no Kitten option** - on
6568
Kitten weeks the OCI dispatch is skipped (noted in the job summary).
6669
- `vagrant-build-test-publish.yml` is **temporarily paused on Kitten

‎almalinux-8-gencloud-ext4.pkr.hcl‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ source "qemu" "almalinux-8-gencloud-ext4-ppc64le" {
7676
ssh_timeout = var.ssh_timeout
7777
boot_command = local.gencloud_ext4_boot_command_8_ppc64le
7878
boot_wait = var.gencloud_boot_wait_ppc64le
79-
accelerator = "none"
79+
accelerator = var.ppc64le_accelerator
8080
disk_interface = "virtio-scsi"
8181
disk_size = var.gencloud_disk_size
8282
disk_cache = "unsafe"
@@ -85,7 +85,9 @@ source "qemu" "almalinux-8-gencloud-ext4-ppc64le" {
8585
disk_compression = true
8686
format = "qcow2"
8787
headless = var.headless
88-
machine_type = "pseries,accel=kvm,kvm-type=HV"
88+
machine_type = var.ppc64le_machine_type
89+
cpu_model = var.ppc64le_cpu_model
90+
qemuargs = var.ppc64le_console_log != "" ? [["-serial", "file:${var.ppc64le_console_log}"]] : []
8991
memory = var.memory_ppc64le
9092
net_device = "virtio-net"
9193
qemu_binary = var.qemu_binary

0 commit comments

Comments
 (0)