vagrant-qemu 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 462be36106f57c7732a3376ec6984c823196782401f5bd0d5efd6ef14869b525
-  data.tar.gz: d4e3ef79a87a6349fb48a195c02252de0911ab0c3682dfba6552db011d248d39
+  metadata.gz: 29dd41685f09eaee73da2f6a10070679da9eb5220150efa47e4c016159264e0f
+  data.tar.gz: 65a2a89ee494f735f5de4b347517ad744a2c26b9dfdae55832a7572c216183c9
 SHA512:
-  metadata.gz: ded7ec9fcddf013a9acb8caa8962bb4d84cd6f6126b306cdba508fca1ffe6457e9aa0e58c4594c9de5dccb74d6615da78d4733d2cdfb95d7aa21553cbf03fc00
-  data.tar.gz: 3fa5f0ddddaeec9f9c26199ef80695760dffd65294b8ff2218257f3376ebe831ac62665ca26a6810116017bb612fe490d7521783d76438f63435532ac3e5e361
+  metadata.gz: cb872c571092692bdcf7d5946ce85eeea75dede69ee619a56c34dd062ace730b36b0aba3c414e0b6c75ff2e2e530dd50ad77c574b5fe0294fae4deab63147d9d
+  data.tar.gz: deecca7a10a369f259df3c517db2b9d96a0b39b27a1050997897bb592944bcb678937fa8e4daadf28882543f4813626a95dd304bef94550bfd52ce54d25a131b

data/CHANGELOG.md

@@ -292,3 +292,41 @@ Project:
   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

@@ -188,7 +188,7 @@ This provider exposes a few provider-specific configuration options:
   * `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 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`

data/lib/vagrant-qemu/driver.rb

@@ -1,5 +1,6 @@
 require 'log4r'
 require 'childprocess'
+require 'open3'
 require 'securerandom'
 require 'yaml'
 
@@ -11,10 +12,17 @@ require "vagrant/util/which"
 
 require_relative "plugin"
 require_relative "network"
+require_relative "version"
 
 module VagrantPlugins
   module QEMU
     class Driver
+      # Seconds to wait for QEMU to exit after SIGTERM before SIGKILL.
+      TERM_TIMEOUT = 10
+      # Seconds to wait after SIGKILL; a large guest's memory takes time to
+      # release.
+      KILL_TIMEOUT = 10
+
       # @return [String] VM ID
       attr_reader :vm_id
       attr_reader :data_dir
@@ -45,10 +53,21 @@ module VagrantPlugins
 
       def delete
         if created?
+          sockets = socket_paths(runtime_dir)
           id_dir = @data_dir.join(@vm_id)
           FileUtils.rm_rf(id_dir)
           id_tmp_dir = @tmp_dir.join(@vm_id)
           FileUtils.rm_rf(id_tmp_dir)
+
+          # Sockets recorded under another VAGRANT_HOME's tmp dir.
+          sockets.each do |path|
+            FileUtils.rm_f(path)
+            begin
+              Dir.rmdir(File.dirname(path))
+            rescue SystemCallError
+              # Not empty, or already removed with id_tmp_dir.
+            end
+          end
         end
       end
 
@@ -65,30 +84,37 @@ module VagrantPlugins
 
           id_tmp_dir = @tmp_dir.join(@vm_id)
           FileUtils.mkdir_p(id_tmp_dir)
+          remove_legacy_runtime_files
+          FileUtils.mkdir_p(run_dir)
+
+          monitor_socket = id_tmp_dir.join("qemu_socket").to_s if options[:control_port].nil?
+          serial_socket = id_tmp_dir.join("qemu_socket_serial").to_s if options[:debug_port].nil?
 
-          # Persist only the runtime state we need to read back later
+          # Persist only the runtime state we need to read back later. The
+          # socket paths are recorded so that commands run under another
+          # VAGRANT_HOME still reach the sockets this launch created.
           persisted_state = {
             :ssh_port => options[:ssh_port],
             :control_port => options[:control_port],
             :debug_port => options[:debug_port],
+            :monitor_socket => monitor_socket,
+            :serial_socket => serial_socket,
+            :plugin_version => VERSION,
           }
-          options_file = id_tmp_dir.join("options.yml")
-          File.write(options_file, persisted_state.to_yaml)
+          File.write(run_dir.join("options.yml"), persisted_state.to_yaml)
 
           control_socket = ""
           if !options[:control_port].nil?
             control_socket = "port=#{options[:control_port]},host=localhost,ipv4=on"
           else
-            unix_socket_path = id_tmp_dir.join("qemu_socket").to_s
-            control_socket = "path=#{unix_socket_path}"
+            control_socket = "path=#{monitor_socket}"
           end
 
           debug_socket = ""
           if !options[:debug_port].nil?
             debug_socket = "port=#{options[:debug_port]},host=localhost,ipv4=on"
           else
-            unix_socket_serial_path = id_tmp_dir.join("qemu_socket_serial").to_s
-            debug_socket = "path=#{unix_socket_serial_path}"
+            debug_socket = "path=#{serial_socket}"
           end
 
           cmd = []
@@ -196,7 +222,7 @@ module VagrantPlugins
           end
 
           # control
-          pid_file = id_tmp_dir.join("qemu.pid").to_s
+          pid_file = run_dir.join("qemu.pid").to_s
           cmd += %W(-chardev socket,id=mon0,#{control_socket},server=on,wait=off)
           cmd += %W(-mon chardev=mon0,mode=readline)
           cmd += %W(-chardev socket,id=ser0,#{debug_socket},server=on,wait=off)
@@ -222,80 +248,218 @@ module VagrantPlugins
       end
 
       def stop(options)
-        return unless running?
+        dir, pid = live_instance
+        return if pid.nil?
 
-        opts = with_persisted_control_port(options)
+        opts = with_persisted_monitor(options, dir)
         timeout = options[:graceful_timeout] || 60
+        monitor = true
 
         # 1. ACPI power button (graceful). Only works if a live guest OS is
         #    there to act on it -- e.g. NOT after `systemctl halt`, which leaves
         #    QEMU running with a halted, unresponsive guest.
         unless options[:quit_only]
-          send_monitor(opts, "system_powerdown")
-          return unless still_running_after?(timeout)
-          @logger.warn("VM did not power down within #{timeout}s; sending 'quit' to QEMU")
+          monitor = send_monitor(opts, "system_powerdown")
+          if monitor
+            return unless still_running_after?(timeout)
+            @logger.warn("VM did not power down within #{timeout}s; sending 'quit' to QEMU")
+          end
         end
 
         # 2. Powerdown didn't take. Ask QEMU itself to quit: it stops the VM,
         #    flushes and closes the qcow2 images, then exits cleanly. Does not
         #    depend on the guest, only on the monitor being reachable.
-        send_monitor(opts, "quit")
-        return unless still_running_after?(timeout)
+        if monitor && send_monitor(opts, "quit")
+          return unless still_running_after?(timeout)
+          @logger.warn("VM still running after 'quit'; forcing kill")
+        else
+          # 3. The monitor is unreachable (e.g. its socket was removed), so
+          #    there is nothing to wait for: SIGTERM makes QEMU shut down and
+          #    close its images like 'quit', without telling the guest.
+          @logger.warn("QEMU monitor unreachable; sending SIGTERM")
+          return if terminate(pid)
+          @logger.warn("VM still running after SIGTERM; forcing kill")
+        end
 
-        # 3. Last resort: SIGKILL the QEMU process (no flush/cleanup).
-        @logger.warn("VM still running after 'quit'; forcing kill")
-        force_kill
+        # 4. Last resort: SIGKILL the QEMU process (no flush/cleanup). If it is
+        #    still there, stop here rather than let halt report success or
+        #    destroy delete the files of a running QEMU. Only a zombie counts
+        #    as gone: one still releasing a large guest's memory no longer
+        #    shows its argv to ps, so the identity check cannot tell.
+        return if force_kill(pid)
+        raise Errors::QemuDidNotExit, pid: pid if process_exists?(pid) && !zombie?(pid)
+      ensure
+        remove_runtime_leftovers(dir, pid) if pid
       end
 
       private
 
       # QEMU unlinks its pidfile on exit, so the file can vanish between any
       # existence check and the read: read it once and treat ENOENT as gone.
-      def read_pid
-        File.read(@tmp_dir.join(@vm_id).join("qemu.pid")).to_i
+      # QEMU creates it mode 0600, so a VM started under sudo leaves one that
+      # other users cannot read.
+      def read_pid(dir)
+        File.read(dir.join("qemu.pid")).to_i
       rescue Errno::ENOENT
         nil
+      rescue Errno::EACCES
+        raise Errors::PidfileNotReadable, path: dir.join("qemu.pid").to_s
+      end
+
+      # Runtime files (qemu.pid, options.yml) live in the project's machine
+      # data dir so a cleaned tmp dir or another VAGRANT_HOME cannot hide a
+      # running VM. The unix sockets stay in Vagrant's tmp dir: macOS caps
+      # socket paths at 104 bytes and project paths can be longer.
+      def run_dir
+        @data_dir.join(@vm_id, "run")
+      end
+
+      # Where each layout keeps qemu.pid, with the ASCII tail of that path to
+      # look for in QEMU's command line. 0.3.7 to 0.7.0 used the tmp dir.
+      def runtime_layouts
+        {
+          run_dir => "/#{@vm_id}/run/qemu.pid",
+          @tmp_dir.join(@vm_id) => "/vagrant-qemu/#{@vm_id}/qemu.pid",
+        }
+      end
+
+      # QEMU removes its pidfile and sockets on a clean exit, but not after
+      # SIGKILL. An older version's options.yml goes too, so the next start
+      # reads only the project-local layout. Nothing is removed while the PID
+      # still exists.
+      def remove_runtime_leftovers(dir, pid)
+        return if process_exists?(pid)
+        # Another VAGRANT_HOME holds no machine lock against us and may have
+        # started the VM again meanwhile.
+        current = read_pid(dir)
+        return if current && current != pid
+        files = [dir.join("qemu.pid").to_s, *socket_paths(dir)]
+        files << dir.join("options.yml").to_s if dir != run_dir
+        FileUtils.rm_f(files)
+      end
+
+      # Unix sockets of the instance whose runtime files are in dir. Versions
+      # before the runtime record always used the tmp dir.
+      def socket_paths(dir)
+        persisted = persisted_options(dir)
+        if persisted.is_a?(Hash) && persisted.key?(:monitor_socket)
+          return [persisted[:monitor_socket], persisted[:serial_socket]].compact
+        end
+        [@tmp_dir.join(@vm_id, "qemu_socket").to_s, @tmp_dir.join(@vm_id, "qemu_socket_serial").to_s]
+      end
+
+      # 0.3.7 to 0.7.0 kept qemu.pid and options.yml in the tmp dir. Remove
+      # them before starting under the project-local layout, unless their PID
+      # still exists: a failed identity check alone never justifies deleting
+      # files a live process may own.
+      def remove_legacy_runtime_files
+        dir = @tmp_dir.join(@vm_id)
+        pid = read_pid(dir)
+        return if pid && pid > 0 && process_exists?(pid)
+        FileUtils.rm_f([dir.join("qemu.pid").to_s, dir.join("options.yml").to_s])
+      end
+
+      # [runtime dir, PID] of this VM's running QEMU, or nil. Never cached:
+      # a reload stops an old-layout VM and starts it under the new one.
+      def live_instance
+        runtime_layouts.each do |dir, token|
+          pid = read_pid(dir)
+          next if pid.nil? || pid <= 0 || !process_exists?(pid)
+          return [dir, pid] if owned_by_vm?(pid, token)
+        end
+        nil
+      end
+
+      # EPERM means the process exists but belongs to another user, e.g. a VM
+      # started with sudo.
+      def process_exists?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
       end
 
-      # Prefer the control_port the VM was actually started with (persisted
-      # in options.yml) so halt still works after a Vagrantfile edit.
-      def with_persisted_control_port(options)
-        options_file = @tmp_dir.join(@vm_id).join("options.yml")
-        return options if !options_file.file?
+      # Guards against a stale pidfile whose PID was reused. Matches only the
+      # ASCII tail of the -pidfile argument: ps escapes non-ASCII bytes under
+      # the C locale, and argv keeps the launch-time path if the project
+      # directory is moved while the VM runs.
+      def owned_by_vm?(pid, token)
+        out, status = Open3.capture2e("ps", "-ww", "-p", pid.to_s, "-o", "args=")
+        return out.b.include?(token.b) if status.success?
+        process_exists?(pid)
+      rescue SystemCallError
+        # No usable ps (e.g. on Windows): keep the kill(0) answer.
+        true
+      end
+
+      # ps state Z: killed and only waiting for its parent to reap it.
+      def zombie?(pid)
+        out, status = Open3.capture2e("ps", "-o", "stat=", "-p", pid.to_s)
+        status.success? && out.strip.start_with?("Z")
+      rescue SystemCallError
+        false
+      end
+
+      # Prefer the monitor endpoint the VM was actually started with
+      # (persisted in options.yml) so halt still works after a Vagrantfile
+      # edit or under another VAGRANT_HOME.
+      def with_persisted_monitor(options, dir)
+        persisted = persisted_options(dir)
+        return options unless persisted.is_a?(Hash)
+
+        options.merge(persisted.slice(:control_port, :monitor_socket))
+      end
 
-        persisted = YAML.safe_load(File.read(options_file), permitted_classes: [Symbol]) rescue nil
-        return options if persisted.nil? || !persisted.key?(:control_port)
+      # The live instance's runtime dir; for a stopped VM, the layout that
+      # last left an options.yml behind (project-local first).
+      def runtime_dir
+        live = live_instance
+        return live.first if live
+        run_dir.join("options.yml").file? ? run_dir : @tmp_dir.join(@vm_id)
+      end
 
-        options.merge(:control_port => persisted[:control_port])
+      def persisted_options(dir = runtime_dir)
+        # safe_load + File.read (not safe_load_file) so older Psych works too
+        YAML.safe_load(File.read(dir.join("options.yml")), permitted_classes: [Symbol])
+      rescue StandardError
+        nil
       end
 
       # Send a single QEMU monitor command over the control channel (TCP
       # control_port if set, else the unix monitor socket). Best-effort: the
       # socket may already be gone (e.g. QEMU exited from a prior command), so
-      # connection errors are swallowed.
+      # connection errors are swallowed. Returns whether the command was
+      # written; a reply cut short after that still counts as delivered.
       # Drain replies until EOF with a deadline: immediately closing both
       # halves can discard the command on QEMU's hangup event, while an
       # unbounded read can bypass every shutdown timeout below.
       def send_monitor(options, command)
+        sent = false
         monitor_timeout = [[options[:graceful_timeout] || 60, 1].max, 5].min
         if !options[:control_port].nil?
           # start binds the TCP monitor with ipv4=on; avoid an IPv6 localhost
           # attempt (and its refused-connection delay on Windows).
           Socket.tcp("127.0.0.1", options[:control_port], connect_timeout: 5) do |sock|
             sock.print "#{command}\n"
+            sent = true
             sock.close_write
             drain_monitor(sock, monitor_timeout)
           end
         else
-          unix_socket_path = @tmp_dir.join(@vm_id).join("qemu_socket").to_s
+          unix_socket_path = options[:monitor_socket] || @tmp_dir.join(@vm_id).join("qemu_socket").to_s
           Socket.unix(unix_socket_path) do |sock|
             sock.print "#{command}\n"
+            sent = true
             sock.close_write
             drain_monitor(sock, monitor_timeout)
           end
         end
+        sent
       rescue => e
         @logger.debug("monitor command '#{command}' failed: #{e}") if @logger
+        sent
       end
 
       def drain_monitor(sock, timeout)
@@ -317,21 +481,38 @@ module VagrantPlugins
         running?
       end
 
-      def force_kill
-        pid = read_pid
-        return if pid.nil? || pid <= 0
+      # True once QEMU is gone; false while it still runs or where SIGTERM is
+      # not supported (e.g. Windows), leaving SIGKILL to the caller.
+      def terminate(pid)
+        return true if pid.nil? || pid <= 0
+        Process.kill("TERM", pid)
+        !still_running_after?(TERM_TIMEOUT)
+      rescue Errno::ESRCH
+        true
+      rescue Errno::EPERM
+        raise Errors::QemuProcessNotOwned, pid: pid
+      rescue SystemCallError, ArgumentError
+        false
+      end
+
+      # True once the process is gone.
+      def force_kill(pid)
+        return true if pid.nil? || pid <= 0
 
         begin
           Process.kill("KILL", pid)
         rescue Errno::ESRCH
           # Process already gone
+        rescue Errno::EPERM
+          raise Errors::QemuProcessNotOwned, pid: pid
         end
 
         # SIGKILL is asynchronous; callers check running? right after stop.
-        20.times do
-          break unless running?
+        (KILL_TIMEOUT * 10).times do
+          return true unless process_exists?(pid)
           sleep 0.1
         end
+        !process_exists?(pid)
       end
 
       public
@@ -341,29 +522,23 @@ module VagrantPlugins
       def serial_endpoint(default_port = nil)
         return nil if @vm_id.nil?
 
-        runtime_dir = @tmp_dir.join(@vm_id)
-        options_file = runtime_dir.join("options.yml")
-        options = YAML.safe_load(File.read(options_file), permitted_classes: [Symbol]) rescue nil
+        options = persisted_options
+        options = {} unless options.is_a?(Hash)
         port = default_port
-        port = options[:debug_port] if options.is_a?(Hash) && options.key?(:debug_port)
+        port = options[:debug_port] if options.key?(:debug_port)
 
         if port.nil?
-          { type: :unix, path: runtime_dir.join("qemu_socket_serial").to_s }
+          path = options[:serial_socket] || @tmp_dir.join(@vm_id, "qemu_socket_serial").to_s
+          { type: :unix, path: path }
         else
           { type: :tcp, host: "127.0.0.1", port: port }
         end
       end
 
       def get_ssh_port(default_port)
-        id_tmp_dir = @tmp_dir.join(@vm_id)
-        options_file = id_tmp_dir.join("options.yml")
-
+        options = persisted_options
         port = default_port
-        if options_file.file?
-          # safe_load + File.read (not safe_load_file) so older Psych works too
-          options = YAML.safe_load(File.read(options_file), permitted_classes: [Symbol]) rescue nil
-          port = options[:ssh_port] if !options.nil? && options.key?(:ssh_port)
-        end
+        port = options[:ssh_port] if options.is_a?(Hash) && options.key?(:ssh_port)
 
         @ssh_port = port
       end
@@ -419,15 +594,7 @@ module VagrantPlugins
       end
 
       def running?
-        pid = read_pid
-        return false if pid.nil? || pid <= 0
-
-        begin
-          Process.kill(0, pid)
-          true
-        rescue Errno::ESRCH
-          false
-        end
+        !live_instance.nil?
       end
 
       def execute(*cmd, **opts, &block)

data/lib/vagrant-qemu/errors.rb

@@ -45,6 +45,18 @@ module VagrantPlugins
         error_key(:destroy_error)
       end
 
+      class QemuProcessNotOwned < VagrantQEMUError
+        error_key(:qemu_process_not_owned)
+      end
+
+      class PidfileNotReadable < VagrantQEMUError
+        error_key(:pidfile_not_readable)
+      end
+
+      class QemuDidNotExit < VagrantQEMUError
+        error_key(:qemu_did_not_exit)
+      end
+
       class SocketVmnetNotMacos < VagrantQEMUError
         error_key(:socket_vmnet_not_macos)
       end

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end

data/locales/en.yml

@@ -105,6 +105,21 @@ en:
 
         The machine ID has been preserved. Fix the underlying issue and
         run `vagrant destroy` again.
+      qemu_process_not_owned: |-
+        The QEMU process of this VM (PID %{pid}) belongs to another user, so
+        it cannot be stopped from here. Run the command as the user that
+        started the VM, e.g. with `sudo` if `vagrant up` ran under sudo.
+      pidfile_not_readable: |-
+        The QEMU pidfile of this VM belongs to another user:
+
+          %{path}
+
+        This usually means the VM was started with `sudo vagrant up`. Run
+        this command as that user too, e.g. with `sudo`.
+      qemu_did_not_exit: |-
+        QEMU (PID %{pid}) is still running 10 seconds after SIGKILL, so the
+        VM's files were left in place. Check the process, e.g. with
+        `ps -p %{pid}`, and run the command again once it has exited.
       socket_vmnet_not_macos: |-
         net_mode = :socket_vmnet is only supported on macOS (it relies on
         the socket_vmnet daemon and vmnet.framework).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - ppggff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-11-09 00:00:00.000000000 Z
 dependencies: []
 description: Enables Vagrant to manage machines with QEMU.
 email: pgf00a@gmail.com