You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/hypervisor/libvirt_resources.go

311 lines
13 KiB
Go

//go:build libvirt
package hypervisor
import (
"context"
"strings"
"git.luoli.live/root/virt/agent/operation"
"libvirt.org/go/libvirt"
"libvirt.org/go/libvirtxml"
)
type resizeResourceValues struct {
VCPUs uint
MemoryMiB uint64
DiskGiB uint64
BandwidthMbps uint64
}
func resizeFromValues(request ResizeResourcesRequest) resizeResourceValues {
return resizeResourceValues{
VCPUs: request.FromVCPUs, MemoryMiB: request.FromMemoryMiB,
DiskGiB: request.FromDiskGiB, BandwidthMbps: request.FromBandwidthMbps,
}
}
func resizeTargetValues(request ResizeResourcesRequest) resizeResourceValues {
return resizeResourceValues{
VCPUs: request.TargetVCPUs, MemoryMiB: request.TargetMemoryMiB,
DiskGiB: request.TargetDiskGiB, BandwidthMbps: request.TargetBandwidthMbps,
}
}
func expectedResizeFromValues(expected *operation.ExpectedState) resizeResourceValues {
return resizeResourceValues{
VCPUs: expected.FromVCPUs, MemoryMiB: expected.FromMemoryMiB,
DiskGiB: expected.FromDiskGiB, BandwidthMbps: expected.FromBandwidthMbps,
}
}
func expectedResizeTargetValues(expected *operation.ExpectedState) resizeResourceValues {
return resizeResourceValues{
VCPUs: expected.TargetVCPUs, MemoryMiB: expected.TargetMemoryMiB,
DiskGiB: expected.TargetDiskGiB, BandwidthMbps: expected.TargetBandwidthMbps,
}
}
func (l *Libvirt) ResizeResources(ctx context.Context, uuid string, request ResizeResourcesRequest) (_ ResizeResourcesResult, resultErr error) {
mutationStarted := false
defer func() {
if !mutationStarted {
resultErr = operation.MarkNotApplied(resultErr)
}
}()
if err := ValidateResizeResources(request); err != nil {
return ResizeResourcesResult{}, err
}
expected, err := expectedMutationState(ctx, operation.ExpectedResizeResources)
if err != nil {
return ResizeResourcesResult{}, err
}
if !resizeRequestMatchesExpected(
request, expected.FromVCPUs, expected.TargetVCPUs,
expected.FromMemoryMiB, expected.TargetMemoryMiB,
expected.FromDiskGiB, expected.TargetDiskGiB,
expected.FromBandwidthMbps, expected.TargetBandwidthMbps,
) {
return ResizeResourcesResult{}, NewError(ErrConflict, "reconciliation_descriptor_mismatch", "resource resize request does not match its durable reconciliation descriptor", nil)
}
domain, err := l.domainByUUID(ctx, uuid)
if err != nil {
return ResizeResourcesResult{}, err
}
defer domain.Free()
active, err := domain.IsActive()
if err != nil {
return ResizeResourcesResult{}, translateLibvirtError("check resource resize domain activity", err)
}
if active {
return ResizeResourcesResult{}, NewError(ErrConflict, "vm_must_be_shutoff", "virtual machine must be shut off before resizing resources", nil)
}
document, definition, metadata, pool, root, err := l.managedRootContext(domain)
if err != nil {
return ResizeResourcesResult{}, err
}
defer pool.Free()
defer root.Free()
if len(metadata.Snapshots) != 0 {
return ResizeResourcesResult{}, NewError(ErrConflict, "snapshots_present", "resource resize is blocked while managed snapshots exist", nil)
}
if metadata.PendingCleanupVolume != "" {
return ResizeResourcesResult{}, NewError(ErrConflict, "disk_cleanup_pending", "resource resize is blocked while system disk cleanup is pending", nil)
}
if metadata.RescueTemplateID != "" {
return ResizeResourcesResult{}, NewError(ErrConflict, "rescue_active", "resource resize is blocked while rescue boot is staged or active", nil)
}
rootInfo, err := validateQCOW2Volume(root, request.FromDiskGiB*gib)
if err != nil {
return ResizeResourcesResult{}, err
}
if !managedDefinitionMatchesResources(definition, metadata, rootInfo.Capacity, resizeFromValues(request)) {
return ResizeResourcesResult{}, NewError(ErrConflict, "resource_state_changed", "host resources no longer match the requested source values", nil)
}
autostart, err := domain.GetAutostart()
if err != nil {
return ResizeResourcesResult{}, translateLibvirtError("read resource resize domain autostart", err)
}
updatedXML, err := resizeManagedDomainDocument(document, resizeTargetValues(request), expected.TransitionID)
if err != nil {
return ResizeResourcesResult{}, err
}
if err := ctx.Err(); err != nil {
return ResizeResourcesResult{}, err
}
active, err = domain.IsActive()
if err != nil {
return ResizeResourcesResult{}, translateLibvirtError("recheck resource resize domain activity", err)
}
if active {
return ResizeResourcesResult{}, NewError(ErrConflict, "vm_must_be_shutoff", "virtual machine must remain shut off before resizing resources", nil)
}
if request.TargetDiskGiB > request.FromDiskGiB {
mutationStarted = true
if err := root.Resize(request.TargetDiskGiB*gib, 0); err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("grow managed system disk", err))
}
if _, err := validateQCOW2Volume(root, request.TargetDiskGiB*gib); err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(err)
}
}
mutationStarted = true
defined, err := l.conn.DomainDefineXML(updatedXML)
if err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("persist resized VM resources", err))
}
defer defined.Free()
if err := defined.SetAutostart(autostart); err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(mutationLibvirtError("preserve resized domain autostart", err))
}
observedXML, observedMetadata, err := requireManagedDomain(defined)
if err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(err)
}
observedDefinition, _, err := parseManagedDomain(observedXML)
if err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(err)
}
observedRootInfo, err := validateQCOW2Volume(root, request.TargetDiskGiB*gib)
if err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(err)
}
if observedMetadata.ResourcesTransitionID != expected.TransitionID ||
!managedDefinitionMatchesResources(observedDefinition, observedMetadata, observedRootInfo.Capacity, resizeTargetValues(request)) {
return ResizeResourcesResult{}, operation.MarkUncertain(NewError(ErrConflict, "resource_resize_observation_failed", "resized resources did not expose the committed transition", nil))
}
active, err = defined.IsActive()
if err != nil {
return ResizeResourcesResult{}, operation.MarkUncertain(translateLibvirtError("verify resized domain activity", err))
}
if active {
return ResizeResourcesResult{}, operation.MarkUncertain(NewError(ErrConflict, "vm_state_changed", "virtual machine became active during the stopped resource resize", nil))
}
return resizeResourcesResult(uuid, expected, VMStateShutoff), nil
}
func resizeManagedDomainDocument(document string, target resizeResourceValues, transitionID string) (string, error) {
return mutateDomainDocument(document, func(definition *libvirtxml.Domain, metadata *domainMetadataXML) error {
if definition.VCPU == nil || definition.Memory == nil || definition.Devices == nil || len(definition.Devices.Interfaces) != 1 {
return NewError(ErrConflict, "resource_layout_changed", "managed VM resource definition is incomplete", nil)
}
if definition.VCPUs != nil || definition.MaximumMemory != nil ||
(definition.CPU != nil && definition.CPU.Topology != nil) {
return NewError(ErrConflict, "resource_layout_changed", "managed VM resource layout does not support stopped resize", nil)
}
definition.VCPU.Value = target.VCPUs
if definition.VCPU.Current != 0 {
definition.VCPU.Current = target.VCPUs
}
definition.Memory.Value = uint(target.MemoryMiB)
definition.Memory.Unit = "MiB"
if definition.CurrentMemory != nil {
definition.CurrentMemory.Value = uint(target.MemoryMiB)
definition.CurrentMemory.Unit = "MiB"
}
setDomainInterfaceBandwidth(definition, target.BandwidthMbps)
metadata.DiskGiB = target.DiskGiB
metadata.BandwidthMbps = target.BandwidthMbps
metadata.ResourcesTransitionID = transitionID
return nil
})
}
func managedDefinitionMatchesResources(definition *libvirtxml.Domain, metadata *domainMetadataXML, rootCapacity uint64, values resizeResourceValues) bool {
if definition == nil || metadata == nil || definition.VCPU == nil || definition.Memory == nil ||
definition.Devices == nil || len(definition.Devices.Interfaces) != 1 ||
definition.VCPUs != nil || definition.MaximumMemory != nil ||
(definition.CPU != nil && definition.CPU.Topology != nil) {
return false
}
if definition.VCPU.Value != values.VCPUs ||
(definition.VCPU.Current != 0 && definition.VCPU.Current != values.VCPUs) ||
!memoryValueMatchesMiB(definition.Memory.Value, definition.Memory.Unit, values.MemoryMiB) ||
(definition.CurrentMemory != nil && !memoryValueMatchesMiB(
definition.CurrentMemory.Value, definition.CurrentMemory.Unit, values.MemoryMiB,
)) {
return false
}
return rootCapacity == values.DiskGiB*gib && metadata.DiskGiB == values.DiskGiB &&
metadata.BandwidthMbps == values.BandwidthMbps &&
domainInterfaceBandwidthMatches(definition, values.BandwidthMbps)
}
func memoryValueMatchesMiB(value uint, unit string, expected uint64) bool {
switch strings.ToLower(unit) {
case "b", "bytes":
return uint64(value) == expected*1024*1024
case "kb", "kib", "":
return uint64(value) == expected*1024
case "mb", "mib":
return uint64(value) == expected
case "gb", "gib":
return uint64(value)*1024 == expected
default:
return false
}
}
func setDomainInterfaceBandwidth(definition *libvirtxml.Domain, bandwidthMbps uint64) {
rate := bandwidthRateKiBPerSecond(bandwidthMbps)
for index := range definition.Devices.Interfaces {
definition.Devices.Interfaces[index].Bandwidth = &libvirtxml.DomainInterfaceBandwidth{
Inbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
Outbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
}
}
}
func domainInterfaceBandwidthMatches(definition *libvirtxml.Domain, bandwidthMbps uint64) bool {
if definition == nil || definition.Devices == nil || len(definition.Devices.Interfaces) == 0 {
return false
}
rate := bandwidthRateKiBPerSecond(bandwidthMbps)
for _, iface := range definition.Devices.Interfaces {
bandwidth := iface.Bandwidth
if bandwidth == nil || bandwidth.Inbound == nil || bandwidth.Outbound == nil ||
bandwidth.Inbound.Average == nil || bandwidth.Inbound.Peak == nil ||
bandwidth.Outbound.Average == nil || bandwidth.Outbound.Peak == nil ||
*bandwidth.Inbound.Average != rate || *bandwidth.Inbound.Peak != rate ||
*bandwidth.Outbound.Average != rate || *bandwidth.Outbound.Peak != rate {
return false
}
}
return true
}
func bandwidthRateKiBPerSecond(bandwidthMbps uint64) int {
return int((bandwidthMbps*1_000_000 + 8191) / 8192)
}
func resizeResourcesResult(uuid string, expected operation.ExpectedState, status VMStateName) ResizeResourcesResult {
return ResizeResourcesResult{
UUID: uuid,
FromVCPUs: expected.FromVCPUs, TargetVCPUs: expected.TargetVCPUs, AppliedVCPUs: expected.TargetVCPUs,
FromMemoryMiB: expected.FromMemoryMiB, TargetMemoryMiB: expected.TargetMemoryMiB, AppliedMemoryMiB: expected.TargetMemoryMiB,
FromDiskGiB: expected.FromDiskGiB, TargetDiskGiB: expected.TargetDiskGiB, AppliedDiskGiB: expected.TargetDiskGiB,
FromBandwidthMbps: expected.FromBandwidthMbps, TargetBandwidthMbps: expected.TargetBandwidthMbps, AppliedBandwidthMbps: expected.TargetBandwidthMbps,
Status: status, ResourcesResized: true,
}
}
func reconcileResizeObservation(expected *operation.ExpectedState, marker string, definition *libvirtxml.Domain,
metadata *domainMetadataXML, rootCapacity uint64) operation.Resolution {
targetMatches := managedDefinitionMatchesResources(definition, metadata, rootCapacity, expectedResizeTargetValues(expected))
if marker == expected.TransitionID && targetMatches {
return operation.Resolution{Resolved: true, Succeeded: true}
}
fromMatches := managedDefinitionMatchesResources(definition, metadata, rootCapacity, expectedResizeFromValues(expected))
if marker != expected.TransitionID && fromMatches {
return resolvedExpectedFailure("resources_not_committed", "host evidence confirms the resource resize did not commit")
}
return resolvedExpectedFailure("resources_partially_resized", "host evidence shows a partial or conflicting resource resize")
}
func (l *Libvirt) reconcileResizeResources(record operation.Record, domain *libvirt.Domain) (operation.Resolution, error) {
_, definition, metadata, pool, root, err := l.managedRootContext(domain)
if err != nil {
return expectedEvidenceError("resources", err)
}
defer pool.Free()
defer root.Free()
rootInfo, err := validateQCOW2Volume(root, 0)
if err != nil {
return expectedEvidenceError("resources", err)
}
classification := reconcileResizeObservation(record.ExpectedState, metadata.ResourcesTransitionID, definition, metadata, rootInfo.Capacity)
if !classification.Resolved || !classification.Succeeded {
return classification, nil
}
state, _, err := domain.GetState()
if err != nil {
return operation.Resolution{}, translateLibvirtError("reconcile resized domain state", err)
}
result := resizeResourcesResult(record.ResourceID, *record.ExpectedState, mapDomainState(state))
return resolvedExpectedSuccess(result)
}