vagrant-qemu 0.6.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 275a26aad79e641534b4c9ea0bb7a9824f964b61c66dbbe9e3bf0d7075f23081
-  data.tar.gz: f4afe41ed386785952534fff85e7030030fab8b4defdd7438ce37cee649b1a50
+  metadata.gz: 29dd41685f09eaee73da2f6a10070679da9eb5220150efa47e4c016159264e0f
+  data.tar.gz: 65a2a89ee494f735f5de4b347517ad744a2c26b9dfdae55832a7572c216183c9
 SHA512:
-  metadata.gz: b05b9827dc708cf7dab8a417caae11eeed6fda22380e6d80d8eb3fd8a08c974b70f26b32ee0a10ceb06699a69ed59f1dcbfb42b856bed00ddb5bdeefa04acd37
-  data.tar.gz: dd55d31e14d55305e1c7714d74eb5d273fed56ba3b4ea927fb37ff305d337dbfd752f913f3b509562c395d8734950079d155e59950138c601041d29b0f10f744
+  metadata.gz: cb872c571092692bdcf7d5946ce85eeea75dede69ee619a56c34dd062ace730b36b0aba3c414e0b6c75ff2e2e530dd50ad77c574b5fe0294fae4deab63147d9d
+  data.tar.gz: deecca7a10a369f259df3c517db2b9d96a0b39b27a1050997897bb592944bcb678937fa8e4daadf28882543f4813626a95dd304bef94550bfd52ce54d25a131b

data/CHANGELOG.md

@@ -223,3 +223,110 @@
 * README: bring a `socket_opts` `listen=`/`connect=` pair up with
   `vagrant up --no-parallel`. A plain `vagrant up` boots both machines in
   parallel, and if the connector starts first the link never comes up.
+
+# 0.7.0 (2026-10-15)
+
+Thanks to @christhomas, who contributed most of this release
+(#81, #85, #87–#95).
+
+New:
+
+* VirtioFS synced folders: `config.vm.synced_folder ..., type: "qemu_virtiofs"`.
+  The provider starts one `virtiofsd` per share, backs guest RAM with a shared
+  memory file and mounts the shares after boot; the daemons are stopped on
+  halt, destroy, package and failed boots. New config: `virtiofsd_bin`,
+  `virtiofs_guest_uid` / `virtiofs_guest_gid` (default 1000) and
+  `extra_virtiofsd_args`; `qe.memory` must be a positive size. Linux hosts and
+  WSL2 use the distribution's `virtiofsd`. macOS support is experimental and
+  needs a QEMU built with vhost-user and a macOS `virtiofsd` port, available
+  from a community Homebrew tap (see the README). (#81)
+* `vagrant serial-config [name|id] [--json]` prints the Unix socket path or TCP
+  host and port of each QEMU machine's serial console. (#37, #92)
+* README: how to package a QEMU machine into a reusable box, plus a tested
+  round-trip recipe in `examples/package-roundtrip`. (#94)
+
+Behavior changes:
+
+* If the guest does not become reachable within `config.vm.boot_timeout`
+  (default 300 s), or Vagrant reports an invalid boot state, the provider now
+  stops the QEMU instance it just started and keeps its disks. Previously QEMU
+  was left running. Emulated guests (a guest architecture different from the
+  host, or no HVF/KVM) and several VMs booting in parallel can need more than
+  300 s; set `config.vm.boot_timeout = 600` or more. A guest that used to
+  finish booting in the background after the timeout now has to be brought up
+  again with `vagrant up`, from the start. Interrupting the boot wait with
+  Ctrl-C still leaves QEMU running. (#89, refs #21)
+* `config.vm.disk :disk, primary: true, size: ...` now grows the existing boot
+  disk instead of attaching a new blank disk; it never shrinks it, and reports
+  sizes such as `100 GiB`. The blank disk an older version created for the
+  declaration (`vagrant_primary.qcow2`, or `<name>.qcow2` for a custom name)
+  is no longer attached; the provider warns while that file exists, and
+  the README's "Upgrading older primary disk declarations" section shows how to
+  attach it again. (#66, #88, #93, #95)
+* With `net_device = nil`, an inherited SSH forward is disabled and the
+  configured `ssh_port` is kept instead of a collision-corrected one. (#71, #87)
+
+Fixes:
+
+* macOS: firmware for an aarch64 guest is now looked up in the host's Homebrew
+  prefix rather than one chosen by the guest architecture, fixing Intel Macs.
+  If Vagrant's Ruby runs under Rosetta on Apple Silicon, set `HOMEBREW_PREFIX`
+  or `qe.qemu_dir`. (#50, #59, #90)
+* Waiting for a monitor reply during `vagrant halt` is now bounded, so halt can
+  always escalate to quit and kill. With `control_port` set, halt connects to
+  127.0.0.1: on macOS 27 connecting to localhost could pick ::1 and appear
+  connected, so powerdown and quit were never delivered and QEMU was killed
+  only after both timeouts. (#89)
+* `vagrant halt` could fail with `Errno::ENOENT` when QEMU removed its pidfile
+  just as the provider read it. An empty pidfile no longer reads as a running
+  VM, and a force kill waits for QEMU to exit.
+* Updating the SSH forward no longer leaks into other machines that share a
+  forwarded_port rule from the top-level or box Vagrantfile.
+* README: AlmaLinux 9 x86_64 guests need `qe.cpu = "max"` under emulation
+  (#67, #91); the `other_default` default is `-parallel none`.
+
+Project:
+
+* Cross-platform CI on GitHub Actions: unit specs on Linux, macOS and Windows;
+  guest smoke tests on Linux, macOS and WSL2; e2e on Linux (KVM), macOS (TCG:
+  vmnet, socket_vmnet, VirtioFS) and VirtioFS in WSL2. (#85)
+* The gem now ships only `lib/`, `locales/`, `LICENSE`, `README.md` and
+  `CHANGELOG.md`.
+
+# 0.8.0 (2026-11-09)
+
+Behavior changes:
+
+* The QEMU pidfile and the runtime record `options.yml` moved from
+  `~/.vagrant.d/tmp/vagrant-qemu/<id>/` into the project, under
+  `.vagrant/machines/<name>/qemu/<id>/run/`. A removed tmp directory, or a
+  later command run under another `VAGRANT_HOME`, no longer makes a running VM
+  look stopped, which had left `vagrant halt` doing nothing and
+  `vagrant destroy` leaving QEMU running. The monitor and serial sockets stay
+  in the tmp directory, since macOS limits unix socket paths to 104 bytes;
+  their paths are recorded at launch, so halt and `vagrant serial-config`
+  still reach them. (#96)
+* A VM started by 0.3.7 to 0.7.0 keeps its old layout while it runs: it is
+  still found, halted and destroyed as before, and moves to the new layout the
+  next time it starts. Only then is it protected as above. Reading the old
+  layout will be kept for at least one minor release.
+* Halt your VMs before downgrading the plugin: older releases look only in the
+  tmp directory and report a VM started by 0.8.0 as stopped.
+
+Fixes:
+
+* A pidfile now counts only if the command line of its process contains that
+  pidfile, so a pidfile left behind by a crash or SIGKILL whose PID was reused
+  no longer reads as a running VM, and halt never signals that process.
+* A VM whose QEMU runs as another user (for example started with
+  `sudo vagrant up`) no longer fails with a bare `Errno::EPERM` or
+  `Errno::EACCES`: the provider says to run the command as that user.
+* When the QEMU monitor cannot be reached, halt sends SIGTERM right away, so
+  QEMU closes its disk images (the guest gets no shutdown request), and
+  SIGKILLs it if it is still running 10 seconds later. It no longer waits out
+  `graceful_timeout` twice and then SIGKILLs.
+* A pidfile and sockets left after a SIGKILL are removed once QEMU is gone.
+* If QEMU is still running 10 seconds after SIGKILL, halt and destroy now fail
+  with an error naming the PID. Before, halt reported success, destroy deleted
+  the VM's files and reload left the old QEMU running. A QEMU that has exited
+  and only waits to be reaped counts as gone.

data/README.md

@@ -35,10 +35,12 @@ Others:
 * SSH into VM
 * Provision the instances with any built-in Vagrant provisioner
 * Synced folder support via SMB
-* Basic operation: up, ssh, halt, destroy
+* Synced folder support via VirtioFS for Linux guests
+* Basic operation: up, ssh, halt, destroy, package
 * Basic suport to forwarded ports, see [vagrant doc](https://www.vagrantup.com/docs/networking/forwarded_ports) for details
 * Support Cloud-init, see [vagrant doc](https://developer.hashicorp.com/vagrant/docs/cloud-init/usage) for details
 * Support Disks, see [vagrant doc](https://developer.hashicorp.com/vagrant/docs/disks/usage) for details
+  * `config.vm.disk :disk, primary: true, size: "100GB"` grows the existing boot disk. The provider reports growth before resizing and warns when a smaller requested size is skipped; it never shrinks the disk. This resizes the virtual disk only: grow the guest's partition/filesystem separately, or use a box whose cloud-init handles that. The declaration is reapplied on start/reload, unlike `qe.disk_resize`, which applies during import. See the [upgrade note for older primary disk declarations](#upgrading-older-primary-disk-declarations).
 * Advanced networking (opt-in): dual-NIC with `private_network` support via QEMU native vmnet (macOS), TAP (Linux), or a `socket` netdev — multicast (Linux/Windows) or point-to-point listen/connect (no root, works on macOS)
 
 ## Usage
@@ -66,6 +68,53 @@ Notes:
   see [vagrant doc](https://www.vagrantup.com/docs/synced-folders/smb) for details
 * need username/password to access shared folder
 
+### VirtioFS synced folders
+
+Install `virtiofsd` on the host and use a Linux guest with VirtioFS support.
+The plugin searches `PATH`, `/usr/libexec`, and `/usr/lib/qemu` for the daemon;
+set `qe.virtiofsd_bin` when it is installed elsewhere.
+
+Apple Silicon macOS support is experimental. The community tap maintained by
+christhomas supplies his macOS virtiofsd port and upstream QEMU built with
+`--enable-vhost-user`. This QEMU formula conflicts with stock Homebrew `qemu`;
+unlink or uninstall the stock formula before installing the tap build:
+
+```sh
+brew unlink qemu # if the stock formula is installed
+brew install antimatter-studios/tap/qemu antimatter-studios/tap/virtiofsd
+```
+
+CI also points the provider at the tap build's firmware directory. If
+`vagrant up` cannot find the aarch64 firmware, do the same:
+
+```sh
+export QEMU_DIR="$(brew --prefix antimatter-studios/tap/qemu)/share/qemu"
+```
+
+CI pins the tap to `f51cb0fcd636247ea977898e7d01a893ee05cf86` and tests this
+combination with TCG; it does not establish macOS HVF support. Linux and Windows WSL2 use the Ubuntu
+`virtiofsd` package. In WSL2 both QEMU and the daemon run inside Linux, so
+shares can live on the native Linux filesystem; Windows DrvFs paths are
+not required. Use `type: "qemu_virtiofs"` explicitly, or restrict
+`config.vm.allowed_synced_folder_types` to `[:qemu_virtiofs]`; its priority is
+below rsync and NFS so installing the daemon does not override those types.
+
+```ruby
+config.vm.synced_folder "./src", "/home/vagrant/src", type: "qemu_virtiofs"
+config.vm.provider "qemu" do |qe|
+  qe.virtiofsd_bin = "/path/to/virtiofsd" # optional
+end
+```
+
+`virtiofs_guest_uid` and `virtiofs_guest_gid` default to `1000`. UID/GID
+translation is used when the installed daemon supports it. Additional daemon
+arguments can be passed through `extra_virtiofsd_args` as an array.
+VirtioFS requires a positive `qe.memory`: bare numbers mean MiB, and
+`K`, `M`, `G`, and `T` suffixes are accepted. The size is rounded up to a whole
+MiB for both guest RAM and its shared backend (`"1.3G"` becomes `1332M`). `nil` is rejected for VirtioFS
+because the shared memory backend needs an explicit size. QEMU creates an
+unlinked RAM backing file in the host temporary directory.
+
 ## Box format
 
 Same as [vagrant-libvirt version-1](https://github.com/vagrant-libvirt/vagrant-libvirt#version-1):
@@ -74,6 +123,40 @@ Same as [vagrant-libvirt version-1](https://github.com/vagrant-libvirt/vagrant-l
 * `metadata.json` file describing box image (provider, virtual_size, format)
 * `Vagrantfile` that does default settings
 
+### Package a QEMU machine into a reusable box
+
+From a source project's directory, start the QEMU VM and package it:
+
+```sh
+vagrant up --provider=qemu
+vagrant package --output ../portable.box
+```
+
+To package a named machine, pass its name before `--output`, for example
+`vagrant package web --output ../portable.box`.
+
+In a fresh consumer project, add the archive and select that box in its
+`Vagrantfile`:
+
+```sh
+vagrant box add portable-qemu ../portable.box
+```
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "portable-qemu"
+end
+```
+
+Then boot it with `vagrant up --provider=qemu`. The archive uses the `libvirt`
+box format, which this plugin can import; let `vagrant box add` read its provider
+metadata. Packaging stops the source VM and includes its box disks and
+architecture. Extra disks, DVDs and cloud-init seed ISOs are excluded. Set up
+networking and synced folders in the consumer project.
+
+For a tested source-to-consumer round trip, see the
+[packaging recipe](examples/package-roundtrip/README.md).
+
 ## Configuration
 
 ### Options
@@ -87,10 +170,10 @@ This provider exposes a few provider-specific configuration options:
   * `cpu` - The cpu model of VM, default: `host` for native virtualization, `max` when emulating a non-host arch
   * `smp` - The smp setting (Simulate an SMP system with n CPUs) of VM, default: `2`
   * `memory` - The memory setting of VM, default: `4G`
-  * `disk_resize` - The target disk size of the primary disk, requires resizing of filesystem inside of VM, default: `nil`.
+  * `disk_resize` - The target disk size of the primary disk, requires resizing of filesystem inside of VM, default: `nil`. Applied only when the VM is imported. With a `primary: true` disk declaration as well, the disk ends up at the larger of the two sizes, and if `disk_resize` is the larger one every start warns that the smaller declaration cannot shrink the disk; set only one of them.
 * debug/expert
   * `ssh_host` - The SSH IP used to access VM, default: `127.0.0.1`
-  * `ssh_auto_correct` - Auto correct port collisions for ssh port, default: `false`
+  * `ssh_auto_correct` - Auto correct port collisions for the provider's SSH forward, default: `false`. When `net_device = nil`, no synthetic SSH forward is added and the direct SSH port is preserved; configure `ssh_host` and `ssh_port` for your custom network.
   * `net_device` - The network device, default: auto-detected — `virtio-net-device` (arm64 `virt`) or `virtio-net-pci` (x86_64 `q35`)
   * `drive_interface` - The interface type for the main drive, default `virtio`
   * `image_path` - The path (or array of paths) to qcow2 image for box-less VM, default is nil value
@@ -103,9 +186,9 @@ This provider exposes a few provider-specific configuration options:
   * `debug_port` - The port number used to export serial port of the vm for debug, default is nil value. (nil means use unix socket, see "Debug" below for details)
   * `no_daemonize` - Disable the "daemonize" mode of QEMU, default is false. (see "Windows host" below as example)
   * `firmware_format` - The format of aarch64 firmware images (`edk2-aarch64-code.fd` and `edk2-arm-vars.fd`) loaded from `qemu_dir`, default: `raw`
-  * `other_default` - The other default arguments used by this plugin, default: `%W(-parallel null -monitor none -display none -vga none)`
+  * `other_default` - The other default arguments used by this plugin, default: `%W(-parallel none -monitor none -display none -vga none)`
   * `extra_image_opts` - Options passed via `-o` to `qemu-img` when the base qcow2 images are created, default: `[]`
-  * `graceful_timeout` - Seconds to wait at each `vagrant halt` stage before escalating, default: `60`. Halt sends ACPI `system_powerdown`, waits up to this long, then sends QEMU's `quit` monitor command (a clean shutdown that flushes and closes the disk images), waits again, and finally SIGKILLs QEMU as a last resort — so halt still completes even when the guest was already halted from inside (e.g. `sudo systemctl halt`), where `system_powerdown` is a no-op
+  * `graceful_timeout` - Seconds to wait at each `vagrant halt` stage before escalating, default: `60`. Halt sends ACPI `system_powerdown`, waits up to this long, then sends QEMU's `quit` monitor command (a clean shutdown that flushes and closes the disk images), waits again, and finally SIGKILLs QEMU as a last resort — so halt still completes even when the guest was already halted from inside (e.g. `sudo systemctl halt`), where `system_powerdown` is a no-op. If the monitor cannot be reached (for example its socket was deleted), halt stops waiting on it: it sends SIGTERM, which makes QEMU close its disk images like `quit` but gives the guest no shutdown request, and SIGKILLs QEMU if it is still running 10 seconds later. If QEMU is still running 10 seconds after SIGKILL, halt and destroy fail with an error instead of reporting success or deleting the VM's files
 * advanced networking (requires `advanced_network = true`)
   * `advanced_network` - Enable dual-NIC advanced networking with `private_network` support, default: `false`
   * `net_mode` - Network backend: `:auto` (detect by platform), `:vmnet_shared`, `:vmnet_host`, `:vmnet_bridged` (macOS, sudo), `:socket_vmnet` (macOS, no sudo — via the socket_vmnet daemon), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`
@@ -143,7 +226,7 @@ to `nil` value to skip related qemu arguments.
 * `net_device`: skip all network related arguments:
   * `-device xxx,netdev=net0`
   * `-netdev user,id=net0,xxx`
-  * NOTES: there will be no network, ssh won't work
+  * NOTES: the provider adds no network; SSH works only if you set up your own network and point `ssh_host` and `ssh_port` at it
 * `drive_interface`: skip drive for the main image, `-drive if=xxx,xxx`
 * `firmware_format`: skip firmware setup for aarch64, `-drive if=pflash,xxx`
 
@@ -436,6 +519,20 @@ Platform support:
 
 Serial port is exported to unix socket: `<user_home>/.vagrant.d/tmp/vagrant-qemu/<id>/qemu_socket_serial`, or `debug_port`.
 
+Run `vagrant serial-config` to list serial endpoints for all machines, or
+`vagrant serial-config NAME` for one machine. The command does not start machines;
+uncreated machines are listed as `NotCreated`. Created machines show `UnixSocket`
+or `Host`/`Port`. Stopped machines report their last-start endpoint when it was recorded, even if
+the configuration has since changed; that endpoint may not be listening.
+Machines using another provider are skipped.
+
+Use `vagrant serial-config --json` for an array of machine names and endpoint
+objects. Each record has `machine` (the Vagrant machine name) and `endpoint`.
+A Unix endpoint has `type: "unix"` and `path`; a TCP endpoint has `type: "tcp"`,
+`host` and `port`. An uncreated machine has a `null` endpoint. For newly started instances,
+the command uses the endpoint recorded at launch, even if `debug_port` changes
+in the Vagrantfile; older instances fall back to their current configuration.
+
 To debug and login to the GuestOS from serial port:
 
 * unix socket
@@ -510,31 +607,68 @@ vagrant plugin list | grep vagrant-qemu
 
 > This command will list all installed plugins, and you should see the vagrant-qemu plugin with the locally built version.
 
-### Running Tests
+### Testing
+
+Tests are RSpec, in three layers. GitHub Actions runs all of them on every pull request (`.github/workflows/ci.yml`); a new push to a pull request cancels its older run, and changes that only touch `*.md` files are not tested.
+
+| Layer | What | Where CI runs it |
+|---|---|---|
+| Unit (`spec/unit`) | Plugin code, no QEMU | Ubuntu, macOS, Windows |
+| Acceptance (`spec/acceptance`) | Vagrant actions against a mock `qemu` (bash scripts) | Ubuntu, macOS |
+| Guest smoke (`examples/ci-smoke`) | Boots a Debian guest: up, ssh, status, halt, destroy | Ubuntu, macOS, Windows WSL2 |
+| e2e (`spec/e2e`) | Real VMs: disks, forwarded ports, provision, reload, package, networking | Ubuntu with KVM; vmnet and socket_vmnet specs on macOS |
+| VirtioFS e2e (`spec/e2e/virtiofs_spec.rb`) | Two resolved shares, host/guest writes, reload, halt/up, daemon and socket cleanup on destroy | Ubuntu, Apple Silicon macOS, Windows WSL2 |
+
+CI uses the latest Vagrant release and prints the Ruby and Vagrant versions in each job. Hosted macOS runners have no HVF, so CI runs macOS guests with TCG; the HVF path is only tested locally.
+
+Run them locally:
 
 ```sh
-# Unit tests (fast, no QEMU needed)
+# Unit and acceptance (fast, no real VM)
 bundle exec rake spec:unit
-
-# Acceptance tests (mock QEMU, no real VM)
 bundle exec rake spec:acceptance
 
-# End-to-end tests (requires QEMU and a box image). e2e exercises the
-# INSTALLED plugin — rebuild and reinstall first (the suite fails fast on
-# a version mismatch):
+# e2e exercises the INSTALLED plugin: rebuild and reinstall first (the
+# suite fails fast on a version mismatch)
 bundle exec rake build
 vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
 TEST_QEMU=1 bundle exec rake spec:e2e
 
-# End-to-end with vmnet (requires sudo + macOS; needs an aarch64 cloud-init box)
-TEST_QEMU=1 TEST_VMNET=1 TEST_BOX_CLOUDINIT=perk/ubuntu-2204-arm64 sudo -E bundle exec rake spec:e2e
+# vmnet (macOS, needs sudo) and socket_vmnet (macOS, needs the daemon:
+# brew install socket_vmnet && sudo brew services start socket_vmnet)
+TEST_VMNET=1 sudo -E bundle exec rspec spec/e2e/advanced_network_spec.rb
+TEST_SOCKET_VMNET=1 bundle exec rspec spec/e2e/socket_vmnet_spec.rb
 
-# All tests
-bundle exec rake spec
+# VirtioFS: install the host daemon (and compatible QEMU on macOS) first.
+# Uses Linux provider defaults (KVM), macOS TCG, and a box matching the host.
+TEST_VIRTIOFS=1 TEST_BOX=cloud-image/debian-12 bundle exec rspec spec/e2e/virtiofs_spec.rb
 ```
 
+The e2e boxes default to Apple Silicon (aarch64) boxes; on another host set `TEST_BOX` and `TEST_BOX_CLOUDINIT` to boxes of the host architecture (CI uses `cloud-image/ubuntu-22.04` for both).
+
+Adding tests:
+
+* A new e2e example in `spec/e2e` tagged `:requires_qemu` runs in CI's Ubuntu e2e job without workflow changes.
+* A feature that needs extra host setup (a daemon, a tool such as `virtiofsd`, root) gets its own tag, an environment switch in `spec/spec_helper.rb` next to `TEST_VMNET`, and a workflow step that installs the dependency and sets the switch.
+
 ## Known issue / Troubleshooting
 
+If boot times out or Vagrant reports an invalid boot state, the provider stops
+the QEMU instance it just launched and keeps its disks. It requests QEMU quit
+directly and allows 3–10 seconds to flush disk writes, based on `qe.graceful_timeout`,
+before falling back to forced termination. Increase `config.vm.boot_timeout` if
+the guest needs more time to become reachable. When QEMU runs on TCG (a guest
+architecture different from the host, or no HVF/KVM available) or several VMs
+boot in parallel, set it to 600 seconds or more, as this project's CI does for
+its TCG runs:
+
+```ruby
+config.vm.boot_timeout = 600
+```
+
+Interrupting the boot wait with Ctrl-C retains the existing behavior and can
+leave QEMU running.
+
 ### 1. failed to create shared folder
 
 ```
@@ -619,9 +753,60 @@ official build from [vagrantup.com](https://www.vagrantup.com/downloads) if
 needed). Do **not** work around it by pinning `logger` in a Gemfile — that tends
 to deepen the conflict.
 
+### 6. AlmaLinux 9 x86_64 guest times out waiting for SSH on Apple Silicon
+
+Check the guest CPU model if the Vagrantfile explicitly sets `qe.cpu = "qemu64"`.
+With the `almalinux/9` box version `9.2.20230513`, that model caused a boot timeout
+in an Apple Silicon test; changing it to `max` allowed the guest to boot and SSH
+successfully. For cross-architecture emulation, use:
+
+```ruby
+config.vm.provider "qemu" do |qe|
+  qe.arch = "x86_64"
+  qe.cpu = "max"
+end
+```
+
+The provider already selects `max` by default when the guest architecture differs
+from the host, so removing an explicit `qemu64` override also restores that default.
+CPU models determine which instruction-set features the guest can use; QEMU's
+[CPU ABI table](https://www.qemu.org/docs/master/system/qemu-cpu-models.html#abi-compatibility-levels-for-cpu-models)
+places `qemu64` below the x86-64-v2 baseline required by
+[RHEL 9](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/considerations_in_adopting_rhel_9/ref_architectures_considerations-in-adopting-rhel-9).
+
+This workaround is for an x86_64 guest running under TCG emulation. A shell
+provisioner that installs OpenSSH cannot fix a failure before the first SSH
+connection, because provisioning starts after the communicator becomes ready.
+
+### Upgrading older primary disk declarations
+
+Before the fix in [PR #88](https://github.com/ppggff/vagrant-qemu/pull/88),
+`primary: true` created a separate blank disk, usually `vagrant_primary.qcow2`,
+instead of growing the boot disk. After upgrading, that extra disk is no longer
+automatically attached. Its file is retained with the VM.
+
+If you stored data on that extra disk, halt the VM and back up the existing file
+under `.vagrant/machines/<name>/qemu/<id>/vagrant_primary.qcow2`. Replace the old
+primary declaration with a non-primary declaration using the same name:
+
+```ruby
+config.vm.disk :disk, name: "vagrant_primary", primary: false, size: "100GB"
+```
+
+Use the size from your original declaration. The provider reuses the existing
+file without recreating it; if it is missing, a new blank disk would be created.
+If you gave the old disk a custom name, use that name instead. Run `vagrant up
+--provider=qemu` and mount its existing filesystem in the guest as before.
+
+If you also want to grow the actual boot disk, add a separate declaration with
+a distinct name, for example:
+
+```ruby
+config.vm.disk :disk, name: "boot", primary: true, size: "100GB"
+```
+
 ## TODO
 
 * Support NFS shared folder
-* Support package VM to box
 * More configures
 * GUI mode

data/lib/vagrant-qemu/action/cleanup_virtiofs.rb

@@ -0,0 +1,18 @@
+require_relative "../synced_folder_virtiofs"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      class CleanupVirtioFS
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          SyncedFolderVirtioFS.new.cleanup(env[:machine], {})
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/action/mount_virtiofs.rb

@@ -0,0 +1,35 @@
+require "log4r"
+require "json"
+require "shellwords"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      class MountVirtioFS
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::mount_virtiofs")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          # prepare sees Vagrant's resolved folder types. Use precisely that
+          # mapping, including shares selected through allowed_synced_folder_types.
+          mounts_file = machine.data_dir.join("virtiofs", "mounts.json")
+          if !machine.provider_config.virtiofs_qemu_args.empty? && mounts_file.file?
+            JSON.parse(File.read(mounts_file)).each do |tag, guestpath|
+
+              escaped_guestpath = Shellwords.escape(guestpath)
+              machine.communicate.sudo("mkdir -p #{escaped_guestpath}")
+              machine.communicate.sudo("mount -t virtiofs #{Shellwords.escape(tag)} #{escaped_guestpath}")
+              machine.ui.info("Mounted virtiofs #{tag} at #{guestpath}")
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/action/prepare_forwarded_port_collision_params.rb

@@ -26,20 +26,26 @@ module VagrantPlugins
         end
       end
 
-      has_ssh_forward = false
-      machine.config.vm.networks.each do |type, options|
-        next if type != :forwarded_port
+      # Update the SSH rule through network(), never in place: a rule from the
+      # top-level or box Vagrantfile is one hash shared by every machine.
+      has_ssh_forward = machine.config.vm.networks.any? do |type, options|
+        type == :forwarded_port && options[:id] == "ssh"
+      end
 
-        # update ssh.host to ssh_port
-        if options[:id] == "ssh"
-          options[:host] = machine.provider_config.ssh_port
-          options[:auto_correct] = machine.provider_config.ssh_auto_correct
-          has_ssh_forward = true
-          break
-        end
+      # There is no provider-managed SSH forward when the user disables our
+      # NIC (e.g. a custom bridged NIC with direct SSH). Vagrant/box configs
+      # may still contain an inherited SSH rule: exclude it from collisions.
+      if machine.provider_config.net_device.nil?
+        machine.config.vm.network(:forwarded_port, id: "ssh", disabled: true) if has_ssh_forward
+        @app.call(env)
+        return
       end
 
-      if !has_ssh_forward
+      if has_ssh_forward
+        machine.config.vm.network(:forwarded_port, id: "ssh",
+          host: machine.provider_config.ssh_port,
+          auto_correct: machine.provider_config.ssh_auto_correct)
+      else
         machine.config.vm.network :forwarded_port,
           :guest => 22, 
           :host => machine.provider_config.ssh_port, 

data/lib/vagrant-qemu/action/reset_virtiofs_args.rb

@@ -0,0 +1,40 @@
+require_relative "../synced_folder_virtiofs"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      class ResetVirtioFSArgs
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          machine.provider_config.virtiofs_qemu_args = []
+          SyncedFolderVirtioFS.new.cleanup(machine, {})
+          @starting = true
+          result = @app.call(env)
+          @starting = false
+          result
+        end
+
+        def recover(env)
+          machine = env[:machine]
+          return unless @starting && !machine.provider_config.virtiofs_qemu_args.empty?
+          # Warden unwinds StartInstance first. Once its recovery stops QEMU,
+          # the daemons can stop too. A running guest keeps its shares.
+          return if machine.provider.driver.running?
+          unless env[:virtiofs_logs_shown]
+            Dir.glob(machine.data_dir.join("virtiofs/*.log")).each do |path|
+              machine.ui.error("virtiofsd log (#{path}):\n#{File.read(path)}")
+            end
+          end
+          SyncedFolderVirtioFS.new.cleanup(machine, preserve_logs: true)
+          machine.provider_config.virtiofs_qemu_args = []
+        rescue StandardError => error
+          machine.ui.error("VirtioFS recovery failed: #{error.message}")
+        end
+      end
+    end
+  end
+end