使用libvirt-go并发执行VM修改与销毁操作的问题及报错分析

我们知道libvirt是线程安全的，但通过两个goroutine并发操作同一VM（修改内存与销毁）会导致状态不确定。请问libvirt如何确定goroutine的执行顺序？

以下是测试代码：

package main

import (
    "fmt"

    "github.com/libvirt/libvirt-go"
)

func main() {
    conn, err := libvirt.NewConnect("qemu:///system")
    if err != nil {
        fmt.Printf("Failed to connect to libvirt: %v\n", err)
        return
    }
    defer conn.Close()

    // 创建新VM
    domainXML := `
        <domain type='kvm'>
            <name>myvm</name>
            <memory unit='KiB'>1048576</memory>
            <vcpu placement='static'>1</vcpu>
            <os>
                <type arch='x86_64' machine='pc-i440fx-2.9'>hvm</type>
                <boot dev='hd'/>
            </os>
            <devices>
                <disk type='file' device='disk'>
                    <driver name='qemu' type='qcow2'/>
                    <source file='path/to/disk'/>
                    <target dev='vda' bus='virtio'/>
                    <address type='pci' domain='0x0000' bus='0x00' slot='0x04' function='0x0'/>
                </disk>
            </devices>
        </domain>`

    dom, err := createVM(conn, domainXML)
    if err != nil {
        fmt.Printf("Failed to create VM: %v\n", err)
        return
    }

    go modifyVMMemory(dom, 2*1024*1024) // 2 GiB

    go deleteVM(dom)

}

func createVM(conn *libvirt.Connect, domainXML string) (*libvirt.Domain, error) {
    dom, err := conn.DomainCreateXML(domainXML, 0)
    if err != nil {
        return nil, err
    }
    return dom, nil
}

func modifyVMMemory(dom *libvirt.Domain, newMemory uint64) error {
    err := dom.SetMaxMemory(newMemory)
    if err != nil {
        return err
    }
    fmt.Print("Modified VM")
    return nil
}

func deleteVM(dom *libvirt.Domain) error {
    err := dom.Destroy()
    if err != nil {
        return err
    }

    err = dom.Undefine()
    if err != nil {
        return err
    }

    fmt.Print("Deleted VM")

    return nil
}

程序首次运行成功，VM被销毁且可重建，但再次运行时出现如下错误：

virError(Code=9, Domain=20, Message='operation failed: domain 'myvm' already exists with uuid 32c25acb-a4c5-4bfd-b2f5-f07b3d9b8eea')

1. libvirt不负责管理Goroutine的执行顺序 #

libvirt的线程安全仅保证多个线程/协程调用其API时不会出现内部数据结构损坏，但它不会主动协调外部并发操作的执行顺序。Goroutine的调度完全由Go运行时决定，libvirt对此没有控制权。

要避免并发操作VM导致的状态不确定，需要在代码中自行实现同步机制：

• 使用sync.WaitGroup确保某个操作完成后再执行另一个
• 使用互斥锁sync.Mutex保护对同一Domain对象的并发访问
• 明确控制协程执行顺序，比如先完成内存修改再触发销毁操作

示例修改（确保先修改内存再销毁）：

import "sync"

func main() {
    // ... 省略连接libvirt、创建VM的代码 ...

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        modifyVMMemory(dom, 2*1024*1024)
    }()
    wg.Wait() // 等待内存修改完成
    go deleteVM(dom)
}

2. 重复运行报错的原因及解决 #

报错提示VM已存在，是因为首次运行时，销毁VM的协程可能在程序退出前未完全执行完Undefine操作，或是并发调度导致Undefine被中断，使得VM定义残留在libvirt中。

解决方法：

• 创建VM前先检查是否存在同名VM，若存在则先销毁并删除定义：

func ensureVMDoesNotExist(conn *libvirt.Connect, name string) error {
    dom, err := conn.LookupDomainByName(name)
    if err != nil {
        if libvirt.IsNotFound(err) {
            return nil
        }
        return err
    }
    // 先销毁运行中的VM
    if state, _, err := dom.GetState(); err == nil && state == libvirt.DOMAIN_RUNNING {
        if err := dom.Destroy(); err != nil {
            return err
        }
    }
    // 删除VM定义
    return dom.Undefine()
}

// 在createVM前调用
func main() {
    // ... 连接libvirt后 ...
    if err := ensureVMDoesNotExist(conn, "myvm"); err != nil {
        fmt.Printf("Failed to clean existing VM: %v\n", err)
        return
    }
    dom, err := createVM(conn, domainXML)
    // ... 后续代码 ...
}

• 程序退出前确保所有协程执行完成，避免资源泄漏：

func main() {
    // ... 创建VM后 ...
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        modifyVMMemory(dom, 2*1024*1024)
    }()
    wg.Wait()

    wg.Add(1)
    go func() {
        defer wg.Done()
        deleteVM(dom)
    }()
    wg.Wait() // 等待销毁完成再退出程序
}

内容的提问来源于stack exchange，提问作者swastik sarkar