src/dma/vendor/github.com/libvirt/libvirt-go/domain.go

   1 /*
   2  * This file is part of the libvirt-go project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * Copyright (c) 2013 Alex Zorin
  23  * Copyright (C) 2016 Red Hat, Inc.
  24  *
  25  */
  26
  27 package libvirt
  28
  29 /*
  30 #cgo pkg-config: libvirt
  31 #include <stdlib.h>
  32 #include "domain_wrapper.h"
  33 #include "connect_wrapper.h"
  34 */
  35 import "C"
  36
  37 import (
  38         "fmt"
  39         "os"
  40         "reflect"
  41         "strconv"
  42         "strings"
  43         "unsafe"
  44 )
  45
  46 const (
  47         DOMAIN_SEND_KEY_MAX_KEYS = uint32(C.VIR_DOMAIN_SEND_KEY_MAX_KEYS)
  48 )
  49
  50 type DomainState int
  51
  52 const (
  53         DOMAIN_NOSTATE     = DomainState(C.VIR_DOMAIN_NOSTATE)
  54         DOMAIN_RUNNING     = DomainState(C.VIR_DOMAIN_RUNNING)
  55         DOMAIN_BLOCKED     = DomainState(C.VIR_DOMAIN_BLOCKED)
  56         DOMAIN_PAUSED      = DomainState(C.VIR_DOMAIN_PAUSED)
  57         DOMAIN_SHUTDOWN    = DomainState(C.VIR_DOMAIN_SHUTDOWN)
  58         DOMAIN_CRASHED     = DomainState(C.VIR_DOMAIN_CRASHED)
  59         DOMAIN_PMSUSPENDED = DomainState(C.VIR_DOMAIN_PMSUSPENDED)
  60         DOMAIN_SHUTOFF     = DomainState(C.VIR_DOMAIN_SHUTOFF)
  61 )
  62
  63 type DomainMetadataType int
  64
  65 const (
  66         DOMAIN_METADATA_DESCRIPTION = DomainMetadataType(C.VIR_DOMAIN_METADATA_DESCRIPTION)
  67         DOMAIN_METADATA_TITLE       = DomainMetadataType(C.VIR_DOMAIN_METADATA_TITLE)
  68         DOMAIN_METADATA_ELEMENT     = DomainMetadataType(C.VIR_DOMAIN_METADATA_ELEMENT)
  69 )
  70
  71 type DomainVcpuFlags int
  72
  73 const (
  74         DOMAIN_VCPU_CONFIG       = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_CONFIG)
  75         DOMAIN_VCPU_CURRENT      = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_CURRENT)
  76         DOMAIN_VCPU_LIVE         = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_LIVE)
  77         DOMAIN_VCPU_MAXIMUM      = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_MAXIMUM)
  78         DOMAIN_VCPU_GUEST        = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_GUEST)
  79         DOMAIN_VCPU_HOTPLUGGABLE = DomainVcpuFlags(C.VIR_DOMAIN_VCPU_HOTPLUGGABLE)
  80 )
  81
  82 type DomainModificationImpact int
  83
  84 const (
  85         DOMAIN_AFFECT_CONFIG  = DomainModificationImpact(C.VIR_DOMAIN_AFFECT_CONFIG)
  86         DOMAIN_AFFECT_CURRENT = DomainModificationImpact(C.VIR_DOMAIN_AFFECT_CURRENT)
  87         DOMAIN_AFFECT_LIVE    = DomainModificationImpact(C.VIR_DOMAIN_AFFECT_LIVE)
  88 )
  89
  90 type DomainMemoryModFlags int
  91
  92 const (
  93         DOMAIN_MEM_CONFIG  = DomainMemoryModFlags(C.VIR_DOMAIN_MEM_CONFIG)
  94         DOMAIN_MEM_CURRENT = DomainMemoryModFlags(C.VIR_DOMAIN_MEM_CURRENT)
  95         DOMAIN_MEM_LIVE    = DomainMemoryModFlags(C.VIR_DOMAIN_MEM_LIVE)
  96         DOMAIN_MEM_MAXIMUM = DomainMemoryModFlags(C.VIR_DOMAIN_MEM_MAXIMUM)
  97 )
  98
  99 type DomainDestroyFlags int
 100
 101 const (
 102         DOMAIN_DESTROY_DEFAULT  = DomainDestroyFlags(C.VIR_DOMAIN_DESTROY_DEFAULT)
 103         DOMAIN_DESTROY_GRACEFUL = DomainDestroyFlags(C.VIR_DOMAIN_DESTROY_GRACEFUL)
 104 )
 105
 106 type DomainShutdownFlags int
 107
 108 const (
 109         DOMAIN_SHUTDOWN_DEFAULT        = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_DEFAULT)
 110         DOMAIN_SHUTDOWN_ACPI_POWER_BTN = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN)
 111         DOMAIN_SHUTDOWN_GUEST_AGENT    = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_GUEST_AGENT)
 112         DOMAIN_SHUTDOWN_INITCTL        = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_INITCTL)
 113         DOMAIN_SHUTDOWN_SIGNAL         = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_SIGNAL)
 114         DOMAIN_SHUTDOWN_PARAVIRT       = DomainShutdownFlags(C.VIR_DOMAIN_SHUTDOWN_PARAVIRT)
 115 )
 116
 117 type DomainUndefineFlagsValues int
 118
 119 const (
 120         DOMAIN_UNDEFINE_MANAGED_SAVE       = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE)       // Also remove any managed save
 121         DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA) // If last use of domain, then also remove any snapshot metadata
 122         DOMAIN_UNDEFINE_NVRAM              = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_NVRAM)              // Also remove any nvram file
 123         DOMAIN_UNDEFINE_KEEP_NVRAM         = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM)         // Keep nvram file
 124 )
 125
 126 type DomainDeviceModifyFlags int
 127
 128 const (
 129         DOMAIN_DEVICE_MODIFY_CONFIG  = DomainDeviceModifyFlags(C.VIR_DOMAIN_DEVICE_MODIFY_CONFIG)
 130         DOMAIN_DEVICE_MODIFY_CURRENT = DomainDeviceModifyFlags(C.VIR_DOMAIN_DEVICE_MODIFY_CURRENT)
 131         DOMAIN_DEVICE_MODIFY_LIVE    = DomainDeviceModifyFlags(C.VIR_DOMAIN_DEVICE_MODIFY_LIVE)
 132         DOMAIN_DEVICE_MODIFY_FORCE   = DomainDeviceModifyFlags(C.VIR_DOMAIN_DEVICE_MODIFY_FORCE)
 133 )
 134
 135 type DomainCreateFlags int
 136
 137 const (
 138         DOMAIN_NONE               = DomainCreateFlags(C.VIR_DOMAIN_NONE)
 139         DOMAIN_START_PAUSED       = DomainCreateFlags(C.VIR_DOMAIN_START_PAUSED)
 140         DOMAIN_START_AUTODESTROY  = DomainCreateFlags(C.VIR_DOMAIN_START_AUTODESTROY)
 141         DOMAIN_START_BYPASS_CACHE = DomainCreateFlags(C.VIR_DOMAIN_START_BYPASS_CACHE)
 142         DOMAIN_START_FORCE_BOOT   = DomainCreateFlags(C.VIR_DOMAIN_START_FORCE_BOOT)
 143         DOMAIN_START_VALIDATE     = DomainCreateFlags(C.VIR_DOMAIN_START_VALIDATE)
 144 )
 145
 146 const DOMAIN_MEMORY_PARAM_UNLIMITED = C.VIR_DOMAIN_MEMORY_PARAM_UNLIMITED
 147
 148 type DomainEventType int
 149
 150 const (
 151         DOMAIN_EVENT_DEFINED     = DomainEventType(C.VIR_DOMAIN_EVENT_DEFINED)
 152         DOMAIN_EVENT_UNDEFINED   = DomainEventType(C.VIR_DOMAIN_EVENT_UNDEFINED)
 153         DOMAIN_EVENT_STARTED     = DomainEventType(C.VIR_DOMAIN_EVENT_STARTED)
 154         DOMAIN_EVENT_SUSPENDED   = DomainEventType(C.VIR_DOMAIN_EVENT_SUSPENDED)
 155         DOMAIN_EVENT_RESUMED     = DomainEventType(C.VIR_DOMAIN_EVENT_RESUMED)
 156         DOMAIN_EVENT_STOPPED     = DomainEventType(C.VIR_DOMAIN_EVENT_STOPPED)
 157         DOMAIN_EVENT_SHUTDOWN    = DomainEventType(C.VIR_DOMAIN_EVENT_SHUTDOWN)
 158         DOMAIN_EVENT_PMSUSPENDED = DomainEventType(C.VIR_DOMAIN_EVENT_PMSUSPENDED)
 159         DOMAIN_EVENT_CRASHED     = DomainEventType(C.VIR_DOMAIN_EVENT_CRASHED)
 160 )
 161
 162 type DomainEventWatchdogAction int
 163
 164 // The action that is to be taken due to the watchdog device firing
 165 const (
 166         // No action, watchdog ignored
 167         DOMAIN_EVENT_WATCHDOG_NONE = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_NONE)
 168
 169         // Guest CPUs are paused
 170         DOMAIN_EVENT_WATCHDOG_PAUSE = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_PAUSE)
 171
 172         // Guest CPUs are reset
 173         DOMAIN_EVENT_WATCHDOG_RESET = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_RESET)
 174
 175         // Guest is forcibly powered off
 176         DOMAIN_EVENT_WATCHDOG_POWEROFF = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF)
 177
 178         // Guest is requested to gracefully shutdown
 179         DOMAIN_EVENT_WATCHDOG_SHUTDOWN = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN)
 180
 181         // No action, a debug message logged
 182         DOMAIN_EVENT_WATCHDOG_DEBUG = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_DEBUG)
 183
 184         // Inject a non-maskable interrupt into guest
 185         DOMAIN_EVENT_WATCHDOG_INJECTNMI = DomainEventWatchdogAction(C.VIR_DOMAIN_EVENT_WATCHDOG_INJECTNMI)
 186 )
 187
 188 type DomainEventIOErrorAction int
 189
 190 // The action that is to be taken due to an IO error occurring
 191 const (
 192         // No action, IO error ignored
 193         DOMAIN_EVENT_IO_ERROR_NONE = DomainEventIOErrorAction(C.VIR_DOMAIN_EVENT_IO_ERROR_NONE)
 194
 195         // Guest CPUs are paused
 196         DOMAIN_EVENT_IO_ERROR_PAUSE = DomainEventIOErrorAction(C.VIR_DOMAIN_EVENT_IO_ERROR_PAUSE)
 197
 198         // IO error reported to guest OS
 199         DOMAIN_EVENT_IO_ERROR_REPORT = DomainEventIOErrorAction(C.VIR_DOMAIN_EVENT_IO_ERROR_REPORT)
 200 )
 201
 202 type DomainEventGraphicsPhase int
 203
 204 // The phase of the graphics client connection
 205 const (
 206         // Initial socket connection established
 207         DOMAIN_EVENT_GRAPHICS_CONNECT = DomainEventGraphicsPhase(C.VIR_DOMAIN_EVENT_GRAPHICS_CONNECT)
 208
 209         // Authentication & setup completed
 210         DOMAIN_EVENT_GRAPHICS_INITIALIZE = DomainEventGraphicsPhase(C.VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE)
 211
 212         // Final socket disconnection
 213         DOMAIN_EVENT_GRAPHICS_DISCONNECT = DomainEventGraphicsPhase(C.VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT)
 214 )
 215
 216 type DomainEventGraphicsAddressType int
 217
 218 const (
 219         // IPv4 address
 220         DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = DomainEventGraphicsAddressType(C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4)
 221
 222         // IPv6 address
 223         DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = DomainEventGraphicsAddressType(C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6)
 224
 225         // UNIX socket path
 226         DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = DomainEventGraphicsAddressType(C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX)
 227 )
 228
 229 type DomainBlockJobType int
 230
 231 const (
 232         // Placeholder
 233         DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = DomainBlockJobType(C.VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN)
 234
 235         // Block Pull (virDomainBlockPull, or virDomainBlockRebase without
 236         // flags), job ends on completion
 237         DOMAIN_BLOCK_JOB_TYPE_PULL = DomainBlockJobType(C.VIR_DOMAIN_BLOCK_JOB_TYPE_PULL)
 238
 239         // Block Copy (virDomainBlockCopy, or virDomainBlockRebase with
 240         // flags), job exists as long as mirroring is active
 241         DOMAIN_BLOCK_JOB_TYPE_COPY = DomainBlockJobType(C.VIR_DOMAIN_BLOCK_JOB_TYPE_COPY)
 242
 243         // Block Commit (virDomainBlockCommit without flags), job ends on
 244         // completion
 245         DOMAIN_BLOCK_JOB_TYPE_COMMIT = DomainBlockJobType(C.VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT)
 246
 247         // Active Block Commit (virDomainBlockCommit with flags), job
 248         // exists as long as sync is active
 249         DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = DomainBlockJobType(C.VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT)
 250 )
 251
 252 type DomainRunningReason int
 253
 254 const (
 255         DOMAIN_RUNNING_UNKNOWN            = DomainRunningReason(C.VIR_DOMAIN_RUNNING_UNKNOWN)
 256         DOMAIN_RUNNING_BOOTED             = DomainRunningReason(C.VIR_DOMAIN_RUNNING_BOOTED)             /* normal startup from boot */
 257         DOMAIN_RUNNING_MIGRATED           = DomainRunningReason(C.VIR_DOMAIN_RUNNING_MIGRATED)           /* migrated from another host */
 258         DOMAIN_RUNNING_RESTORED           = DomainRunningReason(C.VIR_DOMAIN_RUNNING_RESTORED)           /* restored from a state file */
 259         DOMAIN_RUNNING_FROM_SNAPSHOT      = DomainRunningReason(C.VIR_DOMAIN_RUNNING_FROM_SNAPSHOT)      /* restored from snapshot */
 260         DOMAIN_RUNNING_UNPAUSED           = DomainRunningReason(C.VIR_DOMAIN_RUNNING_UNPAUSED)           /* returned from paused state */
 261         DOMAIN_RUNNING_MIGRATION_CANCELED = DomainRunningReason(C.VIR_DOMAIN_RUNNING_MIGRATION_CANCELED) /* returned from migration */
 262         DOMAIN_RUNNING_SAVE_CANCELED      = DomainRunningReason(C.VIR_DOMAIN_RUNNING_SAVE_CANCELED)      /* returned from failed save process */
 263         DOMAIN_RUNNING_WAKEUP             = DomainRunningReason(C.VIR_DOMAIN_RUNNING_WAKEUP)             /* returned from pmsuspended due to wakeup event */
 264         DOMAIN_RUNNING_CRASHED            = DomainRunningReason(C.VIR_DOMAIN_RUNNING_CRASHED)            /* resumed from crashed */
 265         DOMAIN_RUNNING_POSTCOPY           = DomainRunningReason(C.VIR_DOMAIN_RUNNING_POSTCOPY)           /* running in post-copy migration mode */
 266 )
 267
 268 type DomainPausedReason int
 269
 270 const (
 271         DOMAIN_PAUSED_UNKNOWN         = DomainPausedReason(C.VIR_DOMAIN_PAUSED_UNKNOWN)         /* the reason is unknown */
 272         DOMAIN_PAUSED_USER            = DomainPausedReason(C.VIR_DOMAIN_PAUSED_USER)            /* paused on user request */
 273         DOMAIN_PAUSED_MIGRATION       = DomainPausedReason(C.VIR_DOMAIN_PAUSED_MIGRATION)       /* paused for offline migration */
 274         DOMAIN_PAUSED_SAVE            = DomainPausedReason(C.VIR_DOMAIN_PAUSED_SAVE)            /* paused for save */
 275         DOMAIN_PAUSED_DUMP            = DomainPausedReason(C.VIR_DOMAIN_PAUSED_DUMP)            /* paused for offline core dump */
 276         DOMAIN_PAUSED_IOERROR         = DomainPausedReason(C.VIR_DOMAIN_PAUSED_IOERROR)         /* paused due to a disk I/O error */
 277         DOMAIN_PAUSED_WATCHDOG        = DomainPausedReason(C.VIR_DOMAIN_PAUSED_WATCHDOG)        /* paused due to a watchdog event */
 278         DOMAIN_PAUSED_FROM_SNAPSHOT   = DomainPausedReason(C.VIR_DOMAIN_PAUSED_FROM_SNAPSHOT)   /* paused after restoring from snapshot */
 279         DOMAIN_PAUSED_SHUTTING_DOWN   = DomainPausedReason(C.VIR_DOMAIN_PAUSED_SHUTTING_DOWN)   /* paused during shutdown process */
 280         DOMAIN_PAUSED_SNAPSHOT        = DomainPausedReason(C.VIR_DOMAIN_PAUSED_SNAPSHOT)        /* paused while creating a snapshot */
 281         DOMAIN_PAUSED_CRASHED         = DomainPausedReason(C.VIR_DOMAIN_PAUSED_CRASHED)         /* paused due to a guest crash */
 282         DOMAIN_PAUSED_STARTING_UP     = DomainPausedReason(C.VIR_DOMAIN_PAUSED_STARTING_UP)     /* the domainis being started */
 283         DOMAIN_PAUSED_POSTCOPY        = DomainPausedReason(C.VIR_DOMAIN_PAUSED_POSTCOPY)        /* paused for post-copy migration */
 284         DOMAIN_PAUSED_POSTCOPY_FAILED = DomainPausedReason(C.VIR_DOMAIN_PAUSED_POSTCOPY_FAILED) /* paused after failed post-copy */
 285 )
 286
 287 type DomainXMLFlags int
 288
 289 const (
 290         DOMAIN_XML_SECURE     = DomainXMLFlags(C.VIR_DOMAIN_XML_SECURE)     /* dump security sensitive information too */
 291         DOMAIN_XML_INACTIVE   = DomainXMLFlags(C.VIR_DOMAIN_XML_INACTIVE)   /* dump inactive domain information */
 292         DOMAIN_XML_UPDATE_CPU = DomainXMLFlags(C.VIR_DOMAIN_XML_UPDATE_CPU) /* update guest CPU requirements according to host CPU */
 293         DOMAIN_XML_MIGRATABLE = DomainXMLFlags(C.VIR_DOMAIN_XML_MIGRATABLE) /* dump XML suitable for migration */
 294 )
 295
 296 type DomainEventDefinedDetailType int
 297
 298 const (
 299         DOMAIN_EVENT_DEFINED_ADDED         = DomainEventDefinedDetailType(C.VIR_DOMAIN_EVENT_DEFINED_ADDED)
 300         DOMAIN_EVENT_DEFINED_UPDATED       = DomainEventDefinedDetailType(C.VIR_DOMAIN_EVENT_DEFINED_UPDATED)
 301         DOMAIN_EVENT_DEFINED_RENAMED       = DomainEventDefinedDetailType(C.VIR_DOMAIN_EVENT_DEFINED_RENAMED)
 302         DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT = DomainEventDefinedDetailType(C.VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT)
 303 )
 304
 305 type DomainEventUndefinedDetailType int
 306
 307 const (
 308         DOMAIN_EVENT_UNDEFINED_REMOVED = DomainEventUndefinedDetailType(C.VIR_DOMAIN_EVENT_UNDEFINED_REMOVED)
 309         DOMAIN_EVENT_UNDEFINED_RENAMED = DomainEventUndefinedDetailType(C.VIR_DOMAIN_EVENT_UNDEFINED_RENAMED)
 310 )
 311
 312 type DomainEventStartedDetailType int
 313
 314 const (
 315         DOMAIN_EVENT_STARTED_BOOTED        = DomainEventStartedDetailType(C.VIR_DOMAIN_EVENT_STARTED_BOOTED)
 316         DOMAIN_EVENT_STARTED_MIGRATED      = DomainEventStartedDetailType(C.VIR_DOMAIN_EVENT_STARTED_MIGRATED)
 317         DOMAIN_EVENT_STARTED_RESTORED      = DomainEventStartedDetailType(C.VIR_DOMAIN_EVENT_STARTED_RESTORED)
 318         DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = DomainEventStartedDetailType(C.VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT)
 319         DOMAIN_EVENT_STARTED_WAKEUP        = DomainEventStartedDetailType(C.VIR_DOMAIN_EVENT_STARTED_WAKEUP)
 320 )
 321
 322 type DomainEventSuspendedDetailType int
 323
 324 const (
 325         DOMAIN_EVENT_SUSPENDED_PAUSED          = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_PAUSED)
 326         DOMAIN_EVENT_SUSPENDED_MIGRATED        = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED)
 327         DOMAIN_EVENT_SUSPENDED_IOERROR         = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_IOERROR)
 328         DOMAIN_EVENT_SUSPENDED_WATCHDOG        = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG)
 329         DOMAIN_EVENT_SUSPENDED_RESTORED        = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_RESTORED)
 330         DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT   = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT)
 331         DOMAIN_EVENT_SUSPENDED_API_ERROR       = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR)
 332         DOMAIN_EVENT_SUSPENDED_POSTCOPY        = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY)
 333         DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED = DomainEventSuspendedDetailType(C.VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED)
 334 )
 335
 336 type DomainEventResumedDetailType int
 337
 338 const (
 339         DOMAIN_EVENT_RESUMED_UNPAUSED      = DomainEventResumedDetailType(C.VIR_DOMAIN_EVENT_RESUMED_UNPAUSED)
 340         DOMAIN_EVENT_RESUMED_MIGRATED      = DomainEventResumedDetailType(C.VIR_DOMAIN_EVENT_RESUMED_MIGRATED)
 341         DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = DomainEventResumedDetailType(C.VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT)
 342         DOMAIN_EVENT_RESUMED_POSTCOPY      = DomainEventResumedDetailType(C.VIR_DOMAIN_EVENT_RESUMED_POSTCOPY)
 343 )
 344
 345 type DomainEventStoppedDetailType int
 346
 347 const (
 348         DOMAIN_EVENT_STOPPED_SHUTDOWN      = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN)
 349         DOMAIN_EVENT_STOPPED_DESTROYED     = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_DESTROYED)
 350         DOMAIN_EVENT_STOPPED_CRASHED       = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_CRASHED)
 351         DOMAIN_EVENT_STOPPED_MIGRATED      = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_MIGRATED)
 352         DOMAIN_EVENT_STOPPED_SAVED         = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_SAVED)
 353         DOMAIN_EVENT_STOPPED_FAILED        = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_FAILED)
 354         DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = DomainEventStoppedDetailType(C.VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT)
 355 )
 356
 357 type DomainEventShutdownDetailType int
 358
 359 const (
 360         DOMAIN_EVENT_SHUTDOWN_FINISHED = DomainEventShutdownDetailType(C.VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED)
 361         DOMAIN_EVENT_SHUTDOWN_GUEST    = DomainEventShutdownDetailType(C.VIR_DOMAIN_EVENT_SHUTDOWN_GUEST)
 362         DOMAIN_EVENT_SHUTDOWN_HOST     = DomainEventShutdownDetailType(C.VIR_DOMAIN_EVENT_SHUTDOWN_HOST)
 363 )
 364
 365 type DomainMemoryStatTags int
 366
 367 const (
 368         DOMAIN_MEMORY_STAT_LAST           = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR)
 369         DOMAIN_MEMORY_STAT_SWAP_IN        = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_IN)
 370         DOMAIN_MEMORY_STAT_SWAP_OUT       = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_OUT)
 371         DOMAIN_MEMORY_STAT_MAJOR_FAULT    = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT)
 372         DOMAIN_MEMORY_STAT_MINOR_FAULT    = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT)
 373         DOMAIN_MEMORY_STAT_UNUSED         = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_UNUSED)
 374         DOMAIN_MEMORY_STAT_AVAILABLE      = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_AVAILABLE)
 375         DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON)
 376         DOMAIN_MEMORY_STAT_RSS            = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_RSS)
 377         DOMAIN_MEMORY_STAT_USABLE         = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_USABLE)
 378         DOMAIN_MEMORY_STAT_LAST_UPDATE    = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE)
 379         DOMAIN_MEMORY_STAT_DISK_CACHES    = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_DISK_CACHES)
 380         DOMAIN_MEMORY_STAT_NR             = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR)
 381 )
 382
 383 type DomainCPUStatsTags string
 384
 385 const (
 386         DOMAIN_CPU_STATS_CPUTIME    = DomainCPUStatsTags(C.VIR_DOMAIN_CPU_STATS_CPUTIME)
 387         DOMAIN_CPU_STATS_SYSTEMTIME = DomainCPUStatsTags(C.VIR_DOMAIN_CPU_STATS_SYSTEMTIME)
 388         DOMAIN_CPU_STATS_USERTIME   = DomainCPUStatsTags(C.VIR_DOMAIN_CPU_STATS_USERTIME)
 389         DOMAIN_CPU_STATS_VCPUTIME   = DomainCPUStatsTags(C.VIR_DOMAIN_CPU_STATS_VCPUTIME)
 390 )
 391
 392 type DomainInterfaceAddressesSource int
 393
 394 const (
 395         DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = DomainInterfaceAddressesSource(C.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE)
 396         DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = DomainInterfaceAddressesSource(C.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT)
 397         DOMAIN_INTERFACE_ADDRESSES_SRC_ARP   = DomainInterfaceAddressesSource(C.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP)
 398 )
 399
 400 type KeycodeSet int
 401
 402 const (
 403         KEYCODE_SET_LINUX  = KeycodeSet(C.VIR_KEYCODE_SET_LINUX)
 404         KEYCODE_SET_XT     = KeycodeSet(C.VIR_KEYCODE_SET_XT)
 405         KEYCODE_SET_ATSET1 = KeycodeSet(C.VIR_KEYCODE_SET_ATSET1)
 406         KEYCODE_SET_ATSET2 = KeycodeSet(C.VIR_KEYCODE_SET_ATSET2)
 407         KEYCODE_SET_ATSET3 = KeycodeSet(C.VIR_KEYCODE_SET_ATSET3)
 408         KEYCODE_SET_OSX    = KeycodeSet(C.VIR_KEYCODE_SET_OSX)
 409         KEYCODE_SET_XT_KBD = KeycodeSet(C.VIR_KEYCODE_SET_XT_KBD)
 410         KEYCODE_SET_USB    = KeycodeSet(C.VIR_KEYCODE_SET_USB)
 411         KEYCODE_SET_WIN32  = KeycodeSet(C.VIR_KEYCODE_SET_WIN32)
 412         KEYCODE_SET_RFB    = KeycodeSet(C.VIR_KEYCODE_SET_RFB)
 413         KEYCODE_SET_QNUM   = KeycodeSet(C.VIR_KEYCODE_SET_QNUM)
 414 )
 415
 416 type ConnectDomainEventBlockJobStatus int
 417
 418 const (
 419         DOMAIN_BLOCK_JOB_COMPLETED = ConnectDomainEventBlockJobStatus(C.VIR_DOMAIN_BLOCK_JOB_COMPLETED)
 420         DOMAIN_BLOCK_JOB_FAILED    = ConnectDomainEventBlockJobStatus(C.VIR_DOMAIN_BLOCK_JOB_FAILED)
 421         DOMAIN_BLOCK_JOB_CANCELED  = ConnectDomainEventBlockJobStatus(C.VIR_DOMAIN_BLOCK_JOB_CANCELED)
 422         DOMAIN_BLOCK_JOB_READY     = ConnectDomainEventBlockJobStatus(C.VIR_DOMAIN_BLOCK_JOB_READY)
 423 )
 424
 425 type ConnectDomainEventDiskChangeReason int
 426
 427 const (
 428         // OldSrcPath is set
 429         DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = ConnectDomainEventDiskChangeReason(C.VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START)
 430         DOMAIN_EVENT_DISK_DROP_MISSING_ON_START   = ConnectDomainEventDiskChangeReason(C.VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START)
 431 )
 432
 433 type ConnectDomainEventTrayChangeReason int
 434
 435 const (
 436         DOMAIN_EVENT_TRAY_CHANGE_OPEN  = ConnectDomainEventTrayChangeReason(C.VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN)
 437         DOMAIN_EVENT_TRAY_CHANGE_CLOSE = ConnectDomainEventTrayChangeReason(C.VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE)
 438 )
 439
 440 type DomainProcessSignal int
 441
 442 const (
 443         DOMAIN_PROCESS_SIGNAL_NOP  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_NOP)
 444         DOMAIN_PROCESS_SIGNAL_HUP  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_HUP)
 445         DOMAIN_PROCESS_SIGNAL_INT  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_INT)
 446         DOMAIN_PROCESS_SIGNAL_QUIT = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_QUIT)
 447         DOMAIN_PROCESS_SIGNAL_ILL  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_ILL)
 448         DOMAIN_PROCESS_SIGNAL_TRAP = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_TRAP)
 449         DOMAIN_PROCESS_SIGNAL_ABRT = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_ABRT)
 450         DOMAIN_PROCESS_SIGNAL_BUS  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_BUS)
 451         DOMAIN_PROCESS_SIGNAL_FPE  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_FPE)
 452         DOMAIN_PROCESS_SIGNAL_KILL = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_KILL)
 453
 454         DOMAIN_PROCESS_SIGNAL_USR1   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_USR1)
 455         DOMAIN_PROCESS_SIGNAL_SEGV   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_SEGV)
 456         DOMAIN_PROCESS_SIGNAL_USR2   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_USR2)
 457         DOMAIN_PROCESS_SIGNAL_PIPE   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_PIPE)
 458         DOMAIN_PROCESS_SIGNAL_ALRM   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_ALRM)
 459         DOMAIN_PROCESS_SIGNAL_TERM   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_TERM)
 460         DOMAIN_PROCESS_SIGNAL_STKFLT = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_STKFLT)
 461         DOMAIN_PROCESS_SIGNAL_CHLD   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_CHLD)
 462         DOMAIN_PROCESS_SIGNAL_CONT   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_CONT)
 463         DOMAIN_PROCESS_SIGNAL_STOP   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_STOP)
 464
 465         DOMAIN_PROCESS_SIGNAL_TSTP   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_TSTP)
 466         DOMAIN_PROCESS_SIGNAL_TTIN   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_TTIN)
 467         DOMAIN_PROCESS_SIGNAL_TTOU   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_TTOU)
 468         DOMAIN_PROCESS_SIGNAL_URG    = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_URG)
 469         DOMAIN_PROCESS_SIGNAL_XCPU   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_XCPU)
 470         DOMAIN_PROCESS_SIGNAL_XFSZ   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_XFSZ)
 471         DOMAIN_PROCESS_SIGNAL_VTALRM = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_VTALRM)
 472         DOMAIN_PROCESS_SIGNAL_PROF   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_PROF)
 473         DOMAIN_PROCESS_SIGNAL_WINCH  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_WINCH)
 474         DOMAIN_PROCESS_SIGNAL_POLL   = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_POLL)
 475
 476         DOMAIN_PROCESS_SIGNAL_PWR = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_PWR)
 477         DOMAIN_PROCESS_SIGNAL_SYS = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_SYS)
 478         DOMAIN_PROCESS_SIGNAL_RT0 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT0)
 479         DOMAIN_PROCESS_SIGNAL_RT1 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT1)
 480         DOMAIN_PROCESS_SIGNAL_RT2 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT2)
 481         DOMAIN_PROCESS_SIGNAL_RT3 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT3)
 482         DOMAIN_PROCESS_SIGNAL_RT4 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT4)
 483         DOMAIN_PROCESS_SIGNAL_RT5 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT5)
 484         DOMAIN_PROCESS_SIGNAL_RT6 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT6)
 485         DOMAIN_PROCESS_SIGNAL_RT7 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT7)
 486
 487         DOMAIN_PROCESS_SIGNAL_RT8  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT8)
 488         DOMAIN_PROCESS_SIGNAL_RT9  = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT9)
 489         DOMAIN_PROCESS_SIGNAL_RT10 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT10)
 490         DOMAIN_PROCESS_SIGNAL_RT11 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT11)
 491         DOMAIN_PROCESS_SIGNAL_RT12 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT12)
 492         DOMAIN_PROCESS_SIGNAL_RT13 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT13)
 493         DOMAIN_PROCESS_SIGNAL_RT14 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT14)
 494         DOMAIN_PROCESS_SIGNAL_RT15 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT15)
 495         DOMAIN_PROCESS_SIGNAL_RT16 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT16)
 496         DOMAIN_PROCESS_SIGNAL_RT17 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT17)
 497         DOMAIN_PROCESS_SIGNAL_RT18 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT18)
 498
 499         DOMAIN_PROCESS_SIGNAL_RT19 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT19)
 500         DOMAIN_PROCESS_SIGNAL_RT20 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT20)
 501         DOMAIN_PROCESS_SIGNAL_RT21 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT21)
 502         DOMAIN_PROCESS_SIGNAL_RT22 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT22)
 503         DOMAIN_PROCESS_SIGNAL_RT23 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT23)
 504         DOMAIN_PROCESS_SIGNAL_RT24 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT24)
 505         DOMAIN_PROCESS_SIGNAL_RT25 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT25)
 506         DOMAIN_PROCESS_SIGNAL_RT26 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT26)
 507         DOMAIN_PROCESS_SIGNAL_RT27 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT27)
 508
 509         DOMAIN_PROCESS_SIGNAL_RT28 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT28)
 510         DOMAIN_PROCESS_SIGNAL_RT29 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT29)
 511         DOMAIN_PROCESS_SIGNAL_RT30 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT30)
 512         DOMAIN_PROCESS_SIGNAL_RT31 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT31)
 513         DOMAIN_PROCESS_SIGNAL_RT32 = DomainProcessSignal(C.VIR_DOMAIN_PROCESS_SIGNAL_RT32)
 514 )
 515
 516 type DomainBlockedReason int
 517
 518 const (
 519         DOMAIN_BLOCKED_UNKNOWN = DomainBlockedReason(C.VIR_DOMAIN_BLOCKED_UNKNOWN)
 520 )
 521
 522 type DomainControlState int
 523
 524 const (
 525         DOMAIN_CONTROL_OK       = DomainControlState(C.VIR_DOMAIN_CONTROL_OK)
 526         DOMAIN_CONTROL_JOB      = DomainControlState(C.VIR_DOMAIN_CONTROL_JOB)
 527         DOMAIN_CONTROL_OCCUPIED = DomainControlState(C.VIR_DOMAIN_CONTROL_OCCUPIED)
 528         DOMAIN_CONTROL_ERROR    = DomainControlState(C.VIR_DOMAIN_CONTROL_ERROR)
 529 )
 530
 531 type DomainControlErrorReason int
 532
 533 const (
 534         DOMAIN_CONTROL_ERROR_REASON_NONE     = DomainControlErrorReason(C.VIR_DOMAIN_CONTROL_ERROR_REASON_NONE)
 535         DOMAIN_CONTROL_ERROR_REASON_UNKNOWN  = DomainControlErrorReason(C.VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN)
 536         DOMAIN_CONTROL_ERROR_REASON_MONITOR  = DomainControlErrorReason(C.VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR)
 537         DOMAIN_CONTROL_ERROR_REASON_INTERNAL = DomainControlErrorReason(C.VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL)
 538 )
 539
 540 type DomainCrashedReason int
 541
 542 const (
 543         DOMAIN_CRASHED_UNKNOWN  = DomainCrashedReason(C.VIR_DOMAIN_CRASHED_UNKNOWN)
 544         DOMAIN_CRASHED_PANICKED = DomainCrashedReason(C.VIR_DOMAIN_CRASHED_PANICKED)
 545 )
 546
 547 type DomainEventCrashedDetailType int
 548
 549 const (
 550         DOMAIN_EVENT_CRASHED_PANICKED = DomainEventCrashedDetailType(C.VIR_DOMAIN_EVENT_CRASHED_PANICKED)
 551 )
 552
 553 type DomainEventPMSuspendedDetailType int
 554
 555 const (
 556         DOMAIN_EVENT_PMSUSPENDED_MEMORY = DomainEventPMSuspendedDetailType(C.VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY)
 557         DOMAIN_EVENT_PMSUSPENDED_DISK   = DomainEventPMSuspendedDetailType(C.VIR_DOMAIN_EVENT_PMSUSPENDED_DISK)
 558 )
 559
 560 type DomainNostateReason int
 561
 562 const (
 563         DOMAIN_NOSTATE_UNKNOWN = DomainNostateReason(C.VIR_DOMAIN_NOSTATE_UNKNOWN)
 564 )
 565
 566 type DomainPMSuspendedReason int
 567
 568 const (
 569         DOMAIN_PMSUSPENDED_UNKNOWN = DomainPMSuspendedReason(C.VIR_DOMAIN_PMSUSPENDED_UNKNOWN)
 570 )
 571
 572 type DomainPMSuspendedDiskReason int
 573
 574 const (
 575         DOMAIN_PMSUSPENDED_DISK_UNKNOWN = DomainPMSuspendedDiskReason(C.VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN)
 576 )
 577
 578 type DomainShutdownReason int
 579
 580 const (
 581         DOMAIN_SHUTDOWN_UNKNOWN = DomainShutdownReason(C.VIR_DOMAIN_SHUTDOWN_UNKNOWN)
 582         DOMAIN_SHUTDOWN_USER    = DomainShutdownReason(C.VIR_DOMAIN_SHUTDOWN_USER)
 583 )
 584
 585 type DomainShutoffReason int
 586
 587 const (
 588         DOMAIN_SHUTOFF_UNKNOWN       = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_UNKNOWN)
 589         DOMAIN_SHUTOFF_SHUTDOWN      = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_SHUTDOWN)
 590         DOMAIN_SHUTOFF_DESTROYED     = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_DESTROYED)
 591         DOMAIN_SHUTOFF_CRASHED       = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_CRASHED)
 592         DOMAIN_SHUTOFF_MIGRATED      = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_MIGRATED)
 593         DOMAIN_SHUTOFF_SAVED         = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_SAVED)
 594         DOMAIN_SHUTOFF_FAILED        = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_FAILED)
 595         DOMAIN_SHUTOFF_FROM_SNAPSHOT = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT)
 596         DOMAIN_SHUTOFF_DAEMON        = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_DAEMON)
 597 )
 598
 599 type DomainBlockCommitFlags int
 600
 601 const (
 602         DOMAIN_BLOCK_COMMIT_SHALLOW         = DomainBlockCommitFlags(C.VIR_DOMAIN_BLOCK_COMMIT_SHALLOW)
 603         DOMAIN_BLOCK_COMMIT_DELETE          = DomainBlockCommitFlags(C.VIR_DOMAIN_BLOCK_COMMIT_DELETE)
 604         DOMAIN_BLOCK_COMMIT_ACTIVE          = DomainBlockCommitFlags(C.VIR_DOMAIN_BLOCK_COMMIT_ACTIVE)
 605         DOMAIN_BLOCK_COMMIT_RELATIVE        = DomainBlockCommitFlags(C.VIR_DOMAIN_BLOCK_COMMIT_RELATIVE)
 606         DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = DomainBlockCommitFlags(C.VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES)
 607 )
 608
 609 type DomainBlockCopyFlags int
 610
 611 const (
 612         DOMAIN_BLOCK_COPY_SHALLOW       = DomainBlockCopyFlags(C.VIR_DOMAIN_BLOCK_COPY_SHALLOW)
 613         DOMAIN_BLOCK_COPY_REUSE_EXT     = DomainBlockCopyFlags(C.VIR_DOMAIN_BLOCK_COPY_REUSE_EXT)
 614         DOMAIN_BLOCK_COPY_TRANSIENT_JOB = DomainBlockCopyFlags(C.VIR_DOMAIN_BLOCK_COPY_TRANSIENT_JOB)
 615 )
 616
 617 type DomainBlockRebaseFlags int
 618
 619 const (
 620         DOMAIN_BLOCK_REBASE_SHALLOW         = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_SHALLOW)
 621         DOMAIN_BLOCK_REBASE_REUSE_EXT       = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT)
 622         DOMAIN_BLOCK_REBASE_COPY_RAW        = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_COPY_RAW)
 623         DOMAIN_BLOCK_REBASE_COPY            = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_COPY)
 624         DOMAIN_BLOCK_REBASE_RELATIVE        = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_RELATIVE)
 625         DOMAIN_BLOCK_REBASE_COPY_DEV        = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_COPY_DEV)
 626         DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = DomainBlockRebaseFlags(C.VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES)
 627 )
 628
 629 type DomainBlockJobAbortFlags int
 630
 631 const (
 632         DOMAIN_BLOCK_JOB_ABORT_ASYNC = DomainBlockJobAbortFlags(C.VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC)
 633         DOMAIN_BLOCK_JOB_ABORT_PIVOT = DomainBlockJobAbortFlags(C.VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT)
 634 )
 635
 636 type DomainBlockJobInfoFlags int
 637
 638 const (
 639         DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = DomainBlockJobInfoFlags(C.VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES)
 640 )
 641
 642 type DomainBlockJobSetSpeedFlags int
 643
 644 const (
 645         DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = DomainBlockJobSetSpeedFlags(C.VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES)
 646 )
 647
 648 type DomainBlockPullFlags int
 649
 650 const (
 651         DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = DomainBlockPullFlags(C.VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES)
 652 )
 653
 654 type DomainBlockResizeFlags int
 655
 656 const (
 657         DOMAIN_BLOCK_RESIZE_BYTES = DomainBlockResizeFlags(C.VIR_DOMAIN_BLOCK_RESIZE_BYTES)
 658 )
 659
 660 type Domain struct {
 661         ptr C.virDomainPtr
 662 }
 663
 664 type DomainChannelFlags int
 665
 666 const (
 667         DOMAIN_CHANNEL_FORCE = DomainChannelFlags(C.VIR_DOMAIN_CHANNEL_FORCE)
 668 )
 669
 670 type DomainConsoleFlags int
 671
 672 const (
 673         DOMAIN_CONSOLE_FORCE = DomainConsoleFlags(C.VIR_DOMAIN_CONSOLE_FORCE)
 674         DOMAIN_CONSOLE_SAFE  = DomainConsoleFlags(C.VIR_DOMAIN_CONSOLE_SAFE)
 675 )
 676
 677 type DomainCoreDumpFormat int
 678
 679 const (
 680         DOMAIN_CORE_DUMP_FORMAT_RAW          = DomainCoreDumpFormat(C.VIR_DOMAIN_CORE_DUMP_FORMAT_RAW)
 681         DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB   = DomainCoreDumpFormat(C.VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB)
 682         DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO    = DomainCoreDumpFormat(C.VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO)
 683         DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY = DomainCoreDumpFormat(C.VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY)
 684 )
 685
 686 type DomainDefineFlags int
 687
 688 const (
 689         DOMAIN_DEFINE_VALIDATE = DomainDefineFlags(C.VIR_DOMAIN_DEFINE_VALIDATE)
 690 )
 691
 692 type DomainJobType int
 693
 694 const (
 695         DOMAIN_JOB_NONE      = DomainJobType(C.VIR_DOMAIN_JOB_NONE)
 696         DOMAIN_JOB_BOUNDED   = DomainJobType(C.VIR_DOMAIN_JOB_BOUNDED)
 697         DOMAIN_JOB_UNBOUNDED = DomainJobType(C.VIR_DOMAIN_JOB_UNBOUNDED)
 698         DOMAIN_JOB_COMPLETED = DomainJobType(C.VIR_DOMAIN_JOB_COMPLETED)
 699         DOMAIN_JOB_FAILED    = DomainJobType(C.VIR_DOMAIN_JOB_FAILED)
 700         DOMAIN_JOB_CANCELLED = DomainJobType(C.VIR_DOMAIN_JOB_CANCELLED)
 701 )
 702
 703 type DomainGetJobStatsFlags int
 704
 705 const (
 706         DOMAIN_JOB_STATS_COMPLETED = DomainGetJobStatsFlags(C.VIR_DOMAIN_JOB_STATS_COMPLETED)
 707 )
 708
 709 type DomainNumatuneMemMode int
 710
 711 const (
 712         DOMAIN_NUMATUNE_MEM_STRICT     = DomainNumatuneMemMode(C.VIR_DOMAIN_NUMATUNE_MEM_STRICT)
 713         DOMAIN_NUMATUNE_MEM_PREFERRED  = DomainNumatuneMemMode(C.VIR_DOMAIN_NUMATUNE_MEM_PREFERRED)
 714         DOMAIN_NUMATUNE_MEM_INTERLEAVE = DomainNumatuneMemMode(C.VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE)
 715 )
 716
 717 type DomainOpenGraphicsFlags int
 718
 719 const (
 720         DOMAIN_OPEN_GRAPHICS_SKIPAUTH = DomainOpenGraphicsFlags(C.VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH)
 721 )
 722
 723 type DomainSetUserPasswordFlags int
 724
 725 const (
 726         DOMAIN_PASSWORD_ENCRYPTED = DomainSetUserPasswordFlags(C.VIR_DOMAIN_PASSWORD_ENCRYPTED)
 727 )
 728
 729 type DomainRebootFlagValues int
 730
 731 const (
 732         DOMAIN_REBOOT_DEFAULT        = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_DEFAULT)
 733         DOMAIN_REBOOT_ACPI_POWER_BTN = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_ACPI_POWER_BTN)
 734         DOMAIN_REBOOT_GUEST_AGENT    = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_GUEST_AGENT)
 735         DOMAIN_REBOOT_INITCTL        = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_INITCTL)
 736         DOMAIN_REBOOT_SIGNAL         = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_SIGNAL)
 737         DOMAIN_REBOOT_PARAVIRT       = DomainRebootFlagValues(C.VIR_DOMAIN_REBOOT_PARAVIRT)
 738 )
 739
 740 type DomainSaveRestoreFlags int
 741
 742 const (
 743         DOMAIN_SAVE_BYPASS_CACHE = DomainSaveRestoreFlags(C.VIR_DOMAIN_SAVE_BYPASS_CACHE)
 744         DOMAIN_SAVE_RUNNING      = DomainSaveRestoreFlags(C.VIR_DOMAIN_SAVE_RUNNING)
 745         DOMAIN_SAVE_PAUSED       = DomainSaveRestoreFlags(C.VIR_DOMAIN_SAVE_PAUSED)
 746 )
 747
 748 type DomainSetTimeFlags int
 749
 750 const (
 751         DOMAIN_TIME_SYNC = DomainSetTimeFlags(C.VIR_DOMAIN_TIME_SYNC)
 752 )
 753
 754 type DomainDiskErrorCode int
 755
 756 const (
 757         DOMAIN_DISK_ERROR_NONE     = DomainDiskErrorCode(C.VIR_DOMAIN_DISK_ERROR_NONE)
 758         DOMAIN_DISK_ERROR_UNSPEC   = DomainDiskErrorCode(C.VIR_DOMAIN_DISK_ERROR_UNSPEC)
 759         DOMAIN_DISK_ERROR_NO_SPACE = DomainDiskErrorCode(C.VIR_DOMAIN_DISK_ERROR_NO_SPACE)
 760 )
 761
 762 type DomainStatsTypes int
 763
 764 const (
 765         DOMAIN_STATS_STATE     = DomainStatsTypes(C.VIR_DOMAIN_STATS_STATE)
 766         DOMAIN_STATS_CPU_TOTAL = DomainStatsTypes(C.VIR_DOMAIN_STATS_CPU_TOTAL)
 767         DOMAIN_STATS_BALLOON   = DomainStatsTypes(C.VIR_DOMAIN_STATS_BALLOON)
 768         DOMAIN_STATS_VCPU      = DomainStatsTypes(C.VIR_DOMAIN_STATS_VCPU)
 769         DOMAIN_STATS_INTERFACE = DomainStatsTypes(C.VIR_DOMAIN_STATS_INTERFACE)
 770         DOMAIN_STATS_BLOCK     = DomainStatsTypes(C.VIR_DOMAIN_STATS_BLOCK)
 771         DOMAIN_STATS_PERF      = DomainStatsTypes(C.VIR_DOMAIN_STATS_PERF)
 772         DOMAIN_STATS_IOTHREAD  = DomainStatsTypes(C.VIR_DOMAIN_STATS_IOTHREAD)
 773 )
 774
 775 type DomainCoreDumpFlags int
 776
 777 const (
 778         DUMP_CRASH        = DomainCoreDumpFlags(C.VIR_DUMP_CRASH)
 779         DUMP_LIVE         = DomainCoreDumpFlags(C.VIR_DUMP_LIVE)
 780         DUMP_BYPASS_CACHE = DomainCoreDumpFlags(C.VIR_DUMP_BYPASS_CACHE)
 781         DUMP_RESET        = DomainCoreDumpFlags(C.VIR_DUMP_RESET)
 782         DUMP_MEMORY_ONLY  = DomainCoreDumpFlags(C.VIR_DUMP_MEMORY_ONLY)
 783 )
 784
 785 type DomainMemoryFlags int
 786
 787 const (
 788         MEMORY_VIRTUAL  = DomainMemoryFlags(C.VIR_MEMORY_VIRTUAL)
 789         MEMORY_PHYSICAL = DomainMemoryFlags(C.VIR_MEMORY_PHYSICAL)
 790 )
 791
 792 type DomainMigrateFlags int
 793
 794 const (
 795         MIGRATE_LIVE              = DomainMigrateFlags(C.VIR_MIGRATE_LIVE)
 796         MIGRATE_PEER2PEER         = DomainMigrateFlags(C.VIR_MIGRATE_PEER2PEER)
 797         MIGRATE_TUNNELLED         = DomainMigrateFlags(C.VIR_MIGRATE_TUNNELLED)
 798         MIGRATE_PERSIST_DEST      = DomainMigrateFlags(C.VIR_MIGRATE_PERSIST_DEST)
 799         MIGRATE_UNDEFINE_SOURCE   = DomainMigrateFlags(C.VIR_MIGRATE_UNDEFINE_SOURCE)
 800         MIGRATE_PAUSED            = DomainMigrateFlags(C.VIR_MIGRATE_PAUSED)
 801         MIGRATE_NON_SHARED_DISK   = DomainMigrateFlags(C.VIR_MIGRATE_NON_SHARED_DISK)
 802         MIGRATE_NON_SHARED_INC    = DomainMigrateFlags(C.VIR_MIGRATE_NON_SHARED_INC)
 803         MIGRATE_CHANGE_PROTECTION = DomainMigrateFlags(C.VIR_MIGRATE_CHANGE_PROTECTION)
 804         MIGRATE_UNSAFE            = DomainMigrateFlags(C.VIR_MIGRATE_UNSAFE)
 805         MIGRATE_OFFLINE           = DomainMigrateFlags(C.VIR_MIGRATE_OFFLINE)
 806         MIGRATE_COMPRESSED        = DomainMigrateFlags(C.VIR_MIGRATE_COMPRESSED)
 807         MIGRATE_ABORT_ON_ERROR    = DomainMigrateFlags(C.VIR_MIGRATE_ABORT_ON_ERROR)
 808         MIGRATE_AUTO_CONVERGE     = DomainMigrateFlags(C.VIR_MIGRATE_AUTO_CONVERGE)
 809         MIGRATE_RDMA_PIN_ALL      = DomainMigrateFlags(C.VIR_MIGRATE_RDMA_PIN_ALL)
 810         MIGRATE_POSTCOPY          = DomainMigrateFlags(C.VIR_MIGRATE_POSTCOPY)
 811         MIGRATE_TLS               = DomainMigrateFlags(C.VIR_MIGRATE_TLS)
 812 )
 813
 814 type VcpuState int
 815
 816 const (
 817         VCPU_OFFLINE = VcpuState(C.VIR_VCPU_OFFLINE)
 818         VCPU_RUNNING = VcpuState(C.VIR_VCPU_RUNNING)
 819         VCPU_BLOCKED = VcpuState(C.VIR_VCPU_BLOCKED)
 820 )
 821
 822 type DomainJobOperationType int
 823
 824 const (
 825         DOMAIN_JOB_OPERATION_UNKNOWN         = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_UNKNOWN)
 826         DOMAIN_JOB_OPERATION_START           = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_START)
 827         DOMAIN_JOB_OPERATION_SAVE            = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_SAVE)
 828         DOMAIN_JOB_OPERATION_RESTORE         = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_RESTORE)
 829         DOMAIN_JOB_OPERATION_MIGRATION_IN    = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_MIGRATION_IN)
 830         DOMAIN_JOB_OPERATION_MIGRATION_OUT   = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_MIGRATION_OUT)
 831         DOMAIN_JOB_OPERATION_SNAPSHOT        = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_SNAPSHOT)
 832         DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT)
 833         DOMAIN_JOB_OPERATION_DUMP            = DomainJobOperationType(C.VIR_DOMAIN_JOB_OPERATION_DUMP)
 834 )
 835
 836 type DomainBlockInfo struct {
 837         Capacity   uint64
 838         Allocation uint64
 839         Physical   uint64
 840 }
 841
 842 type DomainInfo struct {
 843         State     DomainState
 844         MaxMem    uint64
 845         Memory    uint64
 846         NrVirtCpu uint
 847         CpuTime   uint64
 848 }
 849
 850 type DomainMemoryStat struct {
 851         Tag int32
 852         Val uint64
 853 }
 854
 855 type DomainVcpuInfo struct {
 856         Number  uint32
 857         State   int32
 858         CpuTime uint64
 859         Cpu     int32
 860         CpuMap  []bool
 861 }
 862
 863 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFree
 864 func (d *Domain) Free() error {
 865         var err C.virError
 866         ret := C.virDomainFreeWrapper(d.ptr, &err)
 867         if ret == -1 {
 868                 return makeError(&err)
 869         }
 870         return nil
 871 }
 872
 873 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainRef
 874 func (c *Domain) Ref() error {
 875         var err C.virError
 876         ret := C.virDomainRefWrapper(c.ptr, &err)
 877         if ret == -1 {
 878                 return makeError(&err)
 879         }
 880         return nil
 881 }
 882
 883 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreate
 884 func (d *Domain) Create() error {
 885         var err C.virError
 886         result := C.virDomainCreateWrapper(d.ptr, &err)
 887         if result == -1 {
 888                 return makeError(&err)
 889         }
 890         return nil
 891 }
 892
 893 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateWithFlags
 894 func (d *Domain) CreateWithFlags(flags DomainCreateFlags) error {
 895         var err C.virError
 896         result := C.virDomainCreateWithFlagsWrapper(d.ptr, C.uint(flags), &err)
 897         if result == -1 {
 898                 return makeError(&err)
 899         }
 900         return nil
 901 }
 902
 903 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateWithFiles
 904 func (d *Domain) CreateWithFiles(files []os.File, flags DomainCreateFlags) error {
 905         cfiles := make([]C.int, len(files))
 906         for i := 0; i < len(files); i++ {
 907                 cfiles[i] = C.int(files[i].Fd())
 908         }
 909         var err C.virError
 910         result := C.virDomainCreateWithFilesWrapper(d.ptr, C.uint(len(files)), &cfiles[0], C.uint(flags), &err)
 911         if result == -1 {
 912                 return makeError(&err)
 913         }
 914         return nil
 915 }
 916
 917 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDestroy
 918 func (d *Domain) Destroy() error {
 919         var err C.virError
 920         result := C.virDomainDestroyWrapper(d.ptr, &err)
 921         if result == -1 {
 922                 return makeError(&err)
 923         }
 924         return nil
 925 }
 926
 927 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainShutdown
 928 func (d *Domain) Shutdown() error {
 929         var err C.virError
 930         result := C.virDomainShutdownWrapper(d.ptr, &err)
 931         if result == -1 {
 932                 return makeError(&err)
 933         }
 934         return nil
 935 }
 936
 937 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainReboot
 938 func (d *Domain) Reboot(flags DomainRebootFlagValues) error {
 939         var err C.virError
 940         result := C.virDomainRebootWrapper(d.ptr, C.uint(flags), &err)
 941         if result == -1 {
 942                 return makeError(&err)
 943         }
 944         return nil
 945 }
 946
 947 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsActive
 948 func (d *Domain) IsActive() (bool, error) {
 949         var err C.virError
 950         result := C.virDomainIsActiveWrapper(d.ptr, &err)
 951         if result == -1 {
 952                 return false, makeError(&err)
 953         }
 954         if result == 1 {
 955                 return true, nil
 956         }
 957         return false, nil
 958 }
 959
 960 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsPersistent
 961 func (d *Domain) IsPersistent() (bool, error) {
 962         var err C.virError
 963         result := C.virDomainIsPersistentWrapper(d.ptr, &err)
 964         if result == -1 {
 965                 return false, makeError(&err)
 966         }
 967         if result == 1 {
 968                 return true, nil
 969         }
 970         return false, nil
 971 }
 972
 973 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsUpdated
 974 func (d *Domain) IsUpdated() (bool, error) {
 975         var err C.virError
 976         result := C.virDomainIsUpdatedWrapper(d.ptr, &err)
 977         if result == -1 {
 978                 return false, makeError(&err)
 979         }
 980         if result == 1 {
 981                 return true, nil
 982         }
 983         return false, nil
 984 }
 985
 986 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetAutostart
 987 func (d *Domain) SetAutostart(autostart bool) error {
 988         var cAutostart C.int
 989         switch autostart {
 990         case true:
 991                 cAutostart = 1
 992         default:
 993                 cAutostart = 0
 994         }
 995         var err C.virError
 996         result := C.virDomainSetAutostartWrapper(d.ptr, cAutostart, &err)
 997         if result == -1 {
 998                 return makeError(&err)
 999         }
1000         return nil
1001 }
1002
1003 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetAutostart
1004 func (d *Domain) GetAutostart() (bool, error) {
1005         var out C.int
1006         var err C.virError
1007         result := C.virDomainGetAutostartWrapper(d.ptr, (*C.int)(unsafe.Pointer(&out)), &err)
1008         if result == -1 {
1009                 return false, makeError(&err)
1010         }
1011         switch out {
1012         case 1:
1013                 return true, nil
1014         default:
1015                 return false, nil
1016         }
1017 }
1018
1019 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockInfo
1020 func (d *Domain) GetBlockInfo(disk string, flag uint) (*DomainBlockInfo, error) {
1021         var cinfo C.virDomainBlockInfo
1022         cDisk := C.CString(disk)
1023         defer C.free(unsafe.Pointer(cDisk))
1024         var err C.virError
1025         result := C.virDomainGetBlockInfoWrapper(d.ptr, cDisk, &cinfo, C.uint(flag), &err)
1026         if result == -1 {
1027                 return nil, makeError(&err)
1028         }
1029
1030         return &DomainBlockInfo{
1031                 Capacity:   uint64(cinfo.capacity),
1032                 Allocation: uint64(cinfo.allocation),
1033                 Physical:   uint64(cinfo.physical),
1034         }, nil
1035 }
1036
1037 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetName
1038 func (d *Domain) GetName() (string, error) {
1039         var err C.virError
1040         name := C.virDomainGetNameWrapper(d.ptr, &err)
1041         if name == nil {
1042                 return "", makeError(&err)
1043         }
1044         return C.GoString(name), nil
1045 }
1046
1047 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetState
1048 func (d *Domain) GetState() (DomainState, int, error) {
1049         var cState C.int
1050         var cReason C.int
1051         var err C.virError
1052         result := C.virDomainGetStateWrapper(d.ptr,
1053                 (*C.int)(unsafe.Pointer(&cState)),
1054                 (*C.int)(unsafe.Pointer(&cReason)),
1055                 0, &err)
1056         if int(result) == -1 {
1057                 return 0, 0, makeError(&err)
1058         }
1059         return DomainState(cState), int(cReason), nil
1060 }
1061
1062 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetID
1063 func (d *Domain) GetID() (uint, error) {
1064         var err C.virError
1065         id := uint(C.virDomainGetIDWrapper(d.ptr, &err))
1066         if id == ^uint(0) {
1067                 return id, makeError(&err)
1068         }
1069         return id, nil
1070 }
1071
1072 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetUUID
1073 func (d *Domain) GetUUID() ([]byte, error) {
1074         var cUuid [C.VIR_UUID_BUFLEN](byte)
1075         cuidPtr := unsafe.Pointer(&cUuid)
1076         var err C.virError
1077         result := C.virDomainGetUUIDWrapper(d.ptr, (*C.uchar)(cuidPtr), &err)
1078         if result != 0 {
1079                 return []byte{}, makeError(&err)
1080         }
1081         return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil
1082 }
1083
1084 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetUUIDString
1085 func (d *Domain) GetUUIDString() (string, error) {
1086         var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char)
1087         cuidPtr := unsafe.Pointer(&cUuid)
1088         var err C.virError
1089         result := C.virDomainGetUUIDStringWrapper(d.ptr, (*C.char)(cuidPtr), &err)
1090         if result != 0 {
1091                 return "", makeError(&err)
1092         }
1093         return C.GoString((*C.char)(cuidPtr)), nil
1094 }
1095
1096 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInfo
1097 func (d *Domain) GetInfo() (*DomainInfo, error) {
1098         var cinfo C.virDomainInfo
1099         var err C.virError
1100         result := C.virDomainGetInfoWrapper(d.ptr, &cinfo, &err)
1101         if result == -1 {
1102                 return nil, makeError(&err)
1103         }
1104         return &DomainInfo{
1105                 State:     DomainState(cinfo.state),
1106                 MaxMem:    uint64(cinfo.maxMem),
1107                 Memory:    uint64(cinfo.memory),
1108                 NrVirtCpu: uint(cinfo.nrVirtCpu),
1109                 CpuTime:   uint64(cinfo.cpuTime),
1110         }, nil
1111 }
1112
1113 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetXMLDesc
1114 func (d *Domain) GetXMLDesc(flags DomainXMLFlags) (string, error) {
1115         var err C.virError
1116         result := C.virDomainGetXMLDescWrapper(d.ptr, C.uint(flags), &err)
1117         if result == nil {
1118                 return "", makeError(&err)
1119         }
1120         xml := C.GoString(result)
1121         C.free(unsafe.Pointer(result))
1122         return xml, nil
1123 }
1124
1125 type DomainCPUStats struct {
1126         CpuTimeSet    bool
1127         CpuTime       uint64
1128         UserTimeSet   bool
1129         UserTime      uint64
1130         SystemTimeSet bool
1131         SystemTime    uint64
1132         VcpuTimeSet   bool
1133         VcpuTime      uint64
1134 }
1135
1136 func getCPUStatsFieldInfo(params *DomainCPUStats) map[string]typedParamsFieldInfo {
1137         return map[string]typedParamsFieldInfo{
1138                 C.VIR_DOMAIN_CPU_STATS_CPUTIME: typedParamsFieldInfo{
1139                         set: &params.CpuTimeSet,
1140                         ul:  &params.CpuTime,
1141                 },
1142                 C.VIR_DOMAIN_CPU_STATS_USERTIME: typedParamsFieldInfo{
1143                         set: &params.UserTimeSet,
1144                         ul:  &params.UserTime,
1145                 },
1146                 C.VIR_DOMAIN_CPU_STATS_SYSTEMTIME: typedParamsFieldInfo{
1147                         set: &params.SystemTimeSet,
1148                         ul:  &params.SystemTime,
1149                 },
1150                 C.VIR_DOMAIN_CPU_STATS_VCPUTIME: typedParamsFieldInfo{
1151                         set: &params.VcpuTimeSet,
1152                         ul:  &params.VcpuTime,
1153                 },
1154         }
1155 }
1156
1157 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetCPUStats
1158 func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32) ([]DomainCPUStats, error) {
1159         var err C.virError
1160         if nCpus == 0 {
1161                 if startCpu == -1 {
1162                         nCpus = 1
1163                 } else {
1164                         ret := C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, 0, 0, 0, &err)
1165                         if ret == -1 {
1166                                 return []DomainCPUStats{}, makeError(&err)
1167                         }
1168                         nCpus = uint(ret)
1169                 }
1170         }
1171
1172         ret := C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, C.int(startCpu), C.uint(nCpus), 0, &err)
1173         if ret == -1 {
1174                 return []DomainCPUStats{}, makeError(&err)
1175         }
1176         nparams := uint(ret)
1177
1178         var cparams []C.virTypedParameter
1179         var nallocparams uint
1180         if startCpu == -1 {
1181                 nallocparams = nparams
1182         } else {
1183                 nallocparams = nparams * nCpus
1184         }
1185         cparams = make([]C.virTypedParameter, nallocparams)
1186         ret = C.virDomainGetCPUStatsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.uint(nparams), C.int(startCpu), C.uint(nCpus), C.uint(flags), &err)
1187         if ret == -1 {
1188                 return []DomainCPUStats{}, makeError(&err)
1189         }
1190
1191         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.int(nallocparams))
1192
1193         stats := make([]DomainCPUStats, nCpus)
1194         for i := 0; i < int(nCpus); i++ {
1195                 offset := i * int(nparams)
1196                 info := getCPUStatsFieldInfo(&stats[i])
1197                 cparamscpu := cparams[offset : offset+int(ret)]
1198                 _, gerr := typedParamsUnpack(cparamscpu, info)
1199                 if gerr != nil {
1200                         return []DomainCPUStats{}, gerr
1201                 }
1202         }
1203         return stats, nil
1204 }
1205
1206 type DomainInterfaceParameters struct {
1207         BandwidthInAverageSet  bool
1208         BandwidthInAverage     uint
1209         BandwidthInPeakSet     bool
1210         BandwidthInPeak        uint
1211         BandwidthInBurstSet    bool
1212         BandwidthInBurst       uint
1213         BandwidthInFloorSet    bool
1214         BandwidthInFloor       uint
1215         BandwidthOutAverageSet bool
1216         BandwidthOutAverage    uint
1217         BandwidthOutPeakSet    bool
1218         BandwidthOutPeak       uint
1219         BandwidthOutBurstSet   bool
1220         BandwidthOutBurst      uint
1221 }
1222
1223 func getInterfaceParameterFieldInfo(params *DomainInterfaceParameters) map[string]typedParamsFieldInfo {
1224         return map[string]typedParamsFieldInfo{
1225                 C.VIR_DOMAIN_BANDWIDTH_IN_AVERAGE: typedParamsFieldInfo{
1226                         set: &params.BandwidthInAverageSet,
1227                         ui:  &params.BandwidthInAverage,
1228                 },
1229                 C.VIR_DOMAIN_BANDWIDTH_IN_PEAK: typedParamsFieldInfo{
1230                         set: &params.BandwidthInPeakSet,
1231                         ui:  &params.BandwidthInPeak,
1232                 },
1233                 C.VIR_DOMAIN_BANDWIDTH_IN_BURST: typedParamsFieldInfo{
1234                         set: &params.BandwidthInBurstSet,
1235                         ui:  &params.BandwidthInBurst,
1236                 },
1237                 C.VIR_DOMAIN_BANDWIDTH_IN_FLOOR: typedParamsFieldInfo{
1238                         set: &params.BandwidthInFloorSet,
1239                         ui:  &params.BandwidthInFloor,
1240                 },
1241                 C.VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE: typedParamsFieldInfo{
1242                         set: &params.BandwidthOutAverageSet,
1243                         ui:  &params.BandwidthOutAverage,
1244                 },
1245                 C.VIR_DOMAIN_BANDWIDTH_OUT_PEAK: typedParamsFieldInfo{
1246                         set: &params.BandwidthOutPeakSet,
1247                         ui:  &params.BandwidthOutPeak,
1248                 },
1249                 C.VIR_DOMAIN_BANDWIDTH_OUT_BURST: typedParamsFieldInfo{
1250                         set: &params.BandwidthOutBurstSet,
1251                         ui:  &params.BandwidthOutBurst,
1252                 },
1253         }
1254 }
1255
1256 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInterfaceParameters
1257 func (d *Domain) GetInterfaceParameters(device string, flags DomainModificationImpact) (*DomainInterfaceParameters, error) {
1258         params := &DomainInterfaceParameters{}
1259         info := getInterfaceParameterFieldInfo(params)
1260
1261         var nparams C.int
1262
1263         cdevice := C.CString(device)
1264         defer C.free(unsafe.Pointer(cdevice))
1265         var err C.virError
1266         ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams, C.uint(0), &err)
1267         if ret == -1 {
1268                 return nil, makeError(&err)
1269         }
1270
1271         cparams := make([]C.virTypedParameter, nparams)
1272         ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
1273         if ret == -1 {
1274                 return nil, makeError(&err)
1275         }
1276
1277         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
1278
1279         _, gerr := typedParamsUnpack(cparams, info)
1280         if gerr != nil {
1281                 return nil, gerr
1282         }
1283
1284         return params, nil
1285 }
1286
1287 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetInterfaceParameters
1288 func (d *Domain) SetInterfaceParameters(device string, params *DomainInterfaceParameters, flags DomainModificationImpact) error {
1289         info := getInterfaceParameterFieldInfo(params)
1290
1291         var nparams C.int
1292
1293         cdevice := C.CString(device)
1294         defer C.free(unsafe.Pointer(cdevice))
1295         var err C.virError
1296         ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams, 0, &err)
1297         if ret == -1 {
1298                 return makeError(&err)
1299         }
1300
1301         cparams := make([]C.virTypedParameter, nparams)
1302         ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
1303         if ret == -1 {
1304                 return makeError(&err)
1305         }
1306
1307         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
1308
1309         gerr := typedParamsPack(cparams, info)
1310         if gerr != nil {
1311                 return gerr
1312         }
1313
1314         ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
1315
1316         return nil
1317 }
1318
1319 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMetadata
1320 func (d *Domain) GetMetadata(tipus DomainMetadataType, uri string, flags DomainModificationImpact) (string, error) {
1321         var cUri *C.char
1322         if uri != "" {
1323                 cUri = C.CString(uri)
1324                 defer C.free(unsafe.Pointer(cUri))
1325         }
1326
1327         var err C.virError
1328         result := C.virDomainGetMetadataWrapper(d.ptr, C.int(tipus), cUri, C.uint(flags), &err)
1329         if result == nil {
1330                 return "", makeError(&err)
1331
1332         }
1333         defer C.free(unsafe.Pointer(result))
1334         return C.GoString(result), nil
1335 }
1336
1337 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMetadata
1338 func (d *Domain) SetMetadata(metaDataType DomainMetadataType, metaDataCont, uriKey, uri string, flags DomainModificationImpact) error {
1339         var cMetaDataCont *C.char
1340         var cUriKey *C.char
1341         var cUri *C.char
1342
1343         if metaDataCont != "" {
1344                 cMetaDataCont = C.CString(metaDataCont)
1345                 defer C.free(unsafe.Pointer(cMetaDataCont))
1346         }
1347
1348         if metaDataType == DOMAIN_METADATA_ELEMENT {
1349                 if uriKey != "" {
1350                         cUriKey = C.CString(uriKey)
1351                         defer C.free(unsafe.Pointer(cUriKey))
1352                 }
1353                 cUri = C.CString(uri)
1354                 defer C.free(unsafe.Pointer(cUri))
1355         }
1356         var err C.virError
1357         result := C.virDomainSetMetadataWrapper(d.ptr, C.int(metaDataType), cMetaDataCont, cUriKey, cUri, C.uint(flags), &err)
1358         if result == -1 {
1359                 return makeError(&err)
1360         }
1361         return nil
1362 }
1363
1364 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainUndefine
1365 func (d *Domain) Undefine() error {
1366         var err C.virError
1367         result := C.virDomainUndefineWrapper(d.ptr, &err)
1368         if result == -1 {
1369                 return makeError(&err)
1370         }
1371         return nil
1372 }
1373
1374 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainUndefineFlags
1375 func (d *Domain) UndefineFlags(flags DomainUndefineFlagsValues) error {
1376         var err C.virError
1377         result := C.virDomainUndefineFlagsWrapper(d.ptr, C.uint(flags), &err)
1378         if result == -1 {
1379                 return makeError(&err)
1380         }
1381         return nil
1382 }
1383
1384 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMaxMemory
1385 func (d *Domain) SetMaxMemory(memory uint) error {
1386         var err C.virError
1387         result := C.virDomainSetMaxMemoryWrapper(d.ptr, C.ulong(memory), &err)
1388         if result == -1 {
1389                 return makeError(&err)
1390         }
1391         return nil
1392 }
1393
1394 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemory
1395 func (d *Domain) SetMemory(memory uint64) error {
1396         var err C.virError
1397         result := C.virDomainSetMemoryWrapper(d.ptr, C.ulong(memory), &err)
1398         if result == -1 {
1399                 return makeError(&err)
1400         }
1401         return nil
1402 }
1403
1404 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryFlags
1405 func (d *Domain) SetMemoryFlags(memory uint64, flags DomainMemoryModFlags) error {
1406         var err C.virError
1407         result := C.virDomainSetMemoryFlagsWrapper(d.ptr, C.ulong(memory), C.uint(flags), &err)
1408         if result == -1 {
1409                 return makeError(&err)
1410         }
1411         return nil
1412 }
1413
1414 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryStatsPeriod
1415 func (d *Domain) SetMemoryStatsPeriod(period int, flags DomainMemoryModFlags) error {
1416         var err C.virError
1417         result := C.virDomainSetMemoryStatsPeriodWrapper(d.ptr, C.int(period), C.uint(flags), &err)
1418         if result == -1 {
1419                 return makeError(&err)
1420         }
1421         return nil
1422 }
1423
1424 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpus
1425 func (d *Domain) SetVcpus(vcpu uint) error {
1426         var err C.virError
1427         result := C.virDomainSetVcpusWrapper(d.ptr, C.uint(vcpu), &err)
1428         if result == -1 {
1429                 return makeError(&err)
1430         }
1431         return nil
1432 }
1433
1434 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpusFlags
1435 func (d *Domain) SetVcpusFlags(vcpu uint, flags DomainVcpuFlags) error {
1436         var err C.virError
1437         result := C.virDomainSetVcpusFlagsWrapper(d.ptr, C.uint(vcpu), C.uint(flags), &err)
1438         if result == -1 {
1439                 return makeError(&err)
1440         }
1441         return nil
1442 }
1443
1444 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSuspend
1445 func (d *Domain) Suspend() error {
1446         var err C.virError
1447         result := C.virDomainSuspendWrapper(d.ptr, &err)
1448         if result == -1 {
1449                 return makeError(&err)
1450         }
1451         return nil
1452 }
1453
1454 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainResume
1455 func (d *Domain) Resume() error {
1456         var err C.virError
1457         result := C.virDomainResumeWrapper(d.ptr, &err)
1458         if result == -1 {
1459                 return makeError(&err)
1460         }
1461         return nil
1462 }
1463
1464 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAbortJob
1465 func (d *Domain) AbortJob() error {
1466         var err C.virError
1467         result := C.virDomainAbortJobWrapper(d.ptr, &err)
1468         if result == -1 {
1469                 return makeError(&err)
1470         }
1471         return nil
1472 }
1473
1474 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDestroyFlags
1475 func (d *Domain) DestroyFlags(flags DomainDestroyFlags) error {
1476         var err C.virError
1477         result := C.virDomainDestroyFlagsWrapper(d.ptr, C.uint(flags), &err)
1478         if result == -1 {
1479                 return makeError(&err)
1480         }
1481         return nil
1482 }
1483
1484 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainShutdownFlags
1485 func (d *Domain) ShutdownFlags(flags DomainShutdownFlags) error {
1486         var err C.virError
1487         result := C.virDomainShutdownFlagsWrapper(d.ptr, C.uint(flags), &err)
1488         if result == -1 {
1489                 return makeError(&err)
1490         }
1491         return nil
1492 }
1493
1494 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAttachDevice
1495 func (d *Domain) AttachDevice(xml string) error {
1496         cXml := C.CString(xml)
1497         defer C.free(unsafe.Pointer(cXml))
1498         var err C.virError
1499         result := C.virDomainAttachDeviceWrapper(d.ptr, cXml, &err)
1500         if result == -1 {
1501                 return makeError(&err)
1502         }
1503         return nil
1504 }
1505
1506 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAttachDeviceFlags
1507 func (d *Domain) AttachDeviceFlags(xml string, flags DomainDeviceModifyFlags) error {
1508         cXml := C.CString(xml)
1509         defer C.free(unsafe.Pointer(cXml))
1510         var err C.virError
1511         result := C.virDomainAttachDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags), &err)
1512         if result == -1 {
1513                 return makeError(&err)
1514         }
1515         return nil
1516 }
1517
1518 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDetachDevice
1519 func (d *Domain) DetachDevice(xml string) error {
1520         cXml := C.CString(xml)
1521         defer C.free(unsafe.Pointer(cXml))
1522         var err C.virError
1523         result := C.virDomainDetachDeviceWrapper(d.ptr, cXml, &err)
1524         if result == -1 {
1525                 return makeError(&err)
1526         }
1527         return nil
1528 }
1529
1530 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDetachDeviceFlags
1531 func (d *Domain) DetachDeviceFlags(xml string, flags DomainDeviceModifyFlags) error {
1532         cXml := C.CString(xml)
1533         defer C.free(unsafe.Pointer(cXml))
1534         var err C.virError
1535         result := C.virDomainDetachDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags), &err)
1536         if result == -1 {
1537                 return makeError(&err)
1538         }
1539         return nil
1540 }
1541
1542 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDetachDeviceAlias
1543 func (d *Domain) DetachDeviceAlias(alias string, flags DomainDeviceModifyFlags) error {
1544         if C.LIBVIR_VERSION_NUMBER < 4004000 {
1545                 return makeNotImplementedError("virDomainDetachDeviceAlias")
1546         }
1547
1548         cAlias := C.CString(alias)
1549         defer C.free(unsafe.Pointer(cAlias))
1550         var err C.virError
1551         result := C.virDomainDetachDeviceAliasWrapper(d.ptr, cAlias, C.uint(flags), &err)
1552         if result == -1 {
1553                 return makeError(&err)
1554         }
1555         return nil
1556 }
1557
1558 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainUpdateDeviceFlags
1559 func (d *Domain) UpdateDeviceFlags(xml string, flags DomainDeviceModifyFlags) error {
1560         cXml := C.CString(xml)
1561         defer C.free(unsafe.Pointer(cXml))
1562         var err C.virError
1563         result := C.virDomainUpdateDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags), &err)
1564         if result == -1 {
1565                 return makeError(&err)
1566         }
1567         return nil
1568 }
1569
1570 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainScreenshot
1571 func (d *Domain) Screenshot(stream *Stream, screen, flags uint32) (string, error) {
1572         var err C.virError
1573         cType := C.virDomainScreenshotWrapper(d.ptr, stream.ptr, C.uint(screen), C.uint(flags), &err)
1574         if cType == nil {
1575                 return "", makeError(&err)
1576         }
1577         defer C.free(unsafe.Pointer(cType))
1578
1579         mimeType := C.GoString(cType)
1580         return mimeType, nil
1581 }
1582
1583 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendKey
1584 func (d *Domain) SendKey(codeset, holdtime uint, keycodes []uint, flags uint32) error {
1585         var err C.virError
1586         result := C.virDomainSendKeyWrapper(d.ptr, C.uint(codeset), C.uint(holdtime), (*C.uint)(unsafe.Pointer(&keycodes[0])), C.int(len(keycodes)), C.uint(flags), &err)
1587         if result == -1 {
1588                 return makeError(&err)
1589         }
1590
1591         return nil
1592 }
1593
1594 type DomainBlockStats struct {
1595         RdBytesSet         bool
1596         RdBytes            int64
1597         RdReqSet           bool
1598         RdReq              int64
1599         RdTotalTimesSet    bool
1600         RdTotalTimes       int64
1601         WrBytesSet         bool
1602         WrBytes            int64
1603         WrReqSet           bool
1604         WrReq              int64
1605         WrTotalTimesSet    bool
1606         WrTotalTimes       int64
1607         FlushReqSet        bool
1608         FlushReq           int64
1609         FlushTotalTimesSet bool
1610         FlushTotalTimes    int64
1611         ErrsSet            bool
1612         Errs               int64
1613 }
1614
1615 func getBlockStatsFieldInfo(params *DomainBlockStats) map[string]typedParamsFieldInfo {
1616         return map[string]typedParamsFieldInfo{
1617                 C.VIR_DOMAIN_BLOCK_STATS_READ_BYTES: typedParamsFieldInfo{
1618                         set: &params.RdBytesSet,
1619                         l:   &params.RdBytes,
1620                 },
1621                 C.VIR_DOMAIN_BLOCK_STATS_READ_REQ: typedParamsFieldInfo{
1622                         set: &params.RdReqSet,
1623                         l:   &params.RdReq,
1624                 },
1625                 C.VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES: typedParamsFieldInfo{
1626                         set: &params.RdTotalTimesSet,
1627                         l:   &params.RdTotalTimes,
1628                 },
1629                 C.VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES: typedParamsFieldInfo{
1630                         set: &params.WrBytesSet,
1631                         l:   &params.WrBytes,
1632                 },
1633                 C.VIR_DOMAIN_BLOCK_STATS_WRITE_REQ: typedParamsFieldInfo{
1634                         set: &params.WrReqSet,
1635                         l:   &params.WrReq,
1636                 },
1637                 C.VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES: typedParamsFieldInfo{
1638                         set: &params.WrTotalTimesSet,
1639                         l:   &params.WrTotalTimes,
1640                 },
1641                 C.VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ: typedParamsFieldInfo{
1642                         set: &params.FlushReqSet,
1643                         l:   &params.FlushReq,
1644                 },
1645                 C.VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES: typedParamsFieldInfo{
1646                         set: &params.FlushTotalTimesSet,
1647                         l:   &params.FlushTotalTimes,
1648                 },
1649                 C.VIR_DOMAIN_BLOCK_STATS_ERRS: typedParamsFieldInfo{
1650                         set: &params.ErrsSet,
1651                         l:   &params.Errs,
1652                 },
1653         }
1654 }
1655
1656 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockStatsFlags
1657 func (d *Domain) BlockStatsFlags(disk string, flags uint32) (*DomainBlockStats, error) {
1658         params := &DomainBlockStats{}
1659         info := getBlockStatsFieldInfo(params)
1660
1661         var nparams C.int
1662
1663         cdisk := C.CString(disk)
1664         defer C.free(unsafe.Pointer(cdisk))
1665         var err C.virError
1666         ret := C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &nparams, C.uint(0), &err)
1667         if ret == -1 {
1668                 return nil, makeError(&err)
1669         }
1670
1671         cparams := make([]C.virTypedParameter, nparams)
1672         ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
1673         if ret == -1 {
1674                 return nil, makeError(&err)
1675         }
1676
1677         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
1678
1679         _, gerr := typedParamsUnpack(cparams, info)
1680         if gerr != nil {
1681                 return nil, gerr
1682         }
1683
1684         return params, nil
1685 }
1686
1687 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockStats
1688 func (d *Domain) BlockStats(path string) (*DomainBlockStats, error) {
1689         cPath := C.CString(path)
1690         defer C.free(unsafe.Pointer(cPath))
1691
1692         size := C.size_t(unsafe.Sizeof(C.struct__virDomainBlockStats{}))
1693
1694         cStats := (C.virDomainBlockStatsPtr)(C.malloc(size))
1695         defer C.free(unsafe.Pointer(cStats))
1696
1697         var err C.virError
1698         result := C.virDomainBlockStatsWrapper(d.ptr, cPath, (C.virDomainBlockStatsPtr)(cStats), size, &err)
1699
1700         if result != 0 {
1701                 return nil, makeError(&err)
1702         }
1703         return &DomainBlockStats{
1704                 WrReqSet:   true,
1705                 WrReq:      int64(cStats.wr_req),
1706                 RdReqSet:   true,
1707                 RdReq:      int64(cStats.rd_req),
1708                 RdBytesSet: true,
1709                 RdBytes:    int64(cStats.rd_bytes),
1710                 WrBytesSet: true,
1711                 WrBytes:    int64(cStats.wr_bytes),
1712         }, nil
1713 }
1714
1715 type DomainInterfaceStats struct {
1716         RxBytesSet   bool
1717         RxBytes      int64
1718         RxPacketsSet bool
1719         RxPackets    int64
1720         RxErrsSet    bool
1721         RxErrs       int64
1722         RxDropSet    bool
1723         RxDrop       int64
1724         TxBytesSet   bool
1725         TxBytes      int64
1726         TxPacketsSet bool
1727         TxPackets    int64
1728         TxErrsSet    bool
1729         TxErrs       int64
1730         TxDropSet    bool
1731         TxDrop       int64
1732 }
1733
1734 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainInterfaceStats
1735 func (d *Domain) InterfaceStats(path string) (*DomainInterfaceStats, error) {
1736         cPath := C.CString(path)
1737         defer C.free(unsafe.Pointer(cPath))
1738
1739         size := C.size_t(unsafe.Sizeof(C.struct__virDomainInterfaceStats{}))
1740
1741         cStats := (C.virDomainInterfaceStatsPtr)(C.malloc(size))
1742         defer C.free(unsafe.Pointer(cStats))
1743
1744         var err C.virError
1745         result := C.virDomainInterfaceStatsWrapper(d.ptr, cPath, (C.virDomainInterfaceStatsPtr)(cStats), size, &err)
1746
1747         if result != 0 {
1748                 return nil, makeError(&err)
1749         }
1750         return &DomainInterfaceStats{
1751                 RxBytesSet:   true,
1752                 RxBytes:      int64(cStats.rx_bytes),
1753                 RxPacketsSet: true,
1754                 RxPackets:    int64(cStats.rx_packets),
1755                 RxErrsSet:    true,
1756                 RxErrs:       int64(cStats.rx_errs),
1757                 RxDropSet:    true,
1758                 RxDrop:       int64(cStats.rx_drop),
1759                 TxBytesSet:   true,
1760                 TxBytes:      int64(cStats.tx_bytes),
1761                 TxPacketsSet: true,
1762                 TxPackets:    int64(cStats.tx_packets),
1763                 TxErrsSet:    true,
1764                 TxErrs:       int64(cStats.tx_errs),
1765                 TxDropSet:    true,
1766                 TxDrop:       int64(cStats.tx_drop),
1767         }, nil
1768 }
1769
1770 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryStats
1771 func (d *Domain) MemoryStats(nrStats uint32, flags uint32) ([]DomainMemoryStat, error) {
1772         ptr := make([]C.virDomainMemoryStatStruct, nrStats)
1773
1774         var err C.virError
1775         result := C.virDomainMemoryStatsWrapper(
1776                 d.ptr, (C.virDomainMemoryStatPtr)(unsafe.Pointer(&ptr[0])),
1777                 C.uint(nrStats), C.uint(flags), &err)
1778
1779         if result == -1 {
1780                 return []DomainMemoryStat{}, makeError(&err)
1781         }
1782
1783         out := make([]DomainMemoryStat, 0)
1784         for i := 0; i < int(result); i++ {
1785                 out = append(out, DomainMemoryStat{
1786                         Tag: int32(ptr[i].tag),
1787                         Val: uint64(ptr[i].val),
1788                 })
1789         }
1790         return out, nil
1791 }
1792
1793 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetConnect
1794 //
1795 // Contrary to the native C API behaviour, the Go API will
1796 // acquire a reference on the returned Connect, which must
1797 // be released by calling Close()
1798 func (d *Domain) DomainGetConnect() (*Connect, error) {
1799         var err C.virError
1800         ptr := C.virDomainGetConnectWrapper(d.ptr, &err)
1801         if ptr == nil {
1802                 return nil, makeError(&err)
1803         }
1804
1805         ret := C.virConnectRefWrapper(ptr, &err)
1806         if ret == -1 {
1807                 return nil, makeError(&err)
1808         }
1809
1810         return &Connect{ptr: ptr}, nil
1811 }
1812
1813 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpus
1814 func (d *Domain) GetVcpus() ([]DomainVcpuInfo, error) {
1815         var cnodeinfo C.virNodeInfo
1816         var err C.virError
1817         ret := C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo, &err)
1818         if ret == -1 {
1819                 return []DomainVcpuInfo{}, makeError(&err)
1820         }
1821
1822         var cdominfo C.virDomainInfo
1823         ret = C.virDomainGetInfoWrapper(d.ptr, &cdominfo, &err)
1824         if ret == -1 {
1825                 return []DomainVcpuInfo{}, makeError(&err)
1826         }
1827
1828         nvcpus := int(cdominfo.nrVirtCpu)
1829         npcpus := int(cnodeinfo.nodes * cnodeinfo.sockets * cnodeinfo.cores * cnodeinfo.threads)
1830         maplen := ((npcpus + 7) / 8)
1831         ccpumaps := make([]C.uchar, maplen*nvcpus)
1832         cinfo := make([]C.virVcpuInfo, nvcpus)
1833
1834         ret = C.virDomainGetVcpusWrapper(d.ptr, &cinfo[0], C.int(nvcpus), &ccpumaps[0], C.int(maplen), &err)
1835         if ret == -1 {
1836                 return []DomainVcpuInfo{}, makeError(&err)
1837         }
1838
1839         info := make([]DomainVcpuInfo, int(ret))
1840         for i := 0; i < int(ret); i++ {
1841                 affinity := make([]bool, npcpus)
1842                 for j := 0; j < npcpus; j++ {
1843                         byte := (i * maplen) + (j / 8)
1844                         bit := j % 8
1845
1846                         affinity[j] = (ccpumaps[byte] & (1 << uint(bit))) != 0
1847                 }
1848
1849                 info[i] = DomainVcpuInfo{
1850                         Number:  uint32(cinfo[i].number),
1851                         State:   int32(cinfo[i].state),
1852                         CpuTime: uint64(cinfo[i].cpuTime),
1853                         Cpu:     int32(cinfo[i].cpu),
1854                         CpuMap:  affinity,
1855                 }
1856         }
1857
1858         return info, nil
1859 }
1860
1861 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpusFlags
1862 func (d *Domain) GetVcpusFlags(flags DomainVcpuFlags) (int32, error) {
1863         var err C.virError
1864         result := C.virDomainGetVcpusFlagsWrapper(d.ptr, C.uint(flags), &err)
1865         if result == -1 {
1866                 return 0, makeError(&err)
1867         }
1868         return int32(result), nil
1869 }
1870
1871 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpu
1872 func (d *Domain) PinVcpu(vcpu uint, cpuMap []bool) error {
1873         maplen := (len(cpuMap) + 7) / 8
1874         ccpumap := make([]C.uchar, maplen)
1875         for i := 0; i < len(cpuMap); i++ {
1876                 if cpuMap[i] {
1877                         byte := i / 8
1878                         bit := i % 8
1879                         ccpumap[byte] |= (1 << uint(bit))
1880                 }
1881         }
1882
1883         var err C.virError
1884         result := C.virDomainPinVcpuWrapper(d.ptr, C.uint(vcpu), &ccpumap[0], C.int(maplen), &err)
1885
1886         if result == -1 {
1887                 return makeError(&err)
1888         }
1889
1890         return nil
1891 }
1892
1893 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpuFlags
1894 func (d *Domain) PinVcpuFlags(vcpu uint, cpuMap []bool, flags DomainModificationImpact) error {
1895         maplen := (len(cpuMap) + 7) / 8
1896         ccpumap := make([]C.uchar, maplen)
1897         for i := 0; i < len(cpuMap); i++ {
1898                 if cpuMap[i] {
1899                         byte := i / 8
1900                         bit := i % 8
1901                         ccpumap[byte] |= (1 << uint(bit))
1902                 }
1903         }
1904
1905         var err C.virError
1906         result := C.virDomainPinVcpuFlagsWrapper(d.ptr, C.uint(vcpu), &ccpumap[0], C.int(maplen), C.uint(flags), &err)
1907
1908         if result == -1 {
1909                 return makeError(&err)
1910         }
1911
1912         return nil
1913 }
1914
1915 type DomainIPAddress struct {
1916         Type   int
1917         Addr   string
1918         Prefix uint
1919 }
1920
1921 type DomainInterface struct {
1922         Name   string
1923         Hwaddr string
1924         Addrs  []DomainIPAddress
1925 }
1926
1927 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainInterfaceAddresses
1928 func (d *Domain) ListAllInterfaceAddresses(src DomainInterfaceAddressesSource) ([]DomainInterface, error) {
1929         if C.LIBVIR_VERSION_NUMBER < 1002014 {
1930                 return []DomainInterface{}, makeNotImplementedError("virDomainInterfaceAddresses")
1931         }
1932
1933         var cList *C.virDomainInterfacePtr
1934         var err C.virError
1935         numIfaces := int(C.virDomainInterfaceAddressesWrapper(d.ptr, (**C.virDomainInterfacePtr)(&cList), C.uint(src), 0, &err))
1936         if numIfaces == -1 {
1937                 return nil, makeError(&err)
1938         }
1939
1940         ifaces := make([]DomainInterface, numIfaces)
1941
1942         for i := 0; i < numIfaces; i++ {
1943                 var ciface *C.virDomainInterface
1944                 ciface = *(**C.virDomainInterface)(unsafe.Pointer(uintptr(unsafe.Pointer(cList)) + (unsafe.Sizeof(ciface) * uintptr(i))))
1945
1946                 ifaces[i].Name = C.GoString(ciface.name)
1947                 ifaces[i].Hwaddr = C.GoString(ciface.hwaddr)
1948
1949                 numAddr := int(ciface.naddrs)
1950
1951                 ifaces[i].Addrs = make([]DomainIPAddress, numAddr)
1952
1953                 for k := 0; k < numAddr; k++ {
1954                         var caddr *C.virDomainIPAddress
1955                         caddr = (*C.virDomainIPAddress)(unsafe.Pointer(uintptr(unsafe.Pointer(ciface.addrs)) + (unsafe.Sizeof(*caddr) * uintptr(k))))
1956                         ifaces[i].Addrs[k] = DomainIPAddress{}
1957                         ifaces[i].Addrs[k].Type = int(caddr._type)
1958                         ifaces[i].Addrs[k].Addr = C.GoString(caddr.addr)
1959                         ifaces[i].Addrs[k].Prefix = uint(caddr.prefix)
1960
1961                 }
1962                 C.virDomainInterfaceFreeWrapper(ciface)
1963         }
1964         C.free(unsafe.Pointer(cList))
1965         return ifaces, nil
1966 }
1967
1968 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotCurrent
1969 func (d *Domain) SnapshotCurrent(flags uint32) (*DomainSnapshot, error) {
1970         var err C.virError
1971         result := C.virDomainSnapshotCurrentWrapper(d.ptr, C.uint(flags), &err)
1972         if result == nil {
1973                 return nil, makeError(&err)
1974         }
1975         return &DomainSnapshot{ptr: result}, nil
1976
1977 }
1978
1979 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotNum
1980 func (d *Domain) SnapshotNum(flags DomainSnapshotListFlags) (int, error) {
1981         var err C.virError
1982         result := int(C.virDomainSnapshotNumWrapper(d.ptr, C.uint(flags), &err))
1983         if result == -1 {
1984                 return 0, makeError(&err)
1985         }
1986         return result, nil
1987 }
1988
1989 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotLookupByName
1990 func (d *Domain) SnapshotLookupByName(name string, flags uint32) (*DomainSnapshot, error) {
1991         cName := C.CString(name)
1992         defer C.free(unsafe.Pointer(cName))
1993         var err C.virError
1994         ptr := C.virDomainSnapshotLookupByNameWrapper(d.ptr, cName, C.uint(flags), &err)
1995         if ptr == nil {
1996                 return nil, makeError(&err)
1997         }
1998         return &DomainSnapshot{ptr: ptr}, nil
1999 }
2000
2001 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListNames
2002 func (d *Domain) SnapshotListNames(flags DomainSnapshotListFlags) ([]string, error) {
2003         const maxNames = 1024
2004         var names [maxNames](*C.char)
2005         namesPtr := unsafe.Pointer(&names)
2006         var err C.virError
2007         numNames := C.virDomainSnapshotListNamesWrapper(
2008                 d.ptr,
2009                 (**C.char)(namesPtr),
2010                 maxNames, C.uint(flags), &err)
2011         if numNames == -1 {
2012                 return nil, makeError(&err)
2013         }
2014         goNames := make([]string, numNames)
2015         for k := 0; k < int(numNames); k++ {
2016                 goNames[k] = C.GoString(names[k])
2017                 C.free(unsafe.Pointer(names[k]))
2018         }
2019         return goNames, nil
2020 }
2021
2022 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainListAllSnapshots
2023 func (d *Domain) ListAllSnapshots(flags DomainSnapshotListFlags) ([]DomainSnapshot, error) {
2024         var cList *C.virDomainSnapshotPtr
2025         var err C.virError
2026         numVols := C.virDomainListAllSnapshotsWrapper(d.ptr, (**C.virDomainSnapshotPtr)(&cList), C.uint(flags), &err)
2027         if numVols == -1 {
2028                 return nil, makeError(&err)
2029         }
2030         hdr := reflect.SliceHeader{
2031                 Data: uintptr(unsafe.Pointer(cList)),
2032                 Len:  int(numVols),
2033                 Cap:  int(numVols),
2034         }
2035         var pools []DomainSnapshot
2036         slice := *(*[]C.virDomainSnapshotPtr)(unsafe.Pointer(&hdr))
2037         for _, ptr := range slice {
2038                 pools = append(pools, DomainSnapshot{ptr})
2039         }
2040         C.free(unsafe.Pointer(cList))
2041         return pools, nil
2042 }
2043
2044 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCommit
2045 func (d *Domain) BlockCommit(disk string, base string, top string, bandwidth uint64, flags DomainBlockCommitFlags) error {
2046         cdisk := C.CString(disk)
2047         defer C.free(unsafe.Pointer(cdisk))
2048         var cbase *C.char
2049         if base != "" {
2050                 cbase = C.CString(base)
2051                 defer C.free(unsafe.Pointer(cbase))
2052         }
2053         var ctop *C.char
2054         if top != "" {
2055                 ctop = C.CString(top)
2056                 defer C.free(unsafe.Pointer(ctop))
2057         }
2058         var err C.virError
2059         ret := C.virDomainBlockCommitWrapper(d.ptr, cdisk, cbase, ctop, C.ulong(bandwidth), C.uint(flags), &err)
2060         if ret == -1 {
2061                 return makeError(&err)
2062         }
2063         return nil
2064 }
2065
2066 type DomainBlockCopyParameters struct {
2067         BandwidthSet   bool
2068         Bandwidth      uint64
2069         GranularitySet bool
2070         Granularity    uint
2071         BufSizeSet     bool
2072         BufSize        uint64
2073 }
2074
2075 func getBlockCopyParameterFieldInfo(params *DomainBlockCopyParameters) map[string]typedParamsFieldInfo {
2076         return map[string]typedParamsFieldInfo{
2077                 C.VIR_DOMAIN_BLOCK_COPY_BANDWIDTH: typedParamsFieldInfo{
2078                         set: &params.BandwidthSet,
2079                         ul:  &params.Bandwidth,
2080                 },
2081                 C.VIR_DOMAIN_BLOCK_COPY_GRANULARITY: typedParamsFieldInfo{
2082                         set: &params.GranularitySet,
2083                         ui:  &params.Granularity,
2084                 },
2085                 C.VIR_DOMAIN_BLOCK_COPY_BUF_SIZE: typedParamsFieldInfo{
2086                         set: &params.BufSizeSet,
2087                         ul:  &params.BufSize,
2088                 },
2089         }
2090 }
2091
2092 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCopy
2093 func (d *Domain) BlockCopy(disk string, destxml string, params *DomainBlockCopyParameters, flags DomainBlockCopyFlags) error {
2094         if C.LIBVIR_VERSION_NUMBER < 1002008 {
2095                 return makeNotImplementedError("virDomainBlockCopy")
2096         }
2097         cdisk := C.CString(disk)
2098         defer C.free(unsafe.Pointer(cdisk))
2099         cdestxml := C.CString(destxml)
2100         defer C.free(unsafe.Pointer(cdestxml))
2101
2102         info := getBlockCopyParameterFieldInfo(params)
2103
2104         cparams, gerr := typedParamsPackNew(info)
2105         if gerr != nil {
2106                 return gerr
2107         }
2108         nparams := len(*cparams)
2109
2110         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams))
2111
2112         var err C.virError
2113         ret := C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags), &err)
2114         if ret == -1 {
2115                 return makeError(&err)
2116         }
2117
2118         return nil
2119 }
2120
2121 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobAbort
2122 func (d *Domain) BlockJobAbort(disk string, flags DomainBlockJobAbortFlags) error {
2123         cdisk := C.CString(disk)
2124         defer C.free(unsafe.Pointer(cdisk))
2125         var err C.virError
2126         ret := C.virDomainBlockJobAbortWrapper(d.ptr, cdisk, C.uint(flags), &err)
2127         if ret == -1 {
2128                 return makeError(&err)
2129         }
2130         return nil
2131 }
2132
2133 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobSetSpeed
2134 func (d *Domain) BlockJobSetSpeed(disk string, bandwidth uint64, flags DomainBlockJobSetSpeedFlags) error {
2135         cdisk := C.CString(disk)
2136         defer C.free(unsafe.Pointer(cdisk))
2137         var err C.virError
2138         ret := C.virDomainBlockJobSetSpeedWrapper(d.ptr, cdisk, C.ulong(bandwidth), C.uint(flags), &err)
2139         if ret == -1 {
2140                 return makeError(&err)
2141         }
2142         return nil
2143 }
2144
2145 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPull
2146 func (d *Domain) BlockPull(disk string, bandwidth uint64, flags DomainBlockPullFlags) error {
2147         cdisk := C.CString(disk)
2148         defer C.free(unsafe.Pointer(cdisk))
2149         var err C.virError
2150         ret := C.virDomainBlockPullWrapper(d.ptr, cdisk, C.ulong(bandwidth), C.uint(flags), &err)
2151         if ret == -1 {
2152                 return makeError(&err)
2153         }
2154         return nil
2155 }
2156
2157 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockRebase
2158 func (d *Domain) BlockRebase(disk string, base string, bandwidth uint64, flags DomainBlockRebaseFlags) error {
2159         cdisk := C.CString(disk)
2160         defer C.free(unsafe.Pointer(cdisk))
2161         var cbase *C.char
2162         if base != "" {
2163                 cbase := C.CString(base)
2164                 defer C.free(unsafe.Pointer(cbase))
2165         }
2166         var err C.virError
2167         ret := C.virDomainBlockRebaseWrapper(d.ptr, cdisk, cbase, C.ulong(bandwidth), C.uint(flags), &err)
2168         if ret == -1 {
2169                 return makeError(&err)
2170         }
2171         return nil
2172 }
2173
2174 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockResize
2175 func (d *Domain) BlockResize(disk string, size uint64, flags DomainBlockResizeFlags) error {
2176         cdisk := C.CString(disk)
2177         defer C.free(unsafe.Pointer(cdisk))
2178         var err C.virError
2179         ret := C.virDomainBlockResizeWrapper(d.ptr, cdisk, C.ulonglong(size), C.uint(flags), &err)
2180         if ret == -1 {
2181                 return makeError(&err)
2182         }
2183         return nil
2184 }
2185
2186 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPeek
2187 func (d *Domain) BlockPeek(disk string, offset uint64, size uint64, flags uint32) ([]byte, error) {
2188         cdisk := C.CString(disk)
2189         defer C.free(unsafe.Pointer(cdisk))
2190         data := make([]byte, size)
2191         var err C.virError
2192         ret := C.virDomainBlockPeekWrapper(d.ptr, cdisk, C.ulonglong(offset), C.size_t(size),
2193                 unsafe.Pointer(&data[0]), C.uint(flags), &err)
2194         if ret == -1 {
2195                 return []byte{}, makeError(&err)
2196         }
2197
2198         return data, nil
2199 }
2200
2201 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryPeek
2202 func (d *Domain) MemoryPeek(start uint64, size uint64, flags DomainMemoryFlags) ([]byte, error) {
2203         data := make([]byte, size)
2204         var err C.virError
2205         ret := C.virDomainMemoryPeekWrapper(d.ptr, C.ulonglong(start), C.size_t(size),
2206                 unsafe.Pointer(&data[0]), C.uint(flags), &err)
2207         if ret == -1 {
2208                 return []byte{}, makeError(&err)
2209         }
2210
2211         return data, nil
2212 }
2213
2214 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate
2215 func (d *Domain) Migrate(dconn *Connect, flags DomainMigrateFlags, dname string, uri string, bandwidth uint64) (*Domain, error) {
2216         var cdname *C.char
2217         if dname != "" {
2218                 cdname = C.CString(dname)
2219                 defer C.free(unsafe.Pointer(cdname))
2220         }
2221         var curi *C.char
2222         if uri != "" {
2223                 curi = C.CString(uri)
2224                 defer C.free(unsafe.Pointer(curi))
2225         }
2226
2227         var err C.virError
2228         ret := C.virDomainMigrateWrapper(d.ptr, dconn.ptr, C.ulong(flags), cdname, curi, C.ulong(bandwidth), &err)
2229         if ret == nil {
2230                 return nil, makeError(&err)
2231         }
2232
2233         return &Domain{
2234                 ptr: ret,
2235         }, nil
2236 }
2237
2238 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate2
2239 func (d *Domain) Migrate2(dconn *Connect, dxml string, flags DomainMigrateFlags, dname string, uri string, bandwidth uint64) (*Domain, error) {
2240         var cdxml *C.char
2241         if dxml != "" {
2242                 cdxml = C.CString(dxml)
2243                 defer C.free(unsafe.Pointer(cdxml))
2244         }
2245         var cdname *C.char
2246         if dname != "" {
2247                 cdname = C.CString(dname)
2248                 defer C.free(unsafe.Pointer(cdname))
2249         }
2250         var curi *C.char
2251         if uri != "" {
2252                 curi = C.CString(uri)
2253                 defer C.free(unsafe.Pointer(curi))
2254         }
2255
2256         var err C.virError
2257         ret := C.virDomainMigrate2Wrapper(d.ptr, dconn.ptr, cdxml, C.ulong(flags), cdname, curi, C.ulong(bandwidth), &err)
2258         if ret == nil {
2259                 return nil, makeError(&err)
2260         }
2261
2262         return &Domain{
2263                 ptr: ret,
2264         }, nil
2265 }
2266
2267 type DomainMigrateParameters struct {
2268         URISet                    bool
2269         URI                       string
2270         DestNameSet               bool
2271         DestName                  string
2272         DestXMLSet                bool
2273         DestXML                   string
2274         PersistXMLSet             bool
2275         PersistXML                string
2276         BandwidthSet              bool
2277         Bandwidth                 uint64
2278         GraphicsURISet            bool
2279         GraphicsURI               string
2280         ListenAddressSet          bool
2281         ListenAddress             string
2282         MigrateDisksSet           bool
2283         MigrateDisks              []string
2284         DisksPortSet              bool
2285         DisksPort                 int
2286         CompressionSet            bool
2287         Compression               string
2288         CompressionMTLevelSet     bool
2289         CompressionMTLevel        int
2290         CompressionMTThreadsSet   bool
2291         CompressionMTThreads      int
2292         CompressionMTDThreadsSet  bool
2293         CompressionMTDThreads     int
2294         CompressionXBZRLECacheSet bool
2295         CompressionXBZRLECache    uint64
2296         AutoConvergeInitialSet    bool
2297         AutoConvergeInitial       int
2298         AutoConvergeIncrementSet  bool
2299         AutoConvergeIncrement     int
2300 }
2301
2302 func getMigrateParameterFieldInfo(params *DomainMigrateParameters) map[string]typedParamsFieldInfo {
2303         return map[string]typedParamsFieldInfo{
2304                 C.VIR_MIGRATE_PARAM_URI: typedParamsFieldInfo{
2305                         set: &params.URISet,
2306                         s:   &params.URI,
2307                 },
2308                 C.VIR_MIGRATE_PARAM_DEST_NAME: typedParamsFieldInfo{
2309                         set: &params.DestNameSet,
2310                         s:   &params.DestName,
2311                 },
2312                 C.VIR_MIGRATE_PARAM_DEST_XML: typedParamsFieldInfo{
2313                         set: &params.DestXMLSet,
2314                         s:   &params.DestXML,
2315                 },
2316                 C.VIR_MIGRATE_PARAM_PERSIST_XML: typedParamsFieldInfo{
2317                         set: &params.PersistXMLSet,
2318                         s:   &params.PersistXML,
2319                 },
2320                 C.VIR_MIGRATE_PARAM_BANDWIDTH: typedParamsFieldInfo{
2321                         set: &params.BandwidthSet,
2322                         ul:  &params.Bandwidth,
2323                 },
2324                 C.VIR_MIGRATE_PARAM_GRAPHICS_URI: typedParamsFieldInfo{
2325                         set: &params.GraphicsURISet,
2326                         s:   &params.GraphicsURI,
2327                 },
2328                 C.VIR_MIGRATE_PARAM_LISTEN_ADDRESS: typedParamsFieldInfo{
2329                         set: &params.ListenAddressSet,
2330                         s:   &params.ListenAddress,
2331                 },
2332                 C.VIR_MIGRATE_PARAM_MIGRATE_DISKS: typedParamsFieldInfo{
2333                         set: &params.MigrateDisksSet,
2334                         sl:  &params.MigrateDisks,
2335                 },
2336                 C.VIR_MIGRATE_PARAM_DISKS_PORT: typedParamsFieldInfo{
2337                         set: &params.DisksPortSet,
2338                         i:   &params.DisksPort,
2339                 },
2340                 C.VIR_MIGRATE_PARAM_COMPRESSION: typedParamsFieldInfo{
2341                         set: &params.CompressionSet,
2342                         s:   &params.Compression,
2343                 },
2344                 C.VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL: typedParamsFieldInfo{
2345                         set: &params.CompressionMTLevelSet,
2346                         i:   &params.CompressionMTLevel,
2347                 },
2348                 C.VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS: typedParamsFieldInfo{
2349                         set: &params.CompressionMTThreadsSet,
2350                         i:   &params.CompressionMTThreads,
2351                 },
2352                 C.VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS: typedParamsFieldInfo{
2353                         set: &params.CompressionMTDThreadsSet,
2354                         i:   &params.CompressionMTDThreads,
2355                 },
2356                 C.VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE: typedParamsFieldInfo{
2357                         set: &params.CompressionXBZRLECacheSet,
2358                         ul:  &params.CompressionXBZRLECache,
2359                 },
2360                 C.VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL: typedParamsFieldInfo{
2361                         set: &params.AutoConvergeInitialSet,
2362                         i:   &params.AutoConvergeInitial,
2363                 },
2364                 C.VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT: typedParamsFieldInfo{
2365                         set: &params.AutoConvergeIncrementSet,
2366                         i:   &params.AutoConvergeIncrement,
2367                 },
2368         }
2369 }
2370
2371 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate3
2372 func (d *Domain) Migrate3(dconn *Connect, params *DomainMigrateParameters, flags DomainMigrateFlags) (*Domain, error) {
2373
2374         info := getMigrateParameterFieldInfo(params)
2375         cparams, gerr := typedParamsPackNew(info)
2376         if gerr != nil {
2377                 return nil, gerr
2378         }
2379         nparams := len(*cparams)
2380
2381         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams))
2382
2383         var err C.virError
2384         ret := C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &err)
2385         if ret == nil {
2386                 return nil, makeError(&err)
2387         }
2388
2389         return &Domain{
2390                 ptr: ret,
2391         }, nil
2392 }
2393
2394 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI
2395 func (d *Domain) MigrateToURI(duri string, flags DomainMigrateFlags, dname string, bandwidth uint64) error {
2396         cduri := C.CString(duri)
2397         defer C.free(unsafe.Pointer(cduri))
2398
2399         var cdname *C.char
2400         if dname != "" {
2401                 cdname = C.CString(dname)
2402                 defer C.free(unsafe.Pointer(cdname))
2403         }
2404
2405         var err C.virError
2406         ret := C.virDomainMigrateToURIWrapper(d.ptr, cduri, C.ulong(flags), cdname, C.ulong(bandwidth), &err)
2407         if ret == -1 {
2408                 return makeError(&err)
2409         }
2410
2411         return nil
2412 }
2413
2414 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI2
2415 func (d *Domain) MigrateToURI2(dconnuri string, miguri string, dxml string, flags DomainMigrateFlags, dname string, bandwidth uint64) error {
2416         var cdconnuri *C.char
2417         if dconnuri != "" {
2418                 cdconnuri = C.CString(dconnuri)
2419                 defer C.free(unsafe.Pointer(cdconnuri))
2420         }
2421         var cmiguri *C.char
2422         if miguri != "" {
2423                 cmiguri = C.CString(miguri)
2424                 defer C.free(unsafe.Pointer(cmiguri))
2425         }
2426         var cdxml *C.char
2427         if dxml != "" {
2428                 cdxml = C.CString(dxml)
2429                 defer C.free(unsafe.Pointer(cdxml))
2430         }
2431         var cdname *C.char
2432         if dname != "" {
2433                 cdname = C.CString(dname)
2434                 defer C.free(unsafe.Pointer(cdname))
2435         }
2436
2437         var err C.virError
2438         ret := C.virDomainMigrateToURI2Wrapper(d.ptr, cdconnuri, cmiguri, cdxml, C.ulong(flags), cdname, C.ulong(bandwidth), &err)
2439         if ret == -1 {
2440                 return makeError(&err)
2441         }
2442
2443         return nil
2444 }
2445
2446 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI3
2447 func (d *Domain) MigrateToURI3(dconnuri string, params *DomainMigrateParameters, flags DomainMigrateFlags) error {
2448         var cdconnuri *C.char
2449         if dconnuri != "" {
2450                 cdconnuri = C.CString(dconnuri)
2451                 defer C.free(unsafe.Pointer(cdconnuri))
2452         }
2453
2454         info := getMigrateParameterFieldInfo(params)
2455         cparams, gerr := typedParamsPackNew(info)
2456         if gerr != nil {
2457                 return gerr
2458         }
2459         nparams := len(*cparams)
2460
2461         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams))
2462
2463         var err C.virError
2464         ret := C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &err)
2465         if ret == -1 {
2466                 return makeError(&err)
2467         }
2468
2469         return nil
2470 }
2471
2472 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetCompressionCache
2473 func (d *Domain) MigrateGetCompressionCache(flags uint32) (uint64, error) {
2474         var cacheSize C.ulonglong
2475
2476         var err C.virError
2477         ret := C.virDomainMigrateGetCompressionCacheWrapper(d.ptr, &cacheSize, C.uint(flags), &err)
2478         if ret == -1 {
2479                 return 0, makeError(&err)
2480         }
2481
2482         return uint64(cacheSize), nil
2483 }
2484
2485 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetCompressionCache
2486 func (d *Domain) MigrateSetCompressionCache(size uint64, flags uint32) error {
2487         var err C.virError
2488         ret := C.virDomainMigrateSetCompressionCacheWrapper(d.ptr, C.ulonglong(size), C.uint(flags), &err)
2489         if ret == -1 {
2490                 return makeError(&err)
2491         }
2492
2493         return nil
2494 }
2495
2496 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetMaxSpeed
2497 func (d *Domain) MigrateGetMaxSpeed(flags uint32) (uint64, error) {
2498         var maxSpeed C.ulong
2499
2500         var err C.virError
2501         ret := C.virDomainMigrateGetMaxSpeedWrapper(d.ptr, &maxSpeed, C.uint(flags), &err)
2502         if ret == -1 {
2503                 return 0, makeError(&err)
2504         }
2505
2506         return uint64(maxSpeed), nil
2507 }
2508
2509 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed
2510 func (d *Domain) MigrateSetMaxSpeed(speed uint64, flags uint32) error {
2511         var err C.virError
2512         ret := C.virDomainMigrateSetMaxSpeedWrapper(d.ptr, C.ulong(speed), C.uint(flags), &err)
2513         if ret == -1 {
2514                 return makeError(&err)
2515         }
2516
2517         return nil
2518 }
2519
2520 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxDowntime
2521 func (d *Domain) MigrateSetMaxDowntime(downtime uint64, flags uint32) error {
2522         var err C.virError
2523         ret := C.virDomainMigrateSetMaxDowntimeWrapper(d.ptr, C.ulonglong(downtime), C.uint(flags), &err)
2524         if ret == -1 {
2525                 return makeError(&err)
2526         }
2527
2528         return nil
2529 }
2530
2531 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetMaxDowntime
2532 func (d *Domain) MigrateGetMaxDowntime(flags uint32) (uint64, error) {
2533         var downtimeLen C.ulonglong
2534
2535         if C.LIBVIR_VERSION_NUMBER < 3007000 {
2536                 return 0, makeNotImplementedError("virDomainMigrateGetMaxDowntime")
2537         }
2538
2539         var err C.virError
2540         ret := C.virDomainMigrateGetMaxDowntimeWrapper(d.ptr, &downtimeLen, C.uint(flags), &err)
2541         if ret == -1 {
2542                 return 0, makeError(&err)
2543         }
2544
2545         return uint64(downtimeLen), nil
2546 }
2547
2548 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateStartPostCopy
2549 func (d *Domain) MigrateStartPostCopy(flags uint32) error {
2550         if C.LIBVIR_VERSION_NUMBER < 1003003 {
2551                 return makeNotImplementedError("virDomainMigrateStartPostCopy")
2552         }
2553
2554         var err C.virError
2555         ret := C.virDomainMigrateStartPostCopyWrapper(d.ptr, C.uint(flags), &err)
2556         if ret == -1 {
2557                 return makeError(&err)
2558         }
2559
2560         return nil
2561 }
2562
2563 type DomainBlkioParameters struct {
2564         WeightSet          bool
2565         Weight             uint
2566         DeviceWeightSet    bool
2567         DeviceWeight       string
2568         DeviceReadIopsSet  bool
2569         DeviceReadIops     string
2570         DeviceWriteIopsSet bool
2571         DeviceWriteIops    string
2572         DeviceReadBpsSet   bool
2573         DeviceReadBps      string
2574         DeviceWriteBpsSet  bool
2575         DeviceWriteBps     string
2576 }
2577
2578 func getBlkioParametersFieldInfo(params *DomainBlkioParameters) map[string]typedParamsFieldInfo {
2579         return map[string]typedParamsFieldInfo{
2580                 C.VIR_DOMAIN_BLKIO_WEIGHT: typedParamsFieldInfo{
2581                         set: &params.WeightSet,
2582                         ui:  &params.Weight,
2583                 },
2584                 C.VIR_DOMAIN_BLKIO_DEVICE_WEIGHT: typedParamsFieldInfo{
2585                         set: &params.DeviceWeightSet,
2586                         s:   &params.DeviceWeight,
2587                 },
2588                 C.VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS: typedParamsFieldInfo{
2589                         set: &params.DeviceReadIopsSet,
2590                         s:   &params.DeviceReadIops,
2591                 },
2592                 C.VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS: typedParamsFieldInfo{
2593                         set: &params.DeviceWriteIopsSet,
2594                         s:   &params.DeviceWriteIops,
2595                 },
2596                 C.VIR_DOMAIN_BLKIO_DEVICE_READ_BPS: typedParamsFieldInfo{
2597                         set: &params.DeviceReadBpsSet,
2598                         s:   &params.DeviceReadBps,
2599                 },
2600                 C.VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS: typedParamsFieldInfo{
2601                         set: &params.DeviceWriteBpsSet,
2602                         s:   &params.DeviceWriteBps,
2603                 },
2604         }
2605 }
2606
2607 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlkioParameters
2608 func (d *Domain) GetBlkioParameters(flags DomainModificationImpact) (*DomainBlkioParameters, error) {
2609         params := &DomainBlkioParameters{}
2610         info := getBlkioParametersFieldInfo(params)
2611
2612         var nparams C.int
2613         var err C.virError
2614         ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err)
2615         if ret == -1 {
2616                 return nil, makeError(&err)
2617         }
2618
2619         cparams := make([]C.virTypedParameter, nparams)
2620         ret = C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
2621         if ret == -1 {
2622                 return nil, makeError(&err)
2623         }
2624
2625         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
2626
2627         _, gerr := typedParamsUnpack(cparams, info)
2628         if gerr != nil {
2629                 return nil, gerr
2630         }
2631
2632         return params, nil
2633 }
2634
2635 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlkioParameters
2636 func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags DomainModificationImpact) error {
2637         info := getBlkioParametersFieldInfo(params)
2638
2639         var nparams C.int
2640
2641         var err C.virError
2642         ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err)
2643         if ret == -1 {
2644                 return makeError(&err)
2645         }
2646
2647         cparams := make([]C.virTypedParameter, nparams)
2648         ret = C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
2649         if ret == -1 {
2650                 return makeError(&err)
2651         }
2652
2653         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
2654
2655         gerr := typedParamsPack(cparams, info)
2656         if gerr != nil {
2657                 return gerr
2658         }
2659
2660         ret = C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
2661
2662         return nil
2663 }
2664
2665 type DomainBlockIoTuneParameters struct {
2666         TotalBytesSecSet          bool
2667         TotalBytesSec             uint64
2668         ReadBytesSecSet           bool
2669         ReadBytesSec              uint64
2670         WriteBytesSecSet          bool
2671         WriteBytesSec             uint64
2672         TotalIopsSecSet           bool
2673         TotalIopsSec              uint64
2674         ReadIopsSecSet            bool
2675         ReadIopsSec               uint64
2676         WriteIopsSecSet           bool
2677         WriteIopsSec              uint64
2678         TotalBytesSecMaxSet       bool
2679         TotalBytesSecMax          uint64
2680         ReadBytesSecMaxSet        bool
2681         ReadBytesSecMax           uint64
2682         WriteBytesSecMaxSet       bool
2683         WriteBytesSecMax          uint64
2684         TotalIopsSecMaxSet        bool
2685         TotalIopsSecMax           uint64
2686         ReadIopsSecMaxSet         bool
2687         ReadIopsSecMax            uint64
2688         WriteIopsSecMaxSet        bool
2689         WriteIopsSecMax           uint64
2690         TotalBytesSecMaxLengthSet bool
2691         TotalBytesSecMaxLength    uint64
2692         ReadBytesSecMaxLengthSet  bool
2693         ReadBytesSecMaxLength     uint64
2694         WriteBytesSecMaxLengthSet bool
2695         WriteBytesSecMaxLength    uint64
2696         TotalIopsSecMaxLengthSet  bool
2697         TotalIopsSecMaxLength     uint64
2698         ReadIopsSecMaxLengthSet   bool
2699         ReadIopsSecMaxLength      uint64
2700         WriteIopsSecMaxLengthSet  bool
2701         WriteIopsSecMaxLength     uint64
2702         SizeIopsSecSet            bool
2703         SizeIopsSec               uint64
2704         GroupNameSet              bool
2705         GroupName                 string
2706 }
2707
2708 func getBlockIoTuneParametersFieldInfo(params *DomainBlockIoTuneParameters) map[string]typedParamsFieldInfo {
2709         return map[string]typedParamsFieldInfo{
2710                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC: typedParamsFieldInfo{
2711                         set: &params.TotalBytesSecSet,
2712                         ul:  &params.TotalBytesSec,
2713                 },
2714                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC: typedParamsFieldInfo{
2715                         set: &params.ReadBytesSecSet,
2716                         ul:  &params.ReadBytesSec,
2717                 },
2718                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC: typedParamsFieldInfo{
2719                         set: &params.WriteBytesSecSet,
2720                         ul:  &params.WriteBytesSec,
2721                 },
2722                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC: typedParamsFieldInfo{
2723                         set: &params.TotalIopsSecSet,
2724                         ul:  &params.TotalIopsSec,
2725                 },
2726                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC: typedParamsFieldInfo{
2727                         set: &params.ReadIopsSecSet,
2728                         ul:  &params.ReadIopsSec,
2729                 },
2730                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC: typedParamsFieldInfo{
2731                         set: &params.WriteIopsSecSet,
2732                         ul:  &params.WriteIopsSec,
2733                 },
2734                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC_MAX: typedParamsFieldInfo{
2735                         set: &params.TotalBytesSecMaxSet,
2736                         ul:  &params.TotalBytesSecMax,
2737                 },
2738                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC_MAX: typedParamsFieldInfo{
2739                         set: &params.ReadBytesSecMaxSet,
2740                         ul:  &params.ReadBytesSecMax,
2741                 },
2742                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC_MAX: typedParamsFieldInfo{
2743                         set: &params.WriteBytesSecMaxSet,
2744                         ul:  &params.WriteBytesSecMax,
2745                 },
2746                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC_MAX: typedParamsFieldInfo{
2747                         set: &params.TotalIopsSecMaxSet,
2748                         ul:  &params.TotalIopsSecMax,
2749                 },
2750                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC_MAX: typedParamsFieldInfo{
2751                         set: &params.ReadIopsSecMaxSet,
2752                         ul:  &params.ReadIopsSecMax,
2753                 },
2754                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC_MAX: typedParamsFieldInfo{
2755                         set: &params.WriteIopsSecMaxSet,
2756                         ul:  &params.WriteIopsSecMax,
2757                 },
2758                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
2759                         set: &params.TotalBytesSecMaxLengthSet,
2760                         ul:  &params.TotalBytesSecMaxLength,
2761                 },
2762                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
2763                         set: &params.ReadBytesSecMaxLengthSet,
2764                         ul:  &params.ReadBytesSecMaxLength,
2765                 },
2766                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
2767                         set: &params.WriteBytesSecMaxLengthSet,
2768                         ul:  &params.WriteBytesSecMaxLength,
2769                 },
2770                 C.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
2771                         set: &params.TotalIopsSecMaxLengthSet,
2772                         ul:  &params.TotalIopsSecMaxLength,
2773                 },
2774                 C.VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
2775                         set: &params.ReadIopsSecMaxLengthSet,
2776                         ul:  &params.ReadIopsSecMaxLength,
2777                 },
2778                 C.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
2779                         set: &params.WriteIopsSecMaxLengthSet,
2780                         ul:  &params.WriteIopsSecMaxLength,
2781                 },
2782                 C.VIR_DOMAIN_BLOCK_IOTUNE_SIZE_IOPS_SEC: typedParamsFieldInfo{
2783                         set: &params.SizeIopsSecSet,
2784                         ul:  &params.SizeIopsSec,
2785                 },
2786                 C.VIR_DOMAIN_BLOCK_IOTUNE_GROUP_NAME: typedParamsFieldInfo{
2787                         set: &params.GroupNameSet,
2788                         s:   &params.GroupName,
2789                 },
2790         }
2791 }
2792
2793 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockIoTune
2794 func (d *Domain) GetBlockIoTune(disk string, flags DomainModificationImpact) (*DomainBlockIoTuneParameters, error) {
2795         cdisk := C.CString(disk)
2796         defer C.free(unsafe.Pointer(cdisk))
2797
2798         params := &DomainBlockIoTuneParameters{}
2799         info := getBlockIoTuneParametersFieldInfo(params)
2800
2801         var nparams C.int
2802         var err C.virError
2803         ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err)
2804         if ret == -1 {
2805                 return nil, makeError(&err)
2806         }
2807
2808         cparams := make([]C.virTypedParameter, nparams)
2809         ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
2810         if ret == -1 {
2811                 return nil, makeError(&err)
2812         }
2813
2814         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
2815
2816         _, gerr := typedParamsUnpack(cparams, info)
2817         if gerr != nil {
2818                 return nil, gerr
2819         }
2820
2821         return params, nil
2822 }
2823
2824 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlockIoTune
2825 func (d *Domain) SetBlockIoTune(disk string, params *DomainBlockIoTuneParameters, flags DomainModificationImpact) error {
2826         cdisk := C.CString(disk)
2827         defer C.free(unsafe.Pointer(cdisk))
2828
2829         info := getBlockIoTuneParametersFieldInfo(params)
2830
2831         var nparams C.int
2832
2833         var err C.virError
2834         ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err)
2835         if ret == -1 {
2836                 return makeError(&err)
2837         }
2838
2839         cparams := make([]C.virTypedParameter, nparams)
2840         ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
2841         if ret == -1 {
2842                 return makeError(&err)
2843         }
2844
2845         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
2846
2847         gerr := typedParamsPack(cparams, info)
2848         if gerr != nil {
2849                 return gerr
2850         }
2851
2852         ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
2853
2854         return nil
2855 }
2856
2857 type DomainBlockJobInfo struct {
2858         Type      DomainBlockJobType
2859         Bandwidth uint64
2860         Cur       uint64
2861         End       uint64
2862 }
2863
2864 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockJobInfo
2865 func (d *Domain) GetBlockJobInfo(disk string, flags DomainBlockJobInfoFlags) (*DomainBlockJobInfo, error) {
2866         cdisk := C.CString(disk)
2867         defer C.free(unsafe.Pointer(cdisk))
2868
2869         var cinfo C.virDomainBlockJobInfo
2870
2871         var err C.virError
2872         ret := C.virDomainGetBlockJobInfoWrapper(d.ptr, cdisk, &cinfo, C.uint(flags), &err)
2873
2874         if ret == -1 {
2875                 return nil, makeError(&err)
2876         }
2877
2878         return &DomainBlockJobInfo{
2879                 Type:      DomainBlockJobType(cinfo._type),
2880                 Bandwidth: uint64(cinfo.bandwidth),
2881                 Cur:       uint64(cinfo.cur),
2882                 End:       uint64(cinfo.end),
2883         }, nil
2884 }
2885
2886 type DomainControlInfo struct {
2887         State     DomainControlState
2888         Details   int
2889         StateTime uint64
2890 }
2891
2892 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetControlInfo
2893 func (d *Domain) GetControlInfo(flags uint32) (*DomainControlInfo, error) {
2894
2895         var cinfo C.virDomainControlInfo
2896
2897         var err C.virError
2898         ret := C.virDomainGetControlInfoWrapper(d.ptr, &cinfo, C.uint(flags), &err)
2899         if ret == -1 {
2900                 return nil, makeError(&err)
2901         }
2902
2903         return &DomainControlInfo{
2904                 State:     DomainControlState(cinfo.state),
2905                 Details:   int(cinfo.details),
2906                 StateTime: uint64(cinfo.stateTime),
2907         }, nil
2908 }
2909
2910 type DomainDiskError struct {
2911         Disk  string
2912         Error DomainDiskErrorCode
2913 }
2914
2915 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetDiskErrors
2916 func (d *Domain) GetDiskErrors(flags uint32) ([]DomainDiskError, error) {
2917         var err C.virError
2918         ret := C.virDomainGetDiskErrorsWrapper(d.ptr, nil, 0, 0, &err)
2919         if ret == -1 {
2920                 return []DomainDiskError{}, makeError(&err)
2921         }
2922
2923         maxerrors := ret
2924         cerrors := make([]C.virDomainDiskError, maxerrors)
2925
2926         ret = C.virDomainGetDiskErrorsWrapper(d.ptr, (*C.virDomainDiskError)(unsafe.Pointer(&cerrors[0])), C.uint(maxerrors), C.uint(flags), &err)
2927         if ret == -1 {
2928                 return []DomainDiskError{}, makeError(&err)
2929         }
2930
2931         errors := make([]DomainDiskError, maxerrors)
2932
2933         for i, cerror := range cerrors {
2934                 errors[i] = DomainDiskError{
2935                         Disk:  C.GoString(cerror.disk),
2936                         Error: DomainDiskErrorCode(cerror.error),
2937                 }
2938                 C.free(unsafe.Pointer(cerror.disk))
2939         }
2940
2941         return errors, nil
2942 }
2943
2944 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetHostname
2945 func (d *Domain) GetHostname(flags uint32) (string, error) {
2946         var err C.virError
2947         ret := C.virDomainGetHostnameWrapper(d.ptr, C.uint(flags), &err)
2948         if ret == nil {
2949                 return "", makeError(&err)
2950         }
2951
2952         defer C.free(unsafe.Pointer(ret))
2953
2954         return C.GoString(ret), nil
2955 }
2956
2957 type DomainJobInfo struct {
2958         Type                      DomainJobType
2959         TimeElapsedSet            bool
2960         TimeElapsed               uint64
2961         TimeElapsedNetSet         bool
2962         TimeElapsedNet            uint64
2963         TimeRemainingSet          bool
2964         TimeRemaining             uint64
2965         DowntimeSet               bool
2966         Downtime                  uint64
2967         DowntimeNetSet            bool
2968         DowntimeNet               uint64
2969         SetupTimeSet              bool
2970         SetupTime                 uint64
2971         DataTotalSet              bool
2972         DataTotal                 uint64
2973         DataProcessedSet          bool
2974         DataProcessed             uint64
2975         DataRemainingSet          bool
2976         DataRemaining             uint64
2977         MemTotalSet               bool
2978         MemTotal                  uint64
2979         MemProcessedSet           bool
2980         MemProcessed              uint64
2981         MemRemainingSet           bool
2982         MemRemaining              uint64
2983         MemConstantSet            bool
2984         MemConstant               uint64
2985         MemNormalSet              bool
2986         MemNormal                 uint64
2987         MemNormalBytesSet         bool
2988         MemNormalBytes            uint64
2989         MemBpsSet                 bool
2990         MemBps                    uint64
2991         MemDirtyRateSet           bool
2992         MemDirtyRate              uint64
2993         MemPageSizeSet            bool
2994         MemPageSize               uint64
2995         MemIterationSet           bool
2996         MemIteration              uint64
2997         DiskTotalSet              bool
2998         DiskTotal                 uint64
2999         DiskProcessedSet          bool
3000         DiskProcessed             uint64
3001         DiskRemainingSet          bool
3002         DiskRemaining             uint64
3003         DiskBpsSet                bool
3004         DiskBps                   uint64
3005         CompressionCacheSet       bool
3006         CompressionCache          uint64
3007         CompressionBytesSet       bool
3008         CompressionBytes          uint64
3009         CompressionPagesSet       bool
3010         CompressionPages          uint64
3011         CompressionCacheMissesSet bool
3012         CompressionCacheMisses    uint64
3013         CompressionOverflowSet    bool
3014         CompressionOverflow       uint64
3015         AutoConvergeThrottleSet   bool
3016         AutoConvergeThrottle      int
3017         OperationSet              bool
3018         Operation                 DomainJobOperationType
3019 }
3020
3021 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobInfo
3022 func (d *Domain) GetJobInfo() (*DomainJobInfo, error) {
3023         var cinfo C.virDomainJobInfo
3024
3025         var err C.virError
3026         ret := C.virDomainGetJobInfoWrapper(d.ptr, &cinfo, &err)
3027         if ret == -1 {
3028                 return nil, makeError(&err)
3029         }
3030
3031         return &DomainJobInfo{
3032                 Type:             DomainJobType(cinfo._type),
3033                 TimeElapsedSet:   true,
3034                 TimeElapsed:      uint64(cinfo.timeElapsed),
3035                 TimeRemainingSet: true,
3036                 TimeRemaining:    uint64(cinfo.timeRemaining),
3037                 DataTotalSet:     true,
3038                 DataTotal:        uint64(cinfo.dataTotal),
3039                 DataProcessedSet: true,
3040                 DataProcessed:    uint64(cinfo.dataProcessed),
3041                 DataRemainingSet: true,
3042                 DataRemaining:    uint64(cinfo.dataRemaining),
3043                 MemTotalSet:      true,
3044                 MemTotal:         uint64(cinfo.memTotal),
3045                 MemProcessedSet:  true,
3046                 MemProcessed:     uint64(cinfo.memProcessed),
3047                 MemRemainingSet:  true,
3048                 MemRemaining:     uint64(cinfo.memRemaining),
3049                 DiskTotalSet:     true,
3050                 DiskTotal:        uint64(cinfo.fileTotal),
3051                 DiskProcessedSet: true,
3052                 DiskProcessed:    uint64(cinfo.fileProcessed),
3053                 DiskRemainingSet: true,
3054                 DiskRemaining:    uint64(cinfo.fileRemaining),
3055         }, nil
3056 }
3057
3058 func getDomainJobInfoFieldInfo(params *DomainJobInfo) map[string]typedParamsFieldInfo {
3059         return map[string]typedParamsFieldInfo{
3060                 C.VIR_DOMAIN_JOB_TIME_ELAPSED: typedParamsFieldInfo{
3061                         set: &params.TimeElapsedSet,
3062                         ul:  &params.TimeElapsed,
3063                 },
3064                 C.VIR_DOMAIN_JOB_TIME_ELAPSED_NET: typedParamsFieldInfo{
3065                         set: &params.TimeElapsedNetSet,
3066                         ul:  &params.TimeElapsedNet,
3067                 },
3068                 C.VIR_DOMAIN_JOB_TIME_REMAINING: typedParamsFieldInfo{
3069                         set: &params.TimeRemainingSet,
3070                         ul:  &params.TimeRemaining,
3071                 },
3072                 C.VIR_DOMAIN_JOB_DOWNTIME: typedParamsFieldInfo{
3073                         set: &params.DowntimeSet,
3074                         ul:  &params.Downtime,
3075                 },
3076                 C.VIR_DOMAIN_JOB_DOWNTIME_NET: typedParamsFieldInfo{
3077                         set: &params.DowntimeNetSet,
3078                         ul:  &params.DowntimeNet,
3079                 },
3080                 C.VIR_DOMAIN_JOB_SETUP_TIME: typedParamsFieldInfo{
3081                         set: &params.SetupTimeSet,
3082                         ul:  &params.SetupTime,
3083                 },
3084                 C.VIR_DOMAIN_JOB_DATA_TOTAL: typedParamsFieldInfo{
3085                         set: &params.DataTotalSet,
3086                         ul:  &params.DataTotal,
3087                 },
3088                 C.VIR_DOMAIN_JOB_DATA_PROCESSED: typedParamsFieldInfo{
3089                         set: &params.DataProcessedSet,
3090                         ul:  &params.DataProcessed,
3091                 },
3092                 C.VIR_DOMAIN_JOB_DATA_REMAINING: typedParamsFieldInfo{
3093                         set: &params.DataRemainingSet,
3094                         ul:  &params.DataRemaining,
3095                 },
3096                 C.VIR_DOMAIN_JOB_MEMORY_TOTAL: typedParamsFieldInfo{
3097                         set: &params.MemTotalSet,
3098                         ul:  &params.MemTotal,
3099                 },
3100                 C.VIR_DOMAIN_JOB_MEMORY_PROCESSED: typedParamsFieldInfo{
3101                         set: &params.MemProcessedSet,
3102                         ul:  &params.MemProcessed,
3103                 },
3104                 C.VIR_DOMAIN_JOB_MEMORY_REMAINING: typedParamsFieldInfo{
3105                         set: &params.MemRemainingSet,
3106                         ul:  &params.MemRemaining,
3107                 },
3108                 C.VIR_DOMAIN_JOB_MEMORY_CONSTANT: typedParamsFieldInfo{
3109                         set: &params.MemConstantSet,
3110                         ul:  &params.MemConstant,
3111                 },
3112                 C.VIR_DOMAIN_JOB_MEMORY_NORMAL: typedParamsFieldInfo{
3113                         set: &params.MemNormalSet,
3114                         ul:  &params.MemNormal,
3115                 },
3116                 C.VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES: typedParamsFieldInfo{
3117                         set: &params.MemNormalBytesSet,
3118                         ul:  &params.MemNormalBytes,
3119                 },
3120                 C.VIR_DOMAIN_JOB_MEMORY_BPS: typedParamsFieldInfo{
3121                         set: &params.MemBpsSet,
3122                         ul:  &params.MemBps,
3123                 },
3124                 C.VIR_DOMAIN_JOB_MEMORY_DIRTY_RATE: typedParamsFieldInfo{
3125                         set: &params.MemDirtyRateSet,
3126                         ul:  &params.MemDirtyRate,
3127                 },
3128                 C.VIR_DOMAIN_JOB_MEMORY_PAGE_SIZE: typedParamsFieldInfo{
3129                         set: &params.MemPageSizeSet,
3130                         ul:  &params.MemPageSize,
3131                 },
3132                 C.VIR_DOMAIN_JOB_MEMORY_ITERATION: typedParamsFieldInfo{
3133                         set: &params.MemIterationSet,
3134                         ul:  &params.MemIteration,
3135                 },
3136                 C.VIR_DOMAIN_JOB_DISK_TOTAL: typedParamsFieldInfo{
3137                         set: &params.DiskTotalSet,
3138                         ul:  &params.DiskTotal,
3139                 },
3140                 C.VIR_DOMAIN_JOB_DISK_PROCESSED: typedParamsFieldInfo{
3141                         set: &params.DiskProcessedSet,
3142                         ul:  &params.DiskProcessed,
3143                 },
3144                 C.VIR_DOMAIN_JOB_DISK_REMAINING: typedParamsFieldInfo{
3145                         set: &params.DiskRemainingSet,
3146                         ul:  &params.DiskRemaining,
3147                 },
3148                 C.VIR_DOMAIN_JOB_DISK_BPS: typedParamsFieldInfo{
3149                         set: &params.DiskBpsSet,
3150                         ul:  &params.DiskBps,
3151                 },
3152                 C.VIR_DOMAIN_JOB_COMPRESSION_CACHE: typedParamsFieldInfo{
3153                         set: &params.CompressionCacheSet,
3154                         ul:  &params.CompressionCache,
3155                 },
3156                 C.VIR_DOMAIN_JOB_COMPRESSION_BYTES: typedParamsFieldInfo{
3157                         set: &params.CompressionBytesSet,
3158                         ul:  &params.CompressionBytes,
3159                 },
3160                 C.VIR_DOMAIN_JOB_COMPRESSION_PAGES: typedParamsFieldInfo{
3161                         set: &params.CompressionPagesSet,
3162                         ul:  &params.CompressionPages,
3163                 },
3164                 C.VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES: typedParamsFieldInfo{
3165                         set: &params.CompressionCacheMissesSet,
3166                         ul:  &params.CompressionCacheMisses,
3167                 },
3168                 C.VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW: typedParamsFieldInfo{
3169                         set: &params.CompressionOverflowSet,
3170                         ul:  &params.CompressionOverflow,
3171                 },
3172                 C.VIR_DOMAIN_JOB_AUTO_CONVERGE_THROTTLE: typedParamsFieldInfo{
3173                         set: &params.AutoConvergeThrottleSet,
3174                         i:   &params.AutoConvergeThrottle,
3175                 },
3176                 C.VIR_DOMAIN_JOB_OPERATION: typedParamsFieldInfo{
3177                         set: &params.OperationSet,
3178                         i:   (*int)(&params.Operation),
3179                 },
3180         }
3181 }
3182
3183 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats
3184 func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags) (*DomainJobInfo, error) {
3185         var cparams *C.virTypedParameter
3186         var nparams C.int
3187         var jobtype C.int
3188         var err C.virError
3189         ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err)
3190         if ret == -1 {
3191                 return nil, makeError(&err)
3192         }
3193         defer C.virTypedParamsFree(cparams, nparams)
3194
3195         params := DomainJobInfo{}
3196         info := getDomainJobInfoFieldInfo(&params)
3197
3198         _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
3199         if gerr != nil {
3200                 return nil, gerr
3201         }
3202
3203         return &params, nil
3204 }
3205
3206 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxMemory
3207 func (d *Domain) GetMaxMemory() (uint64, error) {
3208         var err C.virError
3209         ret := C.virDomainGetMaxMemoryWrapper(d.ptr, &err)
3210         if ret == 0 {
3211                 return 0, makeError(&err)
3212         }
3213
3214         return uint64(ret), nil
3215 }
3216
3217 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxVcpus
3218 func (d *Domain) GetMaxVcpus() (uint, error) {
3219         var err C.virError
3220         ret := C.virDomainGetMaxVcpusWrapper(d.ptr, &err)
3221         if ret == -1 {
3222                 return 0, makeError(&err)
3223         }
3224
3225         return uint(ret), nil
3226 }
3227
3228 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetOSType
3229 func (d *Domain) GetOSType() (string, error) {
3230         var err C.virError
3231         ret := C.virDomainGetOSTypeWrapper(d.ptr, &err)
3232         if ret == nil {
3233                 return "", makeError(&err)
3234         }
3235
3236         defer C.free(unsafe.Pointer(ret))
3237
3238         return C.GoString(ret), nil
3239 }
3240
3241 type DomainMemoryParameters struct {
3242         HardLimitSet     bool
3243         HardLimit        uint64
3244         SoftLimitSet     bool
3245         SoftLimit        uint64
3246         MinGuaranteeSet  bool
3247         MinGuarantee     uint64
3248         SwapHardLimitSet bool
3249         SwapHardLimit    uint64
3250 }
3251
3252 func getDomainMemoryParametersFieldInfo(params *DomainMemoryParameters) map[string]typedParamsFieldInfo {
3253         return map[string]typedParamsFieldInfo{
3254                 C.VIR_DOMAIN_MEMORY_HARD_LIMIT: typedParamsFieldInfo{
3255                         set: &params.HardLimitSet,
3256                         ul:  &params.HardLimit,
3257                 },
3258                 C.VIR_DOMAIN_MEMORY_SOFT_LIMIT: typedParamsFieldInfo{
3259                         set: &params.SoftLimitSet,
3260                         ul:  &params.SoftLimit,
3261                 },
3262                 C.VIR_DOMAIN_MEMORY_MIN_GUARANTEE: typedParamsFieldInfo{
3263                         set: &params.MinGuaranteeSet,
3264                         ul:  &params.MinGuarantee,
3265                 },
3266                 C.VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT: typedParamsFieldInfo{
3267                         set: &params.SwapHardLimitSet,
3268                         ul:  &params.SwapHardLimit,
3269                 },
3270         }
3271 }
3272
3273 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMemoryParameters
3274 func (d *Domain) GetMemoryParameters(flags DomainModificationImpact) (*DomainMemoryParameters, error) {
3275         params := &DomainMemoryParameters{}
3276         info := getDomainMemoryParametersFieldInfo(params)
3277
3278         var nparams C.int
3279         var err C.virError
3280         ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err)
3281         if ret == -1 {
3282                 return nil, makeError(&err)
3283         }
3284
3285         cparams := make([]C.virTypedParameter, nparams)
3286         ret = C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
3287         if ret == -1 {
3288                 return nil, makeError(&err)
3289         }
3290
3291         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3292
3293         _, gerr := typedParamsUnpack(cparams, info)
3294         if gerr != nil {
3295                 return nil, gerr
3296         }
3297
3298         return params, nil
3299 }
3300
3301 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryParameters
3302 func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags DomainModificationImpact) error {
3303         info := getDomainMemoryParametersFieldInfo(params)
3304
3305         var nparams C.int
3306
3307         var err C.virError
3308         ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err)
3309         if ret == -1 {
3310                 return makeError(&err)
3311         }
3312
3313         cparams := make([]C.virTypedParameter, nparams)
3314         ret = C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
3315         if ret == -1 {
3316                 return makeError(&err)
3317         }
3318
3319         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3320
3321         gerr := typedParamsPack(cparams, info)
3322         if gerr != nil {
3323                 return gerr
3324         }
3325
3326         ret = C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
3327
3328         return nil
3329 }
3330
3331 type DomainNumaParameters struct {
3332         NodesetSet bool
3333         Nodeset    string
3334         ModeSet    bool
3335         Mode       DomainNumatuneMemMode
3336 }
3337
3338 func getDomainNumaParametersFieldInfo(params *DomainNumaParameters) map[string]typedParamsFieldInfo {
3339         return map[string]typedParamsFieldInfo{
3340                 C.VIR_DOMAIN_NUMA_NODESET: typedParamsFieldInfo{
3341                         set: &params.NodesetSet,
3342                         s:   &params.Nodeset,
3343                 },
3344                 C.VIR_DOMAIN_NUMA_MODE: typedParamsFieldInfo{
3345                         set: &params.ModeSet,
3346                         i:   (*int)(&params.Mode),
3347                 },
3348         }
3349 }
3350
3351 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetNumaParameters
3352 func (d *Domain) GetNumaParameters(flags DomainModificationImpact) (*DomainNumaParameters, error) {
3353         params := &DomainNumaParameters{}
3354         info := getDomainNumaParametersFieldInfo(params)
3355
3356         var nparams C.int
3357         var err C.virError
3358         ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err)
3359         if ret == -1 {
3360                 return nil, makeError(&err)
3361         }
3362
3363         cparams := make([]C.virTypedParameter, nparams)
3364         ret = C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
3365         if ret == -1 {
3366                 return nil, makeError(&err)
3367         }
3368
3369         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3370
3371         _, gerr := typedParamsUnpack(cparams, info)
3372         if gerr != nil {
3373                 return nil, gerr
3374         }
3375
3376         return params, nil
3377 }
3378
3379 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetNumaParameters
3380 func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags DomainModificationImpact) error {
3381         info := getDomainNumaParametersFieldInfo(params)
3382
3383         var nparams C.int
3384
3385         var err C.virError
3386         ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err)
3387         if ret == -1 {
3388                 return makeError(&err)
3389         }
3390
3391         cparams := make([]C.virTypedParameter, nparams)
3392         ret = C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
3393         if ret == -1 {
3394                 return makeError(&err)
3395         }
3396
3397         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3398
3399         gerr := typedParamsPack(cparams, info)
3400         if gerr != nil {
3401                 return gerr
3402         }
3403
3404         ret = C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
3405
3406         return nil
3407 }
3408
3409 type DomainPerfEvents struct {
3410         CmtSet                   bool
3411         Cmt                      bool
3412         MbmtSet                  bool
3413         Mbmt                     bool
3414         MbmlSet                  bool
3415         Mbml                     bool
3416         CacheMissesSet           bool
3417         CacheMisses              bool
3418         CacheReferencesSet       bool
3419         CacheReferences          bool
3420         InstructionsSet          bool
3421         Instructions             bool
3422         CpuCyclesSet             bool
3423         CpuCycles                bool
3424         BranchInstructionsSet    bool
3425         BranchInstructions       bool
3426         BranchMissesSet          bool
3427         BranchMisses             bool
3428         BusCyclesSet             bool
3429         BusCycles                bool
3430         StalledCyclesFrontendSet bool
3431         StalledCyclesFrontend    bool
3432         StalledCyclesBackendSet  bool
3433         StalledCyclesBackend     bool
3434         RefCpuCyclesSet          bool
3435         RefCpuCycles             bool
3436         CpuClockSet              bool
3437         CpuClock                 bool
3438         TaskClockSet             bool
3439         TaskClock                bool
3440         PageFaultsSet            bool
3441         PageFaults               bool
3442         ContextSwitchesSet       bool
3443         ContextSwitches          bool
3444         CpuMigrationsSet         bool
3445         CpuMigrations            bool
3446         PageFaultsMinSet         bool
3447         PageFaultsMin            bool
3448         PageFaultsMajSet         bool
3449         PageFaultsMaj            bool
3450         AlignmentFaultsSet       bool
3451         AlignmentFaults          bool
3452         EmulationFaultsSet       bool
3453         EmulationFaults          bool
3454 }
3455
3456 /* Remember to also update DomainStatsPerf in connect.go when adding to the stuct above */
3457
3458 func getDomainPerfEventsFieldInfo(params *DomainPerfEvents) map[string]typedParamsFieldInfo {
3459         return map[string]typedParamsFieldInfo{
3460                 C.VIR_PERF_PARAM_CMT: typedParamsFieldInfo{
3461                         set: &params.CmtSet,
3462                         b:   &params.Cmt,
3463                 },
3464                 C.VIR_PERF_PARAM_MBMT: typedParamsFieldInfo{
3465                         set: &params.MbmtSet,
3466                         b:   &params.Mbmt,
3467                 },
3468                 C.VIR_PERF_PARAM_MBML: typedParamsFieldInfo{
3469                         set: &params.MbmlSet,
3470                         b:   &params.Mbml,
3471                 },
3472                 C.VIR_PERF_PARAM_CACHE_MISSES: typedParamsFieldInfo{
3473                         set: &params.CacheMissesSet,
3474                         b:   &params.CacheMisses,
3475                 },
3476                 C.VIR_PERF_PARAM_CACHE_REFERENCES: typedParamsFieldInfo{
3477                         set: &params.CacheReferencesSet,
3478                         b:   &params.CacheReferences,
3479                 },
3480                 C.VIR_PERF_PARAM_INSTRUCTIONS: typedParamsFieldInfo{
3481                         set: &params.InstructionsSet,
3482                         b:   &params.Instructions,
3483                 },
3484                 C.VIR_PERF_PARAM_CPU_CYCLES: typedParamsFieldInfo{
3485                         set: &params.CpuCyclesSet,
3486                         b:   &params.CpuCycles,
3487                 },
3488                 C.VIR_PERF_PARAM_BRANCH_INSTRUCTIONS: typedParamsFieldInfo{
3489                         set: &params.BranchInstructionsSet,
3490                         b:   &params.BranchInstructions,
3491                 },
3492                 C.VIR_PERF_PARAM_BRANCH_MISSES: typedParamsFieldInfo{
3493                         set: &params.BranchMissesSet,
3494                         b:   &params.BranchMisses,
3495                 },
3496                 C.VIR_PERF_PARAM_BUS_CYCLES: typedParamsFieldInfo{
3497                         set: &params.BusCyclesSet,
3498                         b:   &params.BusCycles,
3499                 },
3500                 C.VIR_PERF_PARAM_STALLED_CYCLES_FRONTEND: typedParamsFieldInfo{
3501                         set: &params.StalledCyclesFrontendSet,
3502                         b:   &params.StalledCyclesFrontend,
3503                 },
3504                 C.VIR_PERF_PARAM_STALLED_CYCLES_BACKEND: typedParamsFieldInfo{
3505                         set: &params.StalledCyclesBackendSet,
3506                         b:   &params.StalledCyclesBackend,
3507                 },
3508                 C.VIR_PERF_PARAM_REF_CPU_CYCLES: typedParamsFieldInfo{
3509                         set: &params.RefCpuCyclesSet,
3510                         b:   &params.RefCpuCycles,
3511                 },
3512                 C.VIR_PERF_PARAM_CPU_CLOCK: typedParamsFieldInfo{
3513                         set: &params.CpuClockSet,
3514                         b:   &params.CpuClock,
3515                 },
3516                 C.VIR_PERF_PARAM_TASK_CLOCK: typedParamsFieldInfo{
3517                         set: &params.TaskClockSet,
3518                         b:   &params.TaskClock,
3519                 },
3520                 C.VIR_PERF_PARAM_PAGE_FAULTS: typedParamsFieldInfo{
3521                         set: &params.PageFaultsSet,
3522                         b:   &params.PageFaults,
3523                 },
3524                 C.VIR_PERF_PARAM_CONTEXT_SWITCHES: typedParamsFieldInfo{
3525                         set: &params.ContextSwitchesSet,
3526                         b:   &params.ContextSwitches,
3527                 },
3528                 C.VIR_PERF_PARAM_CPU_MIGRATIONS: typedParamsFieldInfo{
3529                         set: &params.CpuMigrationsSet,
3530                         b:   &params.CpuMigrations,
3531                 },
3532                 C.VIR_PERF_PARAM_PAGE_FAULTS_MIN: typedParamsFieldInfo{
3533                         set: &params.PageFaultsMinSet,
3534                         b:   &params.PageFaultsMin,
3535                 },
3536                 C.VIR_PERF_PARAM_PAGE_FAULTS_MAJ: typedParamsFieldInfo{
3537                         set: &params.PageFaultsMajSet,
3538                         b:   &params.PageFaultsMaj,
3539                 },
3540                 C.VIR_PERF_PARAM_ALIGNMENT_FAULTS: typedParamsFieldInfo{
3541                         set: &params.AlignmentFaultsSet,
3542                         b:   &params.AlignmentFaults,
3543                 },
3544                 C.VIR_PERF_PARAM_EMULATION_FAULTS: typedParamsFieldInfo{
3545                         set: &params.EmulationFaultsSet,
3546                         b:   &params.EmulationFaults,
3547                 },
3548         }
3549 }
3550
3551 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetPerfEvents
3552 func (d *Domain) GetPerfEvents(flags DomainModificationImpact) (*DomainPerfEvents, error) {
3553         if C.LIBVIR_VERSION_NUMBER < 1003003 {
3554                 return nil, makeNotImplementedError("virDomainGetPerfEvents")
3555         }
3556
3557         params := &DomainPerfEvents{}
3558         info := getDomainPerfEventsFieldInfo(params)
3559
3560         var cparams *C.virTypedParameter
3561         var nparams C.int
3562         var err C.virError
3563         ret := C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err)
3564         if ret == -1 {
3565                 return nil, makeError(&err)
3566         }
3567
3568         defer C.virTypedParamsFree(cparams, nparams)
3569
3570         _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
3571         if gerr != nil {
3572                 return nil, gerr
3573         }
3574
3575         return params, nil
3576 }
3577
3578 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetPerfEvents
3579 func (d *Domain) SetPerfEvents(params *DomainPerfEvents, flags DomainModificationImpact) error {
3580         if C.LIBVIR_VERSION_NUMBER < 1003003 {
3581                 return makeNotImplementedError("virDomainSetPerfEvents")
3582         }
3583
3584         info := getDomainPerfEventsFieldInfo(params)
3585
3586         var cparams *C.virTypedParameter
3587         var nparams C.int
3588         var err C.virError
3589         ret := C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err)
3590         if ret == -1 {
3591                 return makeError(&err)
3592         }
3593
3594         defer C.virTypedParamsFree(cparams, nparams)
3595
3596         gerr := typedParamsPackLen(cparams, int(nparams), info)
3597         if gerr != nil {
3598                 return gerr
3599         }
3600
3601         ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(flags), &err)
3602
3603         return nil
3604 }
3605
3606 type DomainSchedulerParameters struct {
3607         Type              string
3608         CpuSharesSet      bool
3609         CpuShares         uint64
3610         GlobalPeriodSet   bool
3611         GlobalPeriod      uint64
3612         GlobalQuotaSet    bool
3613         GlobalQuota       int64
3614         VcpuPeriodSet     bool
3615         VcpuPeriod        uint64
3616         VcpuQuotaSet      bool
3617         VcpuQuota         int64
3618         EmulatorPeriodSet bool
3619         EmulatorPeriod    uint64
3620         EmulatorQuotaSet  bool
3621         EmulatorQuota     int64
3622         IothreadPeriodSet bool
3623         IothreadPeriod    uint64
3624         IothreadQuotaSet  bool
3625         IothreadQuota     int64
3626         WeightSet         bool
3627         Weight            uint
3628         CapSet            bool
3629         Cap               uint
3630         ReservationSet    bool
3631         Reservation       int64
3632         LimitSet          bool
3633         Limit             int64
3634         SharesSet         bool
3635         Shares            int
3636 }
3637
3638 func getDomainSchedulerParametersFieldInfo(params *DomainSchedulerParameters) map[string]typedParamsFieldInfo {
3639         return map[string]typedParamsFieldInfo{
3640                 C.VIR_DOMAIN_SCHEDULER_CPU_SHARES: typedParamsFieldInfo{
3641                         set: &params.CpuSharesSet,
3642                         ul:  &params.CpuShares,
3643                 },
3644                 C.VIR_DOMAIN_SCHEDULER_GLOBAL_PERIOD: typedParamsFieldInfo{
3645                         set: &params.GlobalPeriodSet,
3646                         ul:  &params.GlobalPeriod,
3647                 },
3648                 C.VIR_DOMAIN_SCHEDULER_GLOBAL_QUOTA: typedParamsFieldInfo{
3649                         set: &params.GlobalQuotaSet,
3650                         l:   &params.GlobalQuota,
3651                 },
3652                 C.VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD: typedParamsFieldInfo{
3653                         set: &params.EmulatorPeriodSet,
3654                         ul:  &params.EmulatorPeriod,
3655                 },
3656                 C.VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA: typedParamsFieldInfo{
3657                         set: &params.EmulatorQuotaSet,
3658                         l:   &params.EmulatorQuota,
3659                 },
3660                 C.VIR_DOMAIN_SCHEDULER_VCPU_PERIOD: typedParamsFieldInfo{
3661                         set: &params.VcpuPeriodSet,
3662                         ul:  &params.VcpuPeriod,
3663                 },
3664                 C.VIR_DOMAIN_SCHEDULER_VCPU_QUOTA: typedParamsFieldInfo{
3665                         set: &params.VcpuQuotaSet,
3666                         l:   &params.VcpuQuota,
3667                 },
3668                 C.VIR_DOMAIN_SCHEDULER_IOTHREAD_PERIOD: typedParamsFieldInfo{
3669                         set: &params.IothreadPeriodSet,
3670                         ul:  &params.IothreadPeriod,
3671                 },
3672                 C.VIR_DOMAIN_SCHEDULER_IOTHREAD_QUOTA: typedParamsFieldInfo{
3673                         set: &params.IothreadQuotaSet,
3674                         l:   &params.IothreadQuota,
3675                 },
3676                 C.VIR_DOMAIN_SCHEDULER_WEIGHT: typedParamsFieldInfo{
3677                         set: &params.WeightSet,
3678                         ui:  &params.Weight,
3679                 },
3680                 C.VIR_DOMAIN_SCHEDULER_CAP: typedParamsFieldInfo{
3681                         set: &params.CapSet,
3682                         ui:  &params.Cap,
3683                 },
3684                 C.VIR_DOMAIN_SCHEDULER_RESERVATION: typedParamsFieldInfo{
3685                         set: &params.ReservationSet,
3686                         l:   &params.Reservation,
3687                 },
3688                 C.VIR_DOMAIN_SCHEDULER_LIMIT: typedParamsFieldInfo{
3689                         set: &params.LimitSet,
3690                         l:   &params.Limit,
3691                 },
3692                 C.VIR_DOMAIN_SCHEDULER_SHARES: typedParamsFieldInfo{
3693                         set: &params.SharesSet,
3694                         i:   &params.Shares,
3695                 },
3696         }
3697 }
3698
3699 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerParameters
3700 func (d *Domain) GetSchedulerParameters() (*DomainSchedulerParameters, error) {
3701         params := &DomainSchedulerParameters{}
3702         info := getDomainSchedulerParametersFieldInfo(params)
3703
3704         var nparams C.int
3705         var err C.virError
3706         schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
3707         if schedtype == nil {
3708                 return nil, makeError(&err)
3709         }
3710
3711         defer C.free(unsafe.Pointer(schedtype))
3712         if nparams == 0 {
3713                 return &DomainSchedulerParameters{
3714                         Type: C.GoString(schedtype),
3715                 }, nil
3716         }
3717
3718         cparams := make([]C.virTypedParameter, nparams)
3719         ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err)
3720         if ret == -1 {
3721                 return nil, makeError(&err)
3722         }
3723         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3724
3725         _, gerr := typedParamsUnpack(cparams, info)
3726         if gerr != nil {
3727                 return nil, gerr
3728         }
3729
3730         return params, nil
3731 }
3732
3733 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerParametersFlags
3734 func (d *Domain) GetSchedulerParametersFlags(flags DomainModificationImpact) (*DomainSchedulerParameters, error) {
3735         params := &DomainSchedulerParameters{}
3736         info := getDomainSchedulerParametersFieldInfo(params)
3737
3738         var nparams C.int
3739         var err C.virError
3740         schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
3741         if schedtype == nil {
3742                 return nil, makeError(&err)
3743         }
3744
3745         defer C.free(unsafe.Pointer(schedtype))
3746         if nparams == 0 {
3747                 return &DomainSchedulerParameters{
3748                         Type: C.GoString(schedtype),
3749                 }, nil
3750         }
3751
3752         cparams := make([]C.virTypedParameter, nparams)
3753         ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
3754         if ret == -1 {
3755                 return nil, makeError(&err)
3756         }
3757         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3758
3759         _, gerr := typedParamsUnpack(cparams, info)
3760         if gerr != nil {
3761                 return nil, gerr
3762         }
3763
3764         return params, nil
3765 }
3766
3767 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetSchedulerParameters
3768 func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters) error {
3769         info := getDomainSchedulerParametersFieldInfo(params)
3770
3771         var nparams C.int
3772         var err C.virError
3773         schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
3774         if schedtype == nil {
3775                 return makeError(&err)
3776         }
3777
3778         defer C.free(unsafe.Pointer(schedtype))
3779         if nparams == 0 {
3780                 return nil
3781         }
3782
3783         cparams := make([]C.virTypedParameter, nparams)
3784         ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err)
3785         if ret == -1 {
3786                 return makeError(&err)
3787         }
3788         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3789
3790         gerr := typedParamsPack(cparams, info)
3791         if gerr != nil {
3792                 return gerr
3793         }
3794
3795         ret = C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, &err)
3796
3797         return nil
3798 }
3799
3800 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetSchedulerParametersFlags
3801 func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParameters, flags DomainModificationImpact) error {
3802         info := getDomainSchedulerParametersFieldInfo(params)
3803
3804         var nparams C.int
3805         var err C.virError
3806         schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
3807         if schedtype == nil {
3808                 return makeError(&err)
3809         }
3810
3811         defer C.free(unsafe.Pointer(schedtype))
3812         if nparams == 0 {
3813                 return nil
3814         }
3815
3816         cparams := make([]C.virTypedParameter, nparams)
3817         ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
3818         if ret == -1 {
3819                 return makeError(&err)
3820         }
3821         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
3822
3823         gerr := typedParamsPack(cparams, info)
3824         if gerr != nil {
3825                 return gerr
3826         }
3827
3828         ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
3829
3830         return nil
3831 }
3832
3833 type SecurityLabel struct {
3834         Label     string
3835         Enforcing bool
3836 }
3837
3838 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabel
3839 func (d *Domain) GetSecurityLabel() (*SecurityLabel, error) {
3840         var clabel C.virSecurityLabel
3841
3842         var err C.virError
3843         ret := C.virDomainGetSecurityLabelWrapper(d.ptr, &clabel, &err)
3844         if ret == -1 {
3845                 return nil, makeError(&err)
3846         }
3847
3848         return &SecurityLabel{
3849                 Label:     C.GoString((*C.char)(unsafe.Pointer(&clabel.label))),
3850                 Enforcing: clabel.enforcing == 1,
3851         }, nil
3852 }
3853
3854 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabelList
3855 func (d *Domain) GetSecurityLabelList() ([]SecurityLabel, error) {
3856         var clabels *C.virSecurityLabel
3857
3858         var err C.virError
3859         ret := C.virDomainGetSecurityLabelListWrapper(d.ptr, (*C.virSecurityLabelPtr)(unsafe.Pointer(&clabels)), &err)
3860         if ret == -1 {
3861                 return []SecurityLabel{}, makeError(&err)
3862         }
3863
3864         labels := make([]SecurityLabel, ret)
3865         for i := 0; i < int(ret); i++ {
3866                 var clabel *C.virSecurityLabel
3867                 clabel = (*C.virSecurityLabel)(unsafe.Pointer(uintptr(unsafe.Pointer(clabels)) + (unsafe.Sizeof(*clabel) * uintptr(i))))
3868                 labels[i] = SecurityLabel{
3869                         Label:     C.GoString((*C.char)(unsafe.Pointer(&clabel.label))),
3870                         Enforcing: clabel.enforcing == 1,
3871                 }
3872         }
3873
3874         return labels, nil
3875 }
3876
3877 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetTime
3878 func (d *Domain) GetTime(flags uint32) (int64, uint, error) {
3879         if C.LIBVIR_VERSION_NUMBER < 1002005 {
3880                 return 0, 0, makeNotImplementedError("virDomainGetTime")
3881         }
3882         var secs C.longlong
3883         var nsecs C.uint
3884         var err C.virError
3885         ret := C.virDomainGetTimeWrapper(d.ptr, &secs, &nsecs, C.uint(flags), &err)
3886         if ret == -1 {
3887                 return 0, 0, makeError(&err)
3888         }
3889
3890         return int64(secs), uint(nsecs), nil
3891 }
3892
3893 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetTime
3894 func (d *Domain) SetTime(secs int64, nsecs uint, flags DomainSetTimeFlags) error {
3895         if C.LIBVIR_VERSION_NUMBER < 1002005 {
3896                 return makeNotImplementedError("virDomainSetTime")
3897         }
3898
3899         var err C.virError
3900         ret := C.virDomainSetTimeWrapper(d.ptr, C.longlong(secs), C.uint(nsecs), C.uint(flags), &err)
3901         if ret == -1 {
3902                 return makeError(&err)
3903         }
3904
3905         return nil
3906 }
3907
3908 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetUserPassword
3909 func (d *Domain) SetUserPassword(user string, password string, flags DomainSetUserPasswordFlags) error {
3910         if C.LIBVIR_VERSION_NUMBER < 1002015 {
3911                 return makeNotImplementedError("virDomainSetUserPassword")
3912         }
3913         cuser := C.CString(user)
3914         cpassword := C.CString(password)
3915
3916         defer C.free(unsafe.Pointer(cuser))
3917         defer C.free(unsafe.Pointer(cpassword))
3918
3919         var err C.virError
3920         ret := C.virDomainSetUserPasswordWrapper(d.ptr, cuser, cpassword, C.uint(flags), &err)
3921         if ret == -1 {
3922                 return makeError(&err)
3923         }
3924
3925         return nil
3926 }
3927
3928 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSave
3929 func (d *Domain) ManagedSave(flags DomainSaveRestoreFlags) error {
3930         var err C.virError
3931         ret := C.virDomainManagedSaveWrapper(d.ptr, C.uint(flags), &err)
3932         if ret == -1 {
3933                 return makeError(&err)
3934         }
3935
3936         return nil
3937 }
3938
3939 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainHasManagedSaveImage
3940 func (d *Domain) HasManagedSaveImage(flags uint32) (bool, error) {
3941         var err C.virError
3942         result := C.virDomainHasManagedSaveImageWrapper(d.ptr, C.uint(flags), &err)
3943         if result == -1 {
3944                 return false, makeError(&err)
3945         }
3946         if result == 1 {
3947                 return true, nil
3948         }
3949         return false, nil
3950 }
3951
3952 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveRemove
3953 func (d *Domain) ManagedSaveRemove(flags uint32) error {
3954         var err C.virError
3955         ret := C.virDomainManagedSaveRemoveWrapper(d.ptr, C.uint(flags), &err)
3956         if ret == -1 {
3957                 return makeError(&err)
3958         }
3959
3960         return nil
3961 }
3962
3963 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainRename
3964 func (d *Domain) Rename(name string, flags uint32) error {
3965         if C.LIBVIR_VERSION_NUMBER < 1002019 {
3966                 return makeNotImplementedError("virDomainRename")
3967         }
3968         cname := C.CString(name)
3969         defer C.free(unsafe.Pointer(cname))
3970         var err C.virError
3971         ret := C.virDomainRenameWrapper(d.ptr, cname, C.uint(flags), &err)
3972         if ret == -1 {
3973                 return makeError(&err)
3974         }
3975
3976         return nil
3977 }
3978
3979 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainReset
3980 func (d *Domain) Reset(flags uint32) error {
3981         var err C.virError
3982         ret := C.virDomainResetWrapper(d.ptr, C.uint(flags), &err)
3983         if ret == -1 {
3984                 return makeError(&err)
3985         }
3986
3987         return nil
3988 }
3989
3990 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendProcessSignal
3991 func (d *Domain) SendProcessSignal(pid int64, signum DomainProcessSignal, flags uint32) error {
3992         var err C.virError
3993         ret := C.virDomainSendProcessSignalWrapper(d.ptr, C.longlong(pid), C.uint(signum), C.uint(flags), &err)
3994         if ret == -1 {
3995                 return makeError(&err)
3996         }
3997
3998         return nil
3999 }
4000
4001 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainInjectNMI
4002 func (d *Domain) InjectNMI(flags uint32) error {
4003         var err C.virError
4004         ret := C.virDomainInjectNMIWrapper(d.ptr, C.uint(flags), &err)
4005         if ret == -1 {
4006                 return makeError(&err)
4007         }
4008
4009         return nil
4010 }
4011
4012 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDump
4013 func (d *Domain) CoreDump(to string, flags DomainCoreDumpFlags) error {
4014         cto := C.CString(to)
4015         defer C.free(unsafe.Pointer(cto))
4016
4017         var err C.virError
4018         ret := C.virDomainCoreDumpWrapper(d.ptr, cto, C.uint(flags), &err)
4019         if ret == -1 {
4020                 return makeError(&err)
4021         }
4022
4023         return nil
4024 }
4025
4026 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDumpWithFormat
4027 func (d *Domain) CoreDumpWithFormat(to string, format DomainCoreDumpFormat, flags DomainCoreDumpFlags) error {
4028         if C.LIBVIR_VERSION_NUMBER < 1002003 {
4029                 makeNotImplementedError("virDomainCoreDumpWithFormat")
4030         }
4031         cto := C.CString(to)
4032         defer C.free(unsafe.Pointer(cto))
4033
4034         var err C.virError
4035         ret := C.virDomainCoreDumpWithFormatWrapper(d.ptr, cto, C.uint(format), C.uint(flags), &err)
4036         if ret == -1 {
4037                 return makeError(&err)
4038         }
4039
4040         return nil
4041 }
4042
4043 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainHasCurrentSnapshot
4044 func (d *Domain) HasCurrentSnapshot(flags uint32) (bool, error) {
4045         var err C.virError
4046         result := C.virDomainHasCurrentSnapshotWrapper(d.ptr, C.uint(flags), &err)
4047         if result == -1 {
4048                 return false, makeError(&err)
4049         }
4050         if result == 1 {
4051                 return true, nil
4052         }
4053         return false, nil
4054 }
4055
4056 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSFreeze
4057 func (d *Domain) FSFreeze(mounts []string, flags uint32) error {
4058         if C.LIBVIR_VERSION_NUMBER < 1002005 {
4059                 return makeNotImplementedError("virDomainFSFreeze")
4060         }
4061         cmounts := make([](*C.char), len(mounts))
4062
4063         for i := 0; i < len(mounts); i++ {
4064                 cmounts[i] = C.CString(mounts[i])
4065                 defer C.free(unsafe.Pointer(cmounts[i]))
4066         }
4067
4068         nmounts := len(mounts)
4069         var err C.virError
4070         ret := C.virDomainFSFreezeWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmounts[0])), C.uint(nmounts), C.uint(flags), &err)
4071         if ret == -1 {
4072                 return makeError(&err)
4073         }
4074
4075         return nil
4076 }
4077
4078 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSThaw
4079 func (d *Domain) FSThaw(mounts []string, flags uint32) error {
4080         if C.LIBVIR_VERSION_NUMBER < 1002005 {
4081                 return makeNotImplementedError("virDomainFSThaw")
4082         }
4083         cmounts := make([](*C.char), len(mounts))
4084
4085         for i := 0; i < len(mounts); i++ {
4086                 cmounts[i] = C.CString(mounts[i])
4087                 defer C.free(unsafe.Pointer(cmounts[i]))
4088         }
4089
4090         nmounts := len(mounts)
4091         var err C.virError
4092         ret := C.virDomainFSThawWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmounts[0])), C.uint(nmounts), C.uint(flags), &err)
4093         if ret == -1 {
4094                 return makeError(&err)
4095         }
4096
4097         return nil
4098 }
4099
4100 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSTrim
4101 func (d *Domain) FSTrim(mount string, minimum uint64, flags uint32) error {
4102         var cmount *C.char
4103         if mount != "" {
4104                 cmount := C.CString(mount)
4105                 defer C.free(unsafe.Pointer(cmount))
4106         }
4107
4108         var err C.virError
4109         ret := C.virDomainFSTrimWrapper(d.ptr, cmount, C.ulonglong(minimum), C.uint(flags), &err)
4110         if ret == -1 {
4111                 return makeError(&err)
4112         }
4113
4114         return nil
4115 }
4116
4117 type DomainFSInfo struct {
4118         MountPoint string
4119         Name       string
4120         FSType     string
4121         DevAlias   []string
4122 }
4123
4124 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetFSInfo
4125 func (d *Domain) GetFSInfo(flags uint32) ([]DomainFSInfo, error) {
4126         if C.LIBVIR_VERSION_NUMBER < 1002011 {
4127                 return []DomainFSInfo{}, makeNotImplementedError("virDomainGetFSInfo")
4128         }
4129         var cfsinfolist **C.virDomainFSInfo
4130
4131         var err C.virError
4132         ret := C.virDomainGetFSInfoWrapper(d.ptr, (**C.virDomainFSInfoPtr)(unsafe.Pointer(&cfsinfolist)), C.uint(flags), &err)
4133         if ret == -1 {
4134                 return []DomainFSInfo{}, makeError(&err)
4135         }
4136
4137         fsinfo := make([]DomainFSInfo, int(ret))
4138
4139         for i := 0; i < int(ret); i++ {
4140                 cfsinfo := (*C.virDomainFSInfo)(*(**C.virDomainFSInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(cfsinfolist)) + (unsafe.Sizeof(*cfsinfolist) * uintptr(i)))))
4141
4142                 aliases := make([]string, int(cfsinfo.ndevAlias))
4143                 for j := 0; j < int(cfsinfo.ndevAlias); j++ {
4144                         calias := (*C.char)(*(**C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(cfsinfo.devAlias)) + (unsafe.Sizeof(*cfsinfo) * uintptr(j)))))
4145                         aliases[j] = C.GoString(calias)
4146                 }
4147                 fsinfo[i] = DomainFSInfo{
4148                         MountPoint: C.GoString(cfsinfo.mountpoint),
4149                         Name:       C.GoString(cfsinfo.name),
4150                         FSType:     C.GoString(cfsinfo.fstype),
4151                         DevAlias:   aliases,
4152                 }
4153
4154                 C.virDomainFSInfoFreeWrapper(cfsinfo)
4155         }
4156         C.free(unsafe.Pointer(cfsinfolist))
4157
4158         return fsinfo, nil
4159 }
4160
4161 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMSuspendForDuration
4162 func (d *Domain) PMSuspendForDuration(target NodeSuspendTarget, duration uint64, flags uint32) error {
4163         var err C.virError
4164         ret := C.virDomainPMSuspendForDurationWrapper(d.ptr, C.uint(target), C.ulonglong(duration), C.uint(flags), &err)
4165         if ret == -1 {
4166                 return makeError(&err)
4167         }
4168
4169         return nil
4170 }
4171
4172 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMWakeup
4173 func (d *Domain) PMWakeup(flags uint32) error {
4174         var err C.virError
4175         ret := C.virDomainPMWakeupWrapper(d.ptr, C.uint(flags), &err)
4176         if ret == -1 {
4177                 return makeError(&err)
4178         }
4179
4180         return nil
4181 }
4182
4183 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAddIOThread
4184 func (d *Domain) AddIOThread(id uint, flags DomainModificationImpact) error {
4185         if C.LIBVIR_VERSION_NUMBER < 1002015 {
4186                 return makeNotImplementedError("virDomainAddIOThread")
4187         }
4188         var err C.virError
4189         ret := C.virDomainAddIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags), &err)
4190         if ret == -1 {
4191                 return makeError(&err)
4192         }
4193
4194         return nil
4195 }
4196
4197 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDelIOThread
4198 func (d *Domain) DelIOThread(id uint, flags DomainModificationImpact) error {
4199         if C.LIBVIR_VERSION_NUMBER < 1002015 {
4200                 return makeNotImplementedError("virDomainDelIOThread")
4201         }
4202         var err C.virError
4203         ret := C.virDomainDelIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags), &err)
4204         if ret == -1 {
4205                 return makeError(&err)
4206         }
4207
4208         return nil
4209 }
4210
4211 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetIOThreadParams
4212
4213 type DomainSetIOThreadParams struct {
4214         PollMaxNsSet   bool
4215         PollMaxNs      uint64
4216         PollGrowSet    bool
4217         PollGrow       uint
4218         PollShrinkSet  bool
4219         PollShrink     uint
4220 }
4221
4222 func getSetIOThreadParamsFieldInfo(params *DomainSetIOThreadParams) map[string]typedParamsFieldInfo {
4223         return map[string]typedParamsFieldInfo{
4224                 C.VIR_DOMAIN_IOTHREAD_POLL_MAX_NS: typedParamsFieldInfo{
4225                         set: &params.PollMaxNsSet,
4226                         ul:  &params.PollMaxNs,
4227                 },
4228                 C.VIR_DOMAIN_IOTHREAD_POLL_GROW: typedParamsFieldInfo{
4229                         set: &params.PollGrowSet,
4230                         ui:  &params.PollGrow,
4231                 },
4232                 C.VIR_DOMAIN_IOTHREAD_POLL_SHRINK: typedParamsFieldInfo{
4233                         set: &params.PollShrinkSet,
4234                         ui:  &params.PollShrink,
4235                 },
4236         }
4237 }
4238
4239 func (d *Domain) SetIOThreadParams(iothreadid uint, params *DomainSetIOThreadParams, flags DomainModificationImpact) error {
4240         if C.LIBVIR_VERSION_NUMBER < 4010000 {
4241                 return makeNotImplementedError("virDomainSetIOThreadParams")
4242         }
4243         info := getSetIOThreadParamsFieldInfo(params)
4244
4245         cparams, gerr := typedParamsPackNew(info)
4246         if gerr != nil {
4247                 return gerr
4248         }
4249         nparams := len(*cparams)
4250
4251         defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams))
4252
4253         var err C.virError
4254         ret := C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid), (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags), &err)
4255         if ret == -1 {
4256                 return makeError(&err)
4257         }
4258
4259         return nil
4260 }
4261
4262 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetEmulatorPinInfo
4263 func (d *Domain) GetEmulatorPinInfo(flags DomainModificationImpact) ([]bool, error) {
4264         var cnodeinfo C.virNodeInfo
4265         var err C.virError
4266         ret := C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo, &err)
4267         if ret == -1 {
4268                 return []bool{}, makeError(&err)
4269         }
4270
4271         ncpus := cnodeinfo.nodes * cnodeinfo.sockets * cnodeinfo.cores * cnodeinfo.threads
4272         maplen := int((ncpus + 7) / 8)
4273         ccpumaps := make([]C.uchar, maplen)
4274         ret = C.virDomainGetEmulatorPinInfoWrapper(d.ptr, &ccpumaps[0], C.int(maplen), C.uint(flags), &err)
4275         if ret == -1 {
4276                 return []bool{}, makeError(&err)
4277         }
4278
4279         cpumaps := make([]bool, ncpus)
4280         for i := 0; i < int(ncpus); i++ {
4281                 byte := i / 8
4282                 bit := i % 8
4283                 cpumaps[i] = (ccpumaps[byte] & (1 << uint(bit))) != 0
4284         }
4285
4286         return cpumaps, nil
4287 }
4288
4289 type DomainIOThreadInfo struct {
4290         IOThreadID uint
4291         CpuMap     []bool
4292 }
4293
4294 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetIOThreadInfo
4295 func (d *Domain) GetIOThreadInfo(flags DomainModificationImpact) ([]DomainIOThreadInfo, error) {
4296         if C.LIBVIR_VERSION_NUMBER < 1002014 {
4297                 return []DomainIOThreadInfo{}, makeNotImplementedError("virDomaingetIOThreadInfo")
4298         }
4299         var cinfolist **C.virDomainIOThreadInfo
4300
4301         var err C.virError
4302         ret := C.virDomainGetIOThreadInfoWrapper(d.ptr, (**C.virDomainIOThreadInfoPtr)(unsafe.Pointer(&cinfolist)), C.uint(flags), &err)
4303         if ret == -1 {
4304                 return []DomainIOThreadInfo{}, makeError(&err)
4305         }
4306
4307         info := make([]DomainIOThreadInfo, int(ret))
4308
4309         for i := 0; i < int(ret); i++ {
4310                 cinfo := (*(**C.virDomainIOThreadInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(cinfolist)) + (unsafe.Sizeof(*cinfolist) * uintptr(i)))))
4311
4312                 ncpus := int(cinfo.cpumaplen * 8)
4313                 cpumap := make([]bool, ncpus)
4314                 for j := 0; j < ncpus; j++ {
4315                         byte := j / 8
4316                         bit := j % 8
4317
4318                         cpumapbyte := *(*C.uchar)(unsafe.Pointer(uintptr(unsafe.Pointer(cinfo.cpumap)) + (unsafe.Sizeof(*cinfo.cpumap) * uintptr(byte))))
4319                         cpumap[j] = (cpumapbyte & (1 << uint(bit))) != 0
4320                 }
4321
4322                 info[i] = DomainIOThreadInfo{
4323                         IOThreadID: uint(cinfo.iothread_id),
4324                         CpuMap:     cpumap,
4325                 }
4326
4327                 C.virDomainIOThreadInfoFreeWrapper(cinfo)
4328         }
4329         C.free(unsafe.Pointer(cinfolist))
4330
4331         return info, nil
4332 }
4333
4334 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpuPinInfo
4335 func (d *Domain) GetVcpuPinInfo(flags DomainModificationImpact) ([][]bool, error) {
4336         var cnodeinfo C.virNodeInfo
4337         var err C.virError
4338         ret := C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo, &err)
4339         if ret == -1 {
4340                 return [][]bool{}, makeError(&err)
4341         }
4342
4343         var cdominfo C.virDomainInfo
4344         ret = C.virDomainGetInfoWrapper(d.ptr, &cdominfo, &err)
4345         if ret == -1 {
4346                 return [][]bool{}, makeError(&err)
4347         }
4348
4349         nvcpus := int(cdominfo.nrVirtCpu)
4350         npcpus := int(cnodeinfo.nodes * cnodeinfo.sockets * cnodeinfo.cores * cnodeinfo.threads)
4351         maplen := ((npcpus + 7) / 8)
4352         ccpumaps := make([]C.uchar, maplen*nvcpus)
4353
4354         ret = C.virDomainGetVcpuPinInfoWrapper(d.ptr, C.int(nvcpus), &ccpumaps[0], C.int(maplen), C.uint(flags), &err)
4355         if ret == -1 {
4356                 return [][]bool{}, makeError(&err)
4357         }
4358
4359         cpumaps := make([][]bool, nvcpus)
4360         for i := 0; i < nvcpus; i++ {
4361                 cpumaps[i] = make([]bool, npcpus)
4362                 for j := 0; j < npcpus; j++ {
4363                         byte := (i * maplen) + (j / 8)
4364                         bit := j % 8
4365
4366                         if (ccpumaps[byte] & (1 << uint(bit))) != 0 {
4367                                 cpumaps[i][j] = true
4368                         }
4369                 }
4370         }
4371
4372         return cpumaps, nil
4373 }
4374
4375 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinEmulator
4376 func (d *Domain) PinEmulator(cpumap []bool, flags DomainModificationImpact) error {
4377
4378         maplen := (len(cpumap) + 7) / 8
4379         ccpumaps := make([]C.uchar, maplen)
4380         for i := 0; i < len(cpumap); i++ {
4381                 if cpumap[i] {
4382                         byte := i / 8
4383                         bit := i % 8
4384
4385                         ccpumaps[byte] |= (1 << uint(bit))
4386                 }
4387         }
4388
4389         var err C.virError
4390         ret := C.virDomainPinEmulatorWrapper(d.ptr, &ccpumaps[0], C.int(maplen), C.uint(flags), &err)
4391         if ret == -1 {
4392                 return makeError(&err)
4393         }
4394
4395         return nil
4396 }
4397
4398 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinIOThread
4399 func (d *Domain) PinIOThread(iothreadid uint, cpumap []bool, flags DomainModificationImpact) error {
4400         if C.LIBVIR_VERSION_NUMBER < 1002014 {
4401                 return makeNotImplementedError("virDomainPinIOThread")
4402         }
4403
4404         maplen := (len(cpumap) + 7) / 8
4405         ccpumaps := make([]C.uchar, maplen)
4406         for i := 0; i < len(cpumap); i++ {
4407                 if cpumap[i] {
4408                         byte := i / 8
4409                         bit := i % 8
4410
4411                         ccpumaps[byte] |= (1 << uint(bit))
4412                 }
4413         }
4414
4415         var err C.virError
4416         ret := C.virDomainPinIOThreadWrapper(d.ptr, C.uint(iothreadid), &ccpumaps[0], C.int(maplen), C.uint(flags), &err)
4417         if ret == -1 {
4418                 return makeError(&err)
4419         }
4420
4421         return nil
4422 }
4423
4424 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenChannel
4425 func (d *Domain) OpenChannel(name string, stream *Stream, flags DomainChannelFlags) error {
4426         cname := C.CString(name)
4427         defer C.free(unsafe.Pointer(cname))
4428
4429         var err C.virError
4430         ret := C.virDomainOpenChannelWrapper(d.ptr, cname, stream.ptr, C.uint(flags), &err)
4431         if ret == -1 {
4432                 return makeError(&err)
4433         }
4434
4435         return nil
4436 }
4437
4438 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenConsole
4439 func (d *Domain) OpenConsole(devname string, stream *Stream, flags DomainConsoleFlags) error {
4440         var cdevname *C.char
4441         if devname != "" {
4442                 cdevname = C.CString(devname)
4443                 defer C.free(unsafe.Pointer(cdevname))
4444         }
4445
4446         var err C.virError
4447         ret := C.virDomainOpenConsoleWrapper(d.ptr, cdevname, stream.ptr, C.uint(flags), &err)
4448         if ret == -1 {
4449                 return makeError(&err)
4450         }
4451
4452         return nil
4453 }
4454
4455 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenGraphics
4456 func (d *Domain) OpenGraphics(idx uint, file os.File, flags DomainOpenGraphicsFlags) error {
4457         var err C.virError
4458         ret := C.virDomainOpenGraphicsWrapper(d.ptr, C.uint(idx), C.int(file.Fd()), C.uint(flags), &err)
4459         if ret == -1 {
4460                 return makeError(&err)
4461         }
4462
4463         return nil
4464 }
4465
4466 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenGraphicsFD
4467 func (d *Domain) OpenGraphicsFD(idx uint, flags DomainOpenGraphicsFlags) (*os.File, error) {
4468         if C.LIBVIR_VERSION_NUMBER < 1002008 {
4469                 return nil, makeNotImplementedError("virDomainOpenGraphicsFD")
4470         }
4471         var err C.virError
4472         ret := C.virDomainOpenGraphicsFDWrapper(d.ptr, C.uint(idx), C.uint(flags), &err)
4473         if ret == -1 {
4474                 return nil, makeError(&err)
4475         }
4476
4477         return os.NewFile(uintptr(ret), "graphics"), nil
4478 }
4479
4480 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotCreateXML
4481 func (d *Domain) CreateSnapshotXML(xml string, flags DomainSnapshotCreateFlags) (*DomainSnapshot, error) {
4482         cXml := C.CString(xml)
4483         defer C.free(unsafe.Pointer(cXml))
4484         var err C.virError
4485         result := C.virDomainSnapshotCreateXMLWrapper(d.ptr, cXml, C.uint(flags), &err)
4486         if result == nil {
4487                 return nil, makeError(&err)
4488         }
4489         return &DomainSnapshot{ptr: result}, nil
4490 }
4491
4492 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSave
4493 func (d *Domain) Save(destFile string) error {
4494         cPath := C.CString(destFile)
4495         defer C.free(unsafe.Pointer(cPath))
4496         var err C.virError
4497         result := C.virDomainSaveWrapper(d.ptr, cPath, &err)
4498         if result == -1 {
4499                 return makeError(&err)
4500         }
4501         return nil
4502 }
4503
4504 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSaveFlags
4505 func (d *Domain) SaveFlags(destFile string, destXml string, flags DomainSaveRestoreFlags) error {
4506         cDestFile := C.CString(destFile)
4507         cDestXml := C.CString(destXml)
4508         defer C.free(unsafe.Pointer(cDestXml))
4509         defer C.free(unsafe.Pointer(cDestFile))
4510         var err C.virError
4511         result := C.virDomainSaveFlagsWrapper(d.ptr, cDestFile, cDestXml, C.uint(flags), &err)
4512         if result == -1 {
4513                 return makeError(&err)
4514         }
4515         return nil
4516 }
4517
4518 type DomainGuestVcpus struct {
4519         Vcpus      []bool
4520         Online     []bool
4521         Offlinable []bool
4522 }
4523
4524 func getDomainGuestVcpusParametersFieldInfo(VcpusSet *bool, Vcpus *string, OnlineSet *bool, Online *string, OfflinableSet *bool, Offlinable *string) map[string]typedParamsFieldInfo {
4525         return map[string]typedParamsFieldInfo{
4526                 "vcpus": typedParamsFieldInfo{
4527                         set: VcpusSet,
4528                         s:   Vcpus,
4529                 },
4530                 "online": typedParamsFieldInfo{
4531                         set: OnlineSet,
4532                         s:   Online,
4533                 },
4534                 "offlinable": typedParamsFieldInfo{
4535                         set: OfflinableSet,
4536                         s:   Offlinable,
4537                 },
4538         }
4539 }
4540
4541 func parseCPUString(cpumapstr string) ([]bool, error) {
4542         pieces := strings.Split(cpumapstr, ",")
4543         var cpumap []bool
4544         for _, piece := range pieces {
4545                 if len(piece) < 1 {
4546                         return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4547                 }
4548                 invert := false
4549                 if piece[0] == '^' {
4550                         invert = true
4551                         piece = piece[1:]
4552                 }
4553                 pair := strings.Split(piece, "-")
4554                 var start, end int
4555                 var err error
4556                 if len(pair) == 1 {
4557                         start, err = strconv.Atoi(pair[0])
4558                         if err != nil {
4559                                 return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4560                         }
4561                         end, err = strconv.Atoi(pair[0])
4562                         if err != nil {
4563                                 return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4564                         }
4565                 } else if len(pair) == 2 {
4566                         start, err = strconv.Atoi(pair[0])
4567                         if err != nil {
4568                                 return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4569                         }
4570                         end, err = strconv.Atoi(pair[1])
4571                         if err != nil {
4572                                 return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4573                         }
4574                 } else {
4575                         return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4576                 }
4577                 if start > end {
4578                         return []bool{}, fmt.Errorf("Malformed cpu map string %s", cpumapstr)
4579                 }
4580                 if (end + 1) > len(cpumap) {
4581                         newcpumap := make([]bool, end+1)
4582                         copy(newcpumap, cpumap)
4583                         cpumap = newcpumap
4584                 }
4585
4586                 for i := start; i <= end; i++ {
4587                         if invert {
4588                                 cpumap[i] = false
4589                         } else {
4590                                 cpumap[i] = true
4591                         }
4592                 }
4593         }
4594
4595         return cpumap, nil
4596 }
4597
4598 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetGuestVcpus
4599 func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus, error) {
4600         if C.LIBVIR_VERSION_NUMBER < 2000000 {
4601                 return nil, makeNotImplementedError("virDomainGetGuestVcpus")
4602         }
4603
4604         var VcpusSet, OnlineSet, OfflinableSet bool
4605         var VcpusStr, OnlineStr, OfflinableStr string
4606         info := getDomainGuestVcpusParametersFieldInfo(&VcpusSet, &VcpusStr, &OnlineSet, &OnlineStr, &OfflinableSet, &OfflinableStr)
4607
4608         var cparams C.virTypedParameterPtr
4609         var nparams C.uint
4610         var err C.virError
4611         ret := C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uint(flags), &err)
4612         if ret == -1 {
4613                 return nil, makeError(&err)
4614         }
4615
4616         defer C.virTypedParamsFree(cparams, C.int(nparams))
4617
4618         _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
4619         if gerr != nil {
4620                 return nil, gerr
4621         }
4622
4623         return &DomainGuestVcpus{}, nil
4624 }
4625
4626 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetGuestVcpus
4627 func (d *Domain) SetGuestVcpus(cpus []bool, state bool, flags uint32) error {
4628         if C.LIBVIR_VERSION_NUMBER < 2000000 {
4629                 return makeNotImplementedError("virDomainSetGuestVcpus")
4630         }
4631
4632         cpumap := ""
4633         for i := 0; i < len(cpus); i++ {
4634                 if cpus[i] {
4635                         if cpumap == "" {
4636                                 cpumap = string(i)
4637                         } else {
4638                                 cpumap += "," + string(i)
4639                         }
4640                 }
4641         }
4642
4643         var cstate C.int
4644         if state {
4645                 cstate = 1
4646         } else {
4647                 cstate = 0
4648         }
4649         ccpumap := C.CString(cpumap)
4650         defer C.free(unsafe.Pointer(ccpumap))
4651         var err C.virError
4652         ret := C.virDomainSetGuestVcpusWrapper(d.ptr, ccpumap, cstate, C.uint(flags), &err)
4653         if ret == -1 {
4654                 return makeError(&err)
4655         }
4656
4657         return nil
4658 }
4659
4660 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpu
4661 func (d *Domain) SetVcpu(cpus []bool, state bool, flags uint32) error {
4662         if C.LIBVIR_VERSION_NUMBER < 3001000 {
4663                 return makeNotImplementedError("virDomainSetVcpu")
4664         }
4665
4666         cpumap := ""
4667         for i := 0; i < len(cpus); i++ {
4668                 if cpus[i] {
4669                         if cpumap == "" {
4670                                 cpumap = string(i)
4671                         } else {
4672                                 cpumap += "," + string(i)
4673                         }
4674                 }
4675         }
4676
4677         var cstate C.int
4678         if state {
4679                 cstate = 1
4680         } else {
4681                 cstate = 0
4682         }
4683         ccpumap := C.CString(cpumap)
4684         defer C.free(unsafe.Pointer(ccpumap))
4685         var err C.virError
4686         ret := C.virDomainSetVcpuWrapper(d.ptr, ccpumap, cstate, C.uint(flags), &err)
4687         if ret == -1 {
4688                 return makeError(&err)
4689         }
4690
4691         return nil
4692 }
4693
4694 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlockThreshold
4695 func (d *Domain) SetBlockThreshold(dev string, threshold uint64, flags uint32) error {
4696         if C.LIBVIR_VERSION_NUMBER < 3002000 {
4697                 return makeNotImplementedError("virDomainSetBlockThreshold")
4698         }
4699
4700         cdev := C.CString(dev)
4701         defer C.free(unsafe.Pointer(cdev))
4702         var err C.virError
4703         ret := C.virDomainSetBlockThresholdWrapper(d.ptr, cdev, C.ulonglong(threshold), C.uint(flags), &err)
4704         if ret == -1 {
4705                 return makeError(&err)
4706         }
4707
4708         return nil
4709 }
4710
4711 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveDefineXML
4712 func (d *Domain) ManagedSaveDefineXML(xml string, flags uint32) error {
4713         if C.LIBVIR_VERSION_NUMBER < 3007000 {
4714                 return makeNotImplementedError("virDomainManagedSaveDefineXML")
4715         }
4716
4717         cxml := C.CString(xml)
4718         defer C.free(unsafe.Pointer(cxml))
4719         var err C.virError
4720         ret := C.virDomainManagedSaveDefineXMLWrapper(d.ptr, cxml, C.uint(flags), &err)
4721         if ret == -1 {
4722                 return makeError(&err)
4723         }
4724
4725         return nil
4726 }
4727
4728 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveGetXMLDesc
4729 func (d *Domain) ManagedSaveGetXMLDesc(flags uint32) (string, error) {
4730         if C.LIBVIR_VERSION_NUMBER < 3007000 {
4731                 return "", makeNotImplementedError("virDomainManagedSaveGetXMLDesc")
4732         }
4733
4734         var err C.virError
4735         ret := C.virDomainManagedSaveGetXMLDescWrapper(d.ptr, C.uint(flags), &err)
4736         if ret == nil {
4737                 return "", makeError(&err)
4738         }
4739
4740         xml := C.GoString(ret)
4741         C.free(unsafe.Pointer(ret))
4742         return xml, nil
4743 }
4744
4745 type DomainLifecycle int
4746
4747 const (
4748         DOMAIN_LIFECYCLE_POWEROFF = DomainLifecycle(C.VIR_DOMAIN_LIFECYCLE_POWEROFF)
4749         DOMAIN_LIFECYCLE_REBOOT   = DomainLifecycle(C.VIR_DOMAIN_LIFECYCLE_REBOOT)
4750         DOMAIN_LIFECYCLE_CRASH    = DomainLifecycle(C.VIR_DOMAIN_LIFECYCLE_CRASH)
4751 )
4752
4753 type DomainLifecycleAction int
4754
4755 const (
4756         DOMAIN_LIFECYCLE_ACTION_DESTROY          = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY)
4757         DOMAIN_LIFECYCLE_ACTION_RESTART          = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_RESTART)
4758         DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME   = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME)
4759         DOMAIN_LIFECYCLE_ACTION_PRESERVE         = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_PRESERVE)
4760         DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY)
4761         DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART = DomainLifecycleAction(C.VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART)
4762 )
4763
4764 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetLifecycleAction
4765 func (d *Domain) SetLifecycleAction(lifecycleType uint32, action uint32, flags uint32) error {
4766         if C.LIBVIR_VERSION_NUMBER < 3009000 {
4767                 return makeNotImplementedError("virDomainSetLifecycleAction")
4768         }
4769
4770         var err C.virError
4771         ret := C.virDomainSetLifecycleActionWrapper(d.ptr, C.uint(lifecycleType), C.uint(action), C.uint(flags), &err)
4772         if ret == -1 {
4773                 return makeError(&err)
4774         }
4775
4776         return nil
4777 }
4778
4779 type DomainLaunchSecurityParameters struct {
4780         SEVMeasurementSet bool
4781         SEVMeasurement    string
4782 }
4783
4784 func getDomainLaunchSecurityFieldInfo(params *DomainLaunchSecurityParameters) map[string]typedParamsFieldInfo {
4785         return map[string]typedParamsFieldInfo{
4786                 C.VIR_DOMAIN_LAUNCH_SECURITY_SEV_MEASUREMENT: typedParamsFieldInfo{
4787                         set: &params.SEVMeasurementSet,
4788                         s:   &params.SEVMeasurement,
4789                 },
4790         }
4791 }
4792
4793 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetLaunchSecurityInfo
4794 func (d *Domain) GetLaunchSecurityInfo(flags uint32) (*DomainLaunchSecurityParameters, error) {
4795         if C.LIBVIR_VERSION_NUMBER < 4005000 {
4796                 return nil, makeNotImplementedError("virDomainGetLaunchSecurityInfo")
4797         }
4798
4799         params := &DomainLaunchSecurityParameters{}
4800         info := getDomainLaunchSecurityFieldInfo(params)
4801
4802         var cparams *C.virTypedParameter
4803         var nparams C.int
4804
4805         var err C.virError
4806         ret := C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err)
4807         if ret == -1 {
4808                 return nil, makeError(&err)
4809         }
4810
4811         defer C.virTypedParamsFree(cparams, nparams)
4812
4813         _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
4814         if gerr != nil {
4815                 return nil, gerr
4816         }
4817
4818         return params, nil
4819 }