vagrant-qemu 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0968c034faf465b2d51e1f7b785a7a1aed39a4d6c40ef96f6b34147e9ab8ebd
-  data.tar.gz: fff8fc272c6c99abb85ccff761137f53ee6aabe8953f4b702ffca61163ea8d27
+  metadata.gz: a7af3fcc9e9a9210bea30f44da695c87fbd15c24eed79de64540bb01ec5d4842
+  data.tar.gz: 805730ceb9574de982d6c20f4b8a7e04c37b13fbdc47ca902ddde6fcf844fef5
 SHA512:
-  metadata.gz: ba77c0b50cd06921799dcc154f8d987a3fe1e367fd4347bbd2a45381f0819815e9f832f29be04a76818fb5e5c24abb4f009fb33350aace09486f1a20f6250012
-  data.tar.gz: 6438ed9c811e25f7393e59971028eea43b5f3d76ac9a11982dd2424c8b7cbd54181cbaa514875aebbb54f38520fcab12575929e5c62259f42c37cce83274c34a
+  metadata.gz: d9613c43e9ea63da345bf0745b3825578cb9d32a8e9465b91a9beea36c571e085d9a325675d28e1a98fe655fbabffb0b29f8e6107e90a13dc504ba83e1b007c8
+  data.tar.gz: 96a64e28147f0a7c6c7994695d8b423088f7f3eb80c18288d2652120e24c5479d88d9d407455f10e0ab252a7cacbf0fb2f0c0ef2a22a403c625d3826d5002ec5

data/CHANGELOG.md

@@ -154,3 +154,35 @@
   core packaging middleware. Environment-specific state — networking, MAC,
   additional disks, DVDs/cloud-init seed ISOs, and firmware — is intentionally
   not baked into the box.
+
+# 0.6.0 (2026-07-21)
+
+* `net_mode = :socket_vmnet` adds no-sudo private networking on macOS: the
+  [socket_vmnet](https://github.com/lima-vm/socket_vmnet) daemon holds the root
+  vmnet membership and QEMU connects to it as a normal user, so `vagrant up`
+  and the other lifecycle commands need no sudo. It reuses the advanced-network
+  dual-NIC + cloud-init path — NIC 0 user-mode (SSH + port forwarding), NIC 1
+  on socket_vmnet with the configured static IP — giving host↔VM and VM↔VM
+  connectivity. On QEMU >= 7.2 QEMU connects to the daemon directly
+  (`-netdev stream`); on older QEMU it falls back to the `socket_vmnet_client`
+  wrapper (`-netdev socket,fd=3`), chosen automatically by probing the QEMU
+  binary. New config: `socket_vmnet_socket` and `socket_vmnet_client` (default
+  to the Homebrew prefix). The static IP must fall within the daemon's subnet
+  (`--vmnet-gateway`, default `192.168.105.1/24`); see the README. (#41)
+
+# 0.6.1 (2026-07-22)
+
+* Fix `vagrant reload` (and any other same-process halt-then-start, e.g. the
+  `vagrant-reload` plugin) failing with a QEMU image write-lock error when a
+  custom disk (`config.vm.disk`) was configured. `configure_disks` re-runs on
+  every `action_start`, but the driver's attached-disk list only ever
+  accumulated, so a reload attached each custom disk twice on the same qemu
+  command line. (#41)
+* Fix `qemu-img create` unconditionally recreating an already-existing custom
+  disk on every `configure_disks` call, which silently wiped the disk's
+  contents on every reload (independent of the bug above — resizing an
+  existing disk to a new configured size still isn't supported).
+* Fix the cloud-init network seed ISO (used by `advanced_network` without a
+  core `cloud_init` user-data config, i.e. the `net_mode` examples above)
+  being re-registered as a duplicate disk on every same-process reload,
+  hitting the same QEMU write-lock error via a different disk.

data/README.md

@@ -108,11 +108,13 @@ This provider exposes a few provider-specific configuration options:
   * `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`)
   * `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), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`
+  * `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`
   * `vmnet_interface` - Physical interface for vmnet-bridged mode, default: `en0`
   * `tap_device` - TAP device name for Linux tap backend, default: `nil` (uses `tap0`)
   * `mcast_addr` - Convenience shortcut for the `:socket` backend's multicast address, default: `nil` (uses `230.0.0.1:1234`)
   * `socket_opts` - Raw options for the `:socket` netdev, emitted verbatim as `-netdev socket,id=netN,<socket_opts>`. You pick the mode: `"mcast=230.0.0.1:1234"` (multicast, N-way), `"listen=:1234"` / `"connect=127.0.0.1:1234"` (point-to-point; you decide which VM listens and which connects — the no-root, macOS-friendly path). Overrides `mcast_addr`. Default: `nil` (falls back to multicast)
+  * `socket_vmnet_socket` - Path to the socket_vmnet daemon's unix socket, used by the `:socket_vmnet` backend, default: `<homebrew-prefix>/var/run/socket_vmnet` (`HOMEBREW_PREFIX` env, else `/opt/homebrew` on Apple Silicon, `/usr/local` on Intel)
+  * `socket_vmnet_client` - Path to the `socket_vmnet_client` wrapper, used only on QEMU older than 7.2 (which lacks the native `stream` netdev), default: `<homebrew-prefix>/opt/socket_vmnet/bin/socket_vmnet_client`
 
 ### Usage
 
@@ -320,7 +322,7 @@ See the [QEMU Documentation](https://www.qemu.org/docs/master/devel/multiple-iot
 
 12. Advanced networking with private_network
 
-Pick a backend with `net_mode`: QEMU's native vmnet.framework on macOS (requires sudo), TAP on Linux, or the `socket` netdev. The `:socket` backend is a thin wrapper around QEMU's `socket` netdev — you choose the mode in `socket_opts`: `mcast=` (multicast, N-way, Linux/Windows) or `listen=`/`connect=` (point-to-point, no root, works on macOS). The plugin creates two NICs: NIC 0 (user-mode for SSH and port forwarding) and NIC 1 (platform backend for VM networking). The static IP is delivered via a cloud-init NoCloud seed ISO that the plugin builds and attaches automatically; the NICs are matched by MAC address, never by interface order.
+Pick a backend with `net_mode`: QEMU's native vmnet.framework on macOS (`:vmnet_shared`/`_host`/`_bridged`, requires sudo), `:socket_vmnet` on macOS (full host↔VM and VM↔VM **without** sudo, via the [socket_vmnet](https://github.com/lima-vm/socket_vmnet) daemon), TAP on Linux, or the `socket` netdev. The `:socket` backend is a thin wrapper around QEMU's `socket` netdev — you choose the mode in `socket_opts`: `mcast=` (multicast, N-way, Linux/Windows) or `listen=`/`connect=` (point-to-point, no root, works on macOS). The plugin creates two NICs: NIC 0 (user-mode for SSH and port forwarding) and NIC 1 (platform backend for VM networking). The static IP is delivered via a cloud-init NoCloud seed ISO that the plugin builds and attaches automatically; the NICs are matched by MAC address, never by interface order.
 
 For VM-to-VM networking on macOS without sudo, use `:socket` with a `listen`/`connect` pair — you decide which VM listens and which connects:
 
@@ -366,6 +368,38 @@ Vagrant.configure("2") do |config|
 end
 ```
 
+Full networking on macOS **without sudo** with `:socket_vmnet` (host↔VM and VM↔VM, static IP):
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "perk/ubuntu-2204-arm64"  # an aarch64 cloud-init box
+  config.vm.network "private_network", ip: "192.168.105.10"
+
+  config.vm.provider "qemu" do |qe|
+    qe.advanced_network = true
+    qe.net_mode = :socket_vmnet
+    # qe.socket_vmnet_socket = "/opt/homebrew/var/run/socket_vmnet"  # default (Homebrew prefix)
+  end
+end
+```
+
+Set up the daemon once (root, one-time), then run `vagrant up` as your normal user:
+
+```sh
+brew install socket_vmnet
+# Reserve a static-IP range so cloud-init IPs don't collide with the DHCP pool:
+sudo brew services start socket_vmnet   # or run it with explicit flags, e.g.:
+# sudo socket_vmnet --vmnet-gateway=192.168.105.1 --vmnet-dhcp-end=192.168.105.100 \
+#     /opt/homebrew/var/run/socket_vmnet
+```
+
+The `private_network` IP must sit inside the daemon's subnet (`--vmnet-gateway`, default
+`192.168.105.1/24`) and, to avoid a DHCP clash, above `--vmnet-dhcp-end`. Unlike the native vmnet
+backends, `:socket_vmnet` cannot tell the daemon which subnet to use — the daemon's launch flags are
+authoritative, so align the IP to them. On QEMU ≥ 7.2 the plugin connects to the daemon directly
+(`-netdev stream`); on older QEMU it automatically falls back to the `socket_vmnet_client` wrapper
+(configurable via `qe.socket_vmnet_client`).
+
 Notes:
 * The guest image must include cloud-init, otherwise the static IP is silently not applied
 * On macOS, vmnet requires root: run `sudo vagrant up` (and the other lifecycle commands such as `halt`/`reload`/`destroy`), because the plugin launches QEMU as a child of the Vagrant process and does not elevate it on its own. The plugin warns when vmnet is selected and Vagrant is not running as root.
@@ -374,7 +408,7 @@ Notes:
   sudo chown -R "$(id -un)":staff ~/.vagrant.d/boxes/<box> .vagrant
   ```
   Pre-adding boxes as your normal user (`vagrant box add <box>`) before the first `sudo vagrant up` also avoids the box ending up root-owned.
-* To avoid root (and this side effect) entirely on macOS, use [`socket_vmnet`](https://github.com/lima-vm/socket_vmnet) — a small root helper daemon you install once, which QEMU then connects to as a normal user (the approach Lima/Colima/minikube take). The `com.apple.developer.networking.vmnet` entitlement could also bypass root in principle, but it is a *restricted* Apple entitlement that requires an Apple-provisioned signing certificate and cannot be ad-hoc / self-signed onto Homebrew's QEMU, so it is not a practical option for individual users.
+* To avoid root (and this side effect) entirely on macOS, use `net_mode = :socket_vmnet` (see the example above): the [`socket_vmnet`](https://github.com/lima-vm/socket_vmnet) daemon holds the root vmnet membership and QEMU connects to it as a normal user (the approach Lima/Colima/minikube take), so `vagrant up` and the other lifecycle commands need no sudo. The `com.apple.developer.networking.vmnet` entitlement could also bypass root in principle, but it is a *restricted* Apple entitlement that requires an Apple-provisioned signing certificate and cannot be ad-hoc / self-signed onto Homebrew's QEMU, so it is not a practical option for individual users.
 * Without `advanced_network = true`, the `private_network` configuration is ignored with a warning
 * When only one NIC is needed (no `private_network`), no cloud-init seed is attached, avoiding compatibility issues
 * Combining `advanced_network` with `config.vm.cloud_init` is supported: the plugin merges your user-data and the generated network-config into a single NoCloud seed
@@ -387,7 +421,8 @@ Platform support:
 
 | Platform | Backend (`net_mode`) | Host ↔ VM | VM ↔ VM | Root? | External dependency |
 |----------|---------|:---------:|:-------:|:-----:|:-------------------:|
-| macOS    | `:vmnet_shared`/`_host`/`_bridged` | Yes | Yes | sudo (or socket_vmnet) | None (QEMU >= 7.0) |
+| macOS    | `:vmnet_shared`/`_host`/`_bridged` | Yes | Yes | sudo | None (QEMU >= 7.0) |
+| macOS    | `:socket_vmnet` | Yes | Yes | No | socket_vmnet daemon (`brew install socket_vmnet`) |
 | macOS    | `:socket` (`listen`/`connect`) | No (use port forwarding) | Yes (2 VMs) | No | None |
 | Linux    | `:tap` + bridge | Yes | Yes | sudo | Pre-created tap device + bridge (`ip` command) |
 | Linux    | `:socket` (`mcast`) | No (use port forwarding) | Yes | No | None |

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

@@ -24,6 +24,10 @@ module VagrantPlugins
         # user-data seed.
         CORE_SEED_DISK_NAME = "vagrant-cloud_init-disk".freeze
 
+        # Disk name this action gives its own network-only seed (no core
+        # user-data seed present).
+        OWN_SEED_DISK_NAME = "vagrant-qemu-network-disk".freeze
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new("vagrant_qemu::action::cloud_init_network")
@@ -55,13 +59,24 @@ module VagrantPlugins
         private
 
         # No core cloud-init seed: build our own network-only seed and attach
-        # it as a fresh :dvd disk.
+        # it as a fresh :dvd disk. This re-runs on every action_start
+        # (including a same-process reload), so a disk already registered
+        # from an earlier run is rebuilt in place rather than re-registered
+        # -- machine.config.vm.disks has no dedup of its own.
         def attach_network_seed(machine, env, pn)
-          iso_path = build_seed(machine, env, pn,
+          existing = machine.config.vm.disks.find do |d|
+            d.type == :dvd && d.name == OWN_SEED_DISK_NAME
+          end
+
+          iso_path = existing ? Pathname.new(existing.file) : machine.data_dir.join("vagrant-qemu-network.iso")
+
+          build_seed(machine, env, pn,
             user_data: "#cloud-config\n",
-            file_destination: machine.data_dir.join("vagrant-qemu-network.iso"))
+            file_destination: iso_path)
+
+          return if existing
 
-          machine.config.vm.disk :dvd, file: iso_path.to_s, name: "vagrant-qemu-network-disk"
+          machine.config.vm.disk :dvd, file: iso_path.to_s, name: OWN_SEED_DISK_NAME
           machine.config.vm.disks.each do |d|
             d.finalize! if d.type == :dvd && d.file == iso_path.to_s
           end

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

@@ -42,6 +42,8 @@ module VagrantPlugins
             :tap_device => config.tap_device,
             :mcast_addr => config.mcast_addr,
             :socket_opts => config.socket_opts,
+            :socket_vmnet_socket => config.socket_vmnet_socket,
+            :socket_vmnet_client => config.socket_vmnet_client,
           }
 
           # Pick up SSH port that may have been corrected by HandleForwardedPortCollisions

data/lib/vagrant-qemu/cap/disk.rb

@@ -32,6 +32,11 @@ module VagrantPlugins
         # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
         # @return [Hash] configured_disks - A hash of all the current configured disks
         def self.configure_disks(machine, defined_disks)
+          # Vagrant re-invokes this on every action_start (including a
+          # same-process reload), always passing the complete current disk
+          # list -- reset before the empty check so a disk removed from the
+          # Vagrantfile doesn't leave a stale entry attached either.
+          machine.provider.driver.reset_attached_drives!
           return {} if defined_disks.empty?
 
           configured_disks = {disk: [], floppy: [], dvd: []}
@@ -79,12 +84,17 @@ module VagrantPlugins
         def self.setup_disk(machine, disk)
           disk_dir = machine.provider.driver.disk_dir
           disk_path = disk_dir.join("#{disk.name}.#{disk.disk_ext}")
-          args = ["create", "-f", "qcow2"]
 
           disk_provider_config = disk.provider_config[:qemu] if disk.provider_config
-          args.push(disk_path.to_s)
-          args.push("#{disk.size}")
-          machine.provider.driver.execute("qemu-img", *args)
+
+          # configure_disks re-runs on every action_start (including a
+          # same-process reload); qemu-img create truncates an existing file
+          # unconditionally, so skip it once the disk already exists instead
+          # of silently wiping it. Resizing an existing disk isn't handled.
+          if !disk_path.file?
+            args = ["create", "-f", "qcow2", disk_path.to_s, "#{disk.size}"]
+            machine.provider.driver.execute("qemu-img", *args)
+          end
 
           {UUID: disk.id, Name: disk.name, Path: disk_path.to_s, primary: !!disk.primary}
         end

data/lib/vagrant-qemu/config.rb

@@ -29,7 +29,7 @@ module VagrantPlugins
       attr_accessor :graceful_timeout  # seconds to wait for guest shutdown before force kill
       # Advanced networking options
       attr_accessor :advanced_network   # bool, opt-in for dual-NIC setup
-      attr_accessor :net_mode           # :auto, :vmnet_shared, :vmnet_host, :vmnet_bridged, :tap, :socket
+      attr_accessor :net_mode           # :auto, :vmnet_shared, :vmnet_host, :vmnet_bridged, :tap, :socket, :socket_vmnet
       attr_accessor :vmnet_interface    # physical interface for vmnet-bridged (e.g. "en0")
       attr_accessor :tap_device         # tap device name for Linux tap backend
       attr_accessor :mcast_addr         # convenience shortcut for the :socket backend's multicast address
@@ -39,6 +39,10 @@ module VagrantPlugins
       # The mode (multicast vs point-to-point listen/connect) and any roles are
       # entirely the user's choice. Overrides mcast_addr when set.
       attr_accessor :socket_opts
+      # socket_vmnet backend (macOS): the daemon's unix socket, and the client
+      # wrapper used only on QEMU without the native `stream` netdev.
+      attr_accessor :socket_vmnet_socket
+      attr_accessor :socket_vmnet_client
 
       def initialize
         @ssh_host = UNSET_VALUE
@@ -71,6 +75,8 @@ module VagrantPlugins
         @tap_device = UNSET_VALUE
         @mcast_addr = UNSET_VALUE
         @socket_opts = UNSET_VALUE
+        @socket_vmnet_socket = UNSET_VALUE
+        @socket_vmnet_client = UNSET_VALUE
       end
 
       #-------------------------------------------------------------------
@@ -123,6 +129,8 @@ module VagrantPlugins
         @tap_device = nil if @tap_device == UNSET_VALUE
         @mcast_addr = nil if @mcast_addr == UNSET_VALUE
         @socket_opts = nil if @socket_opts == UNSET_VALUE
+        @socket_vmnet_socket = "#{homebrew_prefix}/var/run/socket_vmnet" if @socket_vmnet_socket == UNSET_VALUE
+        @socket_vmnet_client = "#{homebrew_prefix}/opt/socket_vmnet/bin/socket_vmnet_client" if @socket_vmnet_client == UNSET_VALUE
 
         # TODO better error msg
         @ssh_port = Integer(@ssh_port)
@@ -152,6 +160,14 @@ module VagrantPlugins
         end
       end
 
+      # Homebrew install prefix: env override, else the per-arch default
+      # (Apple Silicon vs Intel). Defaults to the host arch (socket_vmnet paths
+      # are host-side); default_qemu_dir passes the guest arch to keep its
+      # firmware-dir behavior.
+      def homebrew_prefix(arch = host_arch)
+        ENV["HOMEBREW_PREFIX"] || (arch == "aarch64" ? "/opt/homebrew" : "/usr/local")
+      end
+
       # QEMU data dir (firmware images). Only actually consumed for aarch64
       # firmware, but resolved generically: explicit env override, then the
       # Homebrew prefix, then a per-platform default.
@@ -161,7 +177,7 @@ module VagrantPlugins
 
         case RbConfig::CONFIG["host_os"]
         when /darwin/
-          arch == "aarch64" ? "/opt/homebrew/share/qemu" : "/usr/local/share/qemu"
+          "#{homebrew_prefix(arch)}/share/qemu"
         else
           "/usr/share/qemu"
         end

data/lib/vagrant-qemu/driver.rb

@@ -114,6 +114,7 @@ module VagrantPlugins
           cmd += %W(-m #{options[:memory]}) if !options[:memory].nil?
 
           # network
+          launch_prefix = []
           if !options[:net_device].nil?
             private_networks = options[:private_networks] || []
             use_advanced = options[:advanced_network] && !private_networks.empty?
@@ -139,8 +140,12 @@ module VagrantPlugins
               # (the static-IP cloud-init seed is built and attached by the
               # CloudInitNetwork action, not here)
               backend = Network.backend_for(options[:net_mode])
+              backend.preflight!(options, qemu_binary)
               cmd += %W(-device #{options[:net_device]},netdev=net1,mac=#{mac1})
               cmd += backend.build_netdev_args("net1", options)
+              # launch_prefix is applied under the same gate as build_netdev_args
+              # (empty for every backend except socket_vmnet's wrapper route).
+              launch_prefix = backend.launch_prefix(options)
             else
               # Single NIC: user-mode only (original behavior, no cloud-init)
               cmd += %W(-device #{options[:net_device]},netdev=net0)
@@ -206,6 +211,10 @@ module VagrantPlugins
           # user-defined
           cmd += options[:extra_qemu_args]
 
+          # socket_vmnet wrapper route: launch qemu under socket_vmnet_client
+          # (empty prefix otherwise -> zero difference from the current path).
+          cmd = launch_prefix + cmd
+
           opts = {:detach => options[:no_daemonize]}
           execute(*cmd, **opts)
         end
@@ -463,6 +472,14 @@ module VagrantPlugins
         end
       end
 
+      # Vagrant's Disk middleware always passes the *complete* current disk
+      # list and re-runs on every action_start (including a same-process
+      # reload, which reuses this Driver instance) -- so attach_disk/attach_dvd
+      # must be rebuilt from a clean slate each time, not accumulated across calls.
+      def reset_attached_drives!
+        @attached_drives = {disk: [], floppy: [], dvd: []}
+      end
+
       def attach_dvd(disk)
         @attached_drives[:dvd] << disk
       end

data/lib/vagrant-qemu/errors.rb

@@ -38,6 +38,18 @@ module VagrantPlugins
       class DestroyError < VagrantQEMUError
         error_key(:destroy_error)
       end
+
+      class SocketVmnetNotMacos < VagrantQEMUError
+        error_key(:socket_vmnet_not_macos)
+      end
+
+      class SocketVmnetSocketNotFound < VagrantQEMUError
+        error_key(:socket_vmnet_socket_not_found)
+      end
+
+      class SocketVmnetClientNotFound < VagrantQEMUError
+        error_key(:socket_vmnet_client_not_found)
+      end
     end
   end
 end

data/lib/vagrant-qemu/network/base.rb

@@ -15,6 +15,23 @@ module VagrantPlugins
         def requires_sudo?
           false
         end
+
+        # Tokens to prepend to the QEMU launch command (a wrapper program).
+        # Empty by default; only socket_vmnet's wrapper route is non-empty.
+        # The driver applies this under the same gate as build_netdev_args.
+        # @param options [Hash] provider config options
+        # @return [Array<String>]
+        def launch_prefix(options)
+          []
+        end
+
+        # Validate preconditions and resolve any backend-specific options
+        # before the command is built. No-op by default; the driver calls it
+        # under the same gate as build_netdev_args.
+        # @param options [Hash] provider config options (may be mutated)
+        # @param qemu_binary [String] the resolved qemu-system-* binary
+        def preflight!(options, qemu_binary)
+        end
       end
     end
   end

data/lib/vagrant-qemu/network/socket_vmnet.rb

@@ -0,0 +1,60 @@
+require_relative "base"
+require_relative "../errors"
+
+module VagrantPlugins
+  module QEMU
+    module Network
+      # socket_vmnet backend (macOS) -- connects the private NIC to a
+      # socket_vmnet daemon so QEMU runs without sudo (the daemon holds the
+      # root vmnet.framework membership).
+      #
+      # Two routes, chosen by whether the QEMU binary has the native `stream`
+      # netdev (options[:use_stream], set by the driver from a probe):
+      #   stream (QEMU >= 7.2): QEMU connects to the daemon's unix socket
+      #     directly -- a pure netdev backend, no launch wrapper.
+      #   wrapper (older QEMU): QEMU is launched under `socket_vmnet_client
+      #     <sock>`, which hands the connection in on fd 3.
+      #
+      # build_netdev_args and launch_prefix are driven by the same use_stream
+      # so they never disagree.
+      class SocketVmnet < Base
+        # Resolve the route and fail fast on missing preconditions. Sets
+        # options[:use_stream]: true when the qemu binary has the native
+        # `stream` netdev, false when it definitively lacks it, and true when
+        # the probe couldn't determine (rare) -- stream needs no extra dependency.
+        def preflight!(options, qemu_binary)
+          raise Errors::SocketVmnetNotMacos unless RbConfig::CONFIG["host_os"] =~ /darwin/
+
+          options[:use_stream] = Network.qemu_supports_stream?(qemu_binary) != false
+
+          socket = options[:socket_vmnet_socket]
+          unless socket && File.exist?(socket)
+            raise Errors::SocketVmnetSocketNotFound, socket: socket
+          end
+
+          return if options[:use_stream]
+
+          client = options[:socket_vmnet_client]
+          unless client && (::Vagrant::Util::Which.which(client) || File.executable?(client))
+            raise Errors::SocketVmnetClientNotFound, client: client
+          end
+        end
+
+        def build_netdev_args(id, options)
+          if options[:use_stream]
+            sock = options[:socket_vmnet_socket]
+            %W(-netdev stream,id=#{id},server=off,addr.type=unix,addr.path=#{sock})
+          else
+            %W(-netdev socket,id=#{id},fd=3)
+          end
+        end
+
+        def launch_prefix(options)
+          return [] if options[:use_stream]
+
+          %W(#{options[:socket_vmnet_client]} #{options[:socket_vmnet_socket]})
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/network.rb

@@ -2,6 +2,7 @@ require_relative "network/base"
 require_relative "network/vmnet"
 require_relative "network/tap"
 require_relative "network/socket"
+require_relative "network/socket_vmnet"
 
 module VagrantPlugins
   module QEMU
@@ -9,7 +10,7 @@ module VagrantPlugins
       # Select the appropriate network backend based on net_mode and platform.
       #
       # @param net_mode [Symbol] :auto, :vmnet_shared, :vmnet_host,
-      #   :vmnet_bridged, :tap, :socket
+      #   :vmnet_bridged, :tap, :socket, :socket_vmnet
       # @return [Base] a network backend instance
       def self.backend_for(net_mode)
         case net_mode
@@ -19,6 +20,8 @@ module VagrantPlugins
           Tap.new
         when :socket
           Socket.new
+        when :socket_vmnet
+          SocketVmnet.new
         when :auto
           auto_detect
         else
@@ -39,6 +42,34 @@ module VagrantPlugins
         end
       end
 
+      # Whether the QEMU binary has the native `stream` netdev (QEMU >= 7.2),
+      # so socket_vmnet can connect to the daemon's unix socket directly
+      # instead of going through the socket_vmnet_client wrapper.
+      #
+      # Probes `<qemu> -M none -netdev help` and looks for a `stream` line on
+      # stdout. Cached per binary.
+      #
+      # Tri-state so the driver can honor the design's fallback direction:
+      #   true  -- probe ran, stream present  -> use stream
+      #   false -- probe ran, stream absent    -> use the wrapper (old QEMU)
+      #   nil   -- probe could not run (rare)  -> driver defaults to stream
+      #
+      # @param qemu_binary [String] path/name of the qemu-system-* binary
+      # @return [Boolean, nil]
+      def self.qemu_supports_stream?(qemu_binary)
+        @stream_support ||= {}
+        return @stream_support[qemu_binary] if @stream_support.key?(qemu_binary)
+
+        result =
+          begin
+            out = ::Vagrant::Util::Subprocess.execute(qemu_binary, "-M", "none", "-netdev", "help")
+            out.exit_code == 0 ? out.stdout.lines.any? { |l| l.strip == "stream" } : nil
+          rescue StandardError
+            nil
+          end
+        @stream_support[qemu_binary] = result
+      end
+
       # Generate a deterministic MAC address from vm_id and NIC index.
       # Uses 52:54:00 prefix (QEMU's OUI).
       #

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.5.0'
+    VERSION = '0.6.1'
   end
 end

data/locales/en.yml

@@ -84,3 +84,24 @@ en:
 
         The machine ID has been preserved. Fix the underlying issue and
         run `vagrant destroy` again.
+      socket_vmnet_not_macos: |-
+        net_mode = :socket_vmnet is only supported on macOS (it relies on
+        the socket_vmnet daemon and vmnet.framework).
+      socket_vmnet_socket_not_found: |-
+        The socket_vmnet daemon socket was not found:
+
+          %{socket}
+
+        Install and start the daemon first, e.g.:
+          brew install socket_vmnet
+          sudo brew services start socket_vmnet
+
+        Or point qe.socket_vmnet_socket at the daemon's socket path.
+      socket_vmnet_client_not_found: |-
+        This QEMU lacks the native `stream` netdev (QEMU < 7.2), so the
+        socket_vmnet_client wrapper is required but was not found:
+
+          %{client}
+
+        Install socket_vmnet (which ships the client), upgrade QEMU to >= 7.2,
+        or point qe.socket_vmnet_client at the wrapper binary.

data/spec/e2e/disk_spec.rb

@@ -32,4 +32,76 @@ describe "extra disk attachment end-to-end", :requires_qemu do
     expect(ssh[:exit_code]).to eq 0
     expect(ssh[:stdout].lines.last.to_s.strip.to_i).to be >= 2
   end
+
+  it "reload with an extra disk does not hit a QEMU image-lock error" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.disk :disk, name: "extra", size: "1GB"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+
+    result = vagrant_up(@work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq 0
+
+    # This is the exact same-process halt->start path a same-process reload
+    # takes (issue #41: reload used to re-attach the extra disk a second
+    # time, so QEMU refused its own duplicate -drive with a write-lock error).
+    reload = vagrant_reload(@work_dir, timeout: 600)
+    expect(reload[:exit_code]).to eq 0
+    expect(reload[:stderr]).not_to match(/Failed to get "write" lock/)
+
+    ssh = vagrant_ssh(@work_dir, command: %q{lsblk -d -n -o TYPE | grep -c '^disk$'})
+    expect(ssh[:exit_code]).to eq 0
+    expect(ssh[:stdout].lines.last.to_s.strip.to_i).to be >= 2
+  end
+
+  it "reload does not wipe data already written to an extra disk" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.disk :disk, name: "extra", size: "1GB"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+
+    result = vagrant_up(@work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq 0
+
+    setup = vagrant_ssh(@work_dir, command: <<~SH)
+      set -e
+      dev=$(lsblk -d -n -o NAME,TYPE | awk '$2=="disk"{print $1}' | grep -v vda | head -1)
+      sudo mkfs.ext4 -F /dev/$dev
+      sudo mkdir -p /mnt/extra
+      sudo mount /dev/$dev /mnt/extra
+      echo marker-should-survive-reload | sudo tee /mnt/extra/marker.txt
+      sudo umount /mnt/extra
+    SH
+    expect(setup[:exit_code]).to eq 0
+
+    # configure_disks unconditionally ran `qemu-img create` on every
+    # action_start (including this same-process reload), silently
+    # truncating the extra disk every time -- this is the regression test.
+    reload = vagrant_reload(@work_dir, timeout: 600)
+    expect(reload[:exit_code]).to eq 0
+
+    check = vagrant_ssh(@work_dir, command: <<~SH)
+      set -e
+      dev=$(lsblk -d -n -o NAME,TYPE | awk '$2=="disk"{print $1}' | grep -v vda | head -1)
+      sudo mkdir -p /mnt/extra
+      sudo mount /dev/$dev /mnt/extra
+      cat /mnt/extra/marker.txt
+    SH
+    expect(check[:exit_code]).to eq 0
+    expect(check[:stdout]).to include("marker-should-survive-reload")
+  end
 end

data/spec/e2e/helper.rb

@@ -130,7 +130,7 @@ RSpec.configure do |config|
   # e2e runs the INSTALLED plugin (see note above) — fail fast when it
   # doesn't match the source tree, instead of silently testing a stale gem.
   config.before(:suite) do
-    next unless ENV["TEST_QEMU"] || ENV["TEST_VMNET"]
+    next unless ENV["TEST_QEMU"] || ENV["TEST_VMNET"] || ENV["TEST_SOCKET_VMNET"]
 
     require "vagrant-qemu/version"
     expected = VagrantPlugins::QEMU::VERSION