vagrant-qemu 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 275a26aad79e641534b4c9ea0bb7a9824f964b61c66dbbe9e3bf0d7075f23081
-  data.tar.gz: f4afe41ed386785952534fff85e7030030fab8b4defdd7438ce37cee649b1a50
+  metadata.gz: 462be36106f57c7732a3376ec6984c823196782401f5bd0d5efd6ef14869b525
+  data.tar.gz: d4e3ef79a87a6349fb48a195c02252de0911ab0c3682dfba6552db011d248d39
 SHA512:
-  metadata.gz: b05b9827dc708cf7dab8a417caae11eeed6fda22380e6d80d8eb3fd8a08c974b70f26b32ee0a10ceb06699a69ed59f1dcbfb42b856bed00ddb5bdeefa04acd37
-  data.tar.gz: dd55d31e14d55305e1c7714d74eb5d273fed56ba3b4ea927fb37ff305d337dbfd752f913f3b509562c395d8734950079d155e59950138c601041d29b0f10f744
+  metadata.gz: ded7ec9fcddf013a9acb8caa8962bb4d84cd6f6126b306cdba508fca1ffe6457e9aa0e58c4594c9de5dccb74d6615da78d4733d2cdfb95d7aa21553cbf03fc00
+  data.tar.gz: 3fa5f0ddddaeec9f9c26199ef80695760dffd65294b8ff2218257f3376ebe831ac62665ca26a6810116017bb612fe490d7521783d76438f63435532ac3e5e361

data/CHANGELOG.md

@@ -223,3 +223,72 @@
 * 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`.

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,7 +186,7 @@ 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
 * advanced networking (requires `advanced_network = true`)
@@ -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

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

@@ -1,4 +1,5 @@
 require "log4r"
+require_relative "../synced_folder_virtiofs"
 
 module VagrantPlugins
   module QEMU
@@ -8,9 +9,11 @@ module VagrantPlugins
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new("vagrant_qemu::action::start_instance")
+          @start_completed = false
         end
 
         def call(env)
+          @start_completed = false
           fw_ports = forwarded_ports(env)
           config = env[:machine].provider_config
 
@@ -21,11 +24,11 @@ module VagrantPlugins
             :machine => config.machine,
             :cpu => config.cpu,
             :smp => config.smp,
-            :memory => config.memory,
+            :memory => config.virtiofs_qemu_args.empty? ? config.memory : SyncedFolderVirtioFS.shared_memory_size(config.memory),
             :net_device => config.net_device,
             :drive_interface => config.drive_interface,
             :qemu_bin => config.qemu_bin,
-            :extra_qemu_args => config.extra_qemu_args,
+            :extra_qemu_args => config.extra_qemu_args + config.virtiofs_qemu_args,
             :extra_netdev_args => config.extra_netdev_args,
             :extra_drive_args => config.extra_drive_args,
             :ports => fw_ports,
@@ -48,7 +51,7 @@ module VagrantPlugins
 
           # Pick up SSH port that may have been corrected by HandleForwardedPortCollisions
           env[:machine].config.vm.networks.each do |type, opts|
-            if type == :forwarded_port && opts[:id] == "ssh"
+            if !config.net_device.nil? && type == :forwarded_port && opts[:id] == "ssh" && !opts[:disabled]
               options[:ssh_port] = opts[:host]
               break
             end
@@ -59,8 +62,69 @@ module VagrantPlugins
           options[:private_networks] = private_networks.map { |_, opts| opts }
 
           env[:ui].output(I18n.t("vagrant_qemu.starting"))
-          env[:machine].provider.driver.start(options)
-          @app.call(env)
+          begin
+            env[:machine].provider.driver.start(options)
+          rescue StandardError
+            raise if config.virtiofs_qemu_args.empty?
+            log_dir = env[:machine].data_dir.join("virtiofs")
+            Dir.glob(log_dir.join("*.log").to_s).each do |path|
+              begin
+                log = File.read(path)
+                env[:ui].error("virtiofsd log (#{path}):\n#{log.empty? ? '(empty)' : log}")
+              rescue Errno::ENOENT, Errno::EACCES
+                # Keep the QEMU failure as the error if the log disappears.
+              end
+            end
+            # ResetVirtioFSArgs#recover would print the same logs again.
+            env[:virtiofs_logs_shown] = true
+            Dir.glob(log_dir.join("*.pid").to_s).each do |path|
+              begin
+                contents = File.read(path).strip
+                next unless contents.match?(/\A[1-9]\d*\z/)
+                pid = contents.to_i
+                alive = begin
+                  Process.kill(0, pid)
+                  true
+                rescue Errno::ESRCH, Errno::EPERM
+                  false
+                end
+                socket_path = path.sub(/\.pid$/, ".sock_path")
+                socket = File.file?(socket_path) ? File.read(socket_path).strip : nil
+                env[:ui].error("virtiofsd pid #{pid} alive=#{alive}, socket=#{socket} socket_exists=#{socket && File.socket?(socket)}")
+              rescue Errno::ENOENT, Errno::EACCES
+                # Keep the QEMU failure as the error if daemon state disappears.
+              end
+            end
+            raise
+          end
+          @control_port = options[:control_port]
+          @start_completed = true
+          result = @app.call(env)
+          @start_completed = false
+          result
+        end
+
+        # Warden calls recover with the original failure. Stop only instances
+        # successfully launched by this action whose communicator never booted.
+        def recover(env)
+          return unless @start_completed
+          error = env["vagrant.error"]
+          return unless error.is_a?(Vagrant::Errors::VMBootTimeout) ||
+            error.is_a?(Vagrant::Errors::VMBootBadState)
+
+          @start_completed = false
+          @logger.warn("Boot failed; stopping the QEMU instance")
+          # The guest may not be able to handle ACPI yet. Ask QEMU to flush
+          # and quit directly, giving it several seconds before SIGKILL.
+          timeout = [[env[:machine].provider_config.graceful_timeout, 3].max, 10].min
+          driver = env[:machine].provider.driver
+          driver.stop(control_port: @control_port, graceful_timeout: timeout, quit_only: true)
+          message = driver.running? ? "boot_failed_stop_failed" : "boot_failed_stopped"
+          env[:ui].warn(I18n.t("vagrant_qemu.#{message}"))
+        rescue StandardError => cleanup_error
+          # Preserve the boot error that Warden is already propagating.
+          @logger.warn("Could not stop QEMU after boot failure: #{cleanup_error}")
+          env[:ui].warn(I18n.t("vagrant_qemu.boot_failed_stop_failed"))
         end
 
         def forwarded_ports(env)