src/dma/vendor/github.com/libvirt/libvirt-go/domain_events.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 import (
  30         "fmt"
  31         "unsafe"
  32 )
  33
  34 /*
  35 #cgo pkg-config: libvirt
  36 #include "domain_events_wrapper.h"
  37 */
  38 import "C"
  39
  40 type DomainEventGenericCallback func(c *Connect, d *Domain)
  41
  42 type DomainEventLifecycle struct {
  43         Event DomainEventType
  44         // TODO: we can make Detail typesafe somehow ?
  45         Detail int
  46 }
  47
  48 type DomainEventLifecycleCallback func(c *Connect, d *Domain, event *DomainEventLifecycle)
  49
  50 type DomainEventRTCChange struct {
  51         Utcoffset int64
  52 }
  53
  54 type DomainEventRTCChangeCallback func(c *Connect, d *Domain, event *DomainEventRTCChange)
  55
  56 type DomainEventWatchdog struct {
  57         Action DomainEventWatchdogAction
  58 }
  59
  60 type DomainEventWatchdogCallback func(c *Connect, d *Domain, event *DomainEventWatchdog)
  61
  62 type DomainEventIOError struct {
  63         SrcPath  string
  64         DevAlias string
  65         Action   DomainEventIOErrorAction
  66 }
  67
  68 type DomainEventIOErrorCallback func(c *Connect, d *Domain, event *DomainEventIOError)
  69
  70 type DomainEventGraphicsAddress struct {
  71         Family  DomainEventGraphicsAddressType
  72         Node    string
  73         Service string
  74 }
  75
  76 type DomainEventGraphicsSubjectIdentity struct {
  77         Type string
  78         Name string
  79 }
  80
  81 type DomainEventGraphics struct {
  82         Phase      DomainEventGraphicsPhase
  83         Local      DomainEventGraphicsAddress
  84         Remote     DomainEventGraphicsAddress
  85         AuthScheme string
  86         Subject    []DomainEventGraphicsSubjectIdentity
  87 }
  88
  89 type DomainEventGraphicsCallback func(c *Connect, d *Domain, event *DomainEventGraphics)
  90
  91 type DomainEventIOErrorReason struct {
  92         SrcPath  string
  93         DevAlias string
  94         Action   DomainEventIOErrorAction
  95         Reason   string
  96 }
  97
  98 type DomainEventIOErrorReasonCallback func(c *Connect, d *Domain, event *DomainEventIOErrorReason)
  99
 100 type DomainEventBlockJob struct {
 101         Disk   string
 102         Type   DomainBlockJobType
 103         Status ConnectDomainEventBlockJobStatus
 104 }
 105
 106 type DomainEventBlockJobCallback func(c *Connect, d *Domain, event *DomainEventBlockJob)
 107
 108 type DomainEventDiskChange struct {
 109         OldSrcPath string
 110         NewSrcPath string
 111         DevAlias   string
 112         Reason     ConnectDomainEventDiskChangeReason
 113 }
 114
 115 type DomainEventDiskChangeCallback func(c *Connect, d *Domain, event *DomainEventDiskChange)
 116
 117 type DomainEventTrayChange struct {
 118         DevAlias string
 119         Reason   ConnectDomainEventTrayChangeReason
 120 }
 121
 122 type DomainEventTrayChangeCallback func(c *Connect, d *Domain, event *DomainEventTrayChange)
 123
 124 type DomainEventPMSuspend struct {
 125         Reason int
 126 }
 127
 128 type DomainEventPMSuspendCallback func(c *Connect, d *Domain, event *DomainEventPMSuspend)
 129
 130 type DomainEventPMWakeup struct {
 131         Reason int
 132 }
 133
 134 type DomainEventPMWakeupCallback func(c *Connect, d *Domain, event *DomainEventPMWakeup)
 135
 136 type DomainEventPMSuspendDisk struct {
 137         Reason int
 138 }
 139
 140 type DomainEventPMSuspendDiskCallback func(c *Connect, d *Domain, event *DomainEventPMSuspendDisk)
 141
 142 type DomainEventBalloonChange struct {
 143         Actual uint64
 144 }
 145
 146 type DomainEventBalloonChangeCallback func(c *Connect, d *Domain, event *DomainEventBalloonChange)
 147
 148 type DomainEventDeviceRemoved struct {
 149         DevAlias string
 150 }
 151
 152 type DomainEventDeviceRemovedCallback func(c *Connect, d *Domain, event *DomainEventDeviceRemoved)
 153
 154 type DomainEventTunableCpuPin struct {
 155         VcpuPinSet     bool
 156         VcpuPin        [][]bool
 157         EmulatorPinSet bool
 158         EmulatorPin    []bool
 159         IOThreadPinSet bool
 160         IOThreadPin    [][]bool
 161 }
 162
 163 type DomainEventTunable struct {
 164         CpuSched      *DomainSchedulerParameters
 165         CpuPin        *DomainEventTunableCpuPin
 166         BlkdevDiskSet bool
 167         BlkdevDisk    string
 168         BlkdevTune    *DomainBlockIoTuneParameters
 169 }
 170
 171 type DomainEventTunableCallback func(c *Connect, d *Domain, event *DomainEventTunable)
 172
 173 type DomainEventAgentLifecycle struct {
 174         State  ConnectDomainEventAgentLifecycleState
 175         Reason ConnectDomainEventAgentLifecycleReason
 176 }
 177
 178 type DomainEventAgentLifecycleCallback func(c *Connect, d *Domain, event *DomainEventAgentLifecycle)
 179
 180 type DomainEventDeviceAdded struct {
 181         DevAlias string
 182 }
 183
 184 type DomainEventDeviceAddedCallback func(c *Connect, d *Domain, event *DomainEventDeviceAdded)
 185
 186 type DomainEventMigrationIteration struct {
 187         Iteration int
 188 }
 189
 190 type DomainEventMigrationIterationCallback func(c *Connect, d *Domain, event *DomainEventMigrationIteration)
 191
 192 type DomainEventJobCompleted struct {
 193         Info DomainJobInfo
 194 }
 195
 196 type DomainEventJobCompletedCallback func(c *Connect, d *Domain, event *DomainEventJobCompleted)
 197
 198 type DomainEventDeviceRemovalFailed struct {
 199         DevAlias string
 200 }
 201
 202 type DomainEventDeviceRemovalFailedCallback func(c *Connect, d *Domain, event *DomainEventDeviceRemovalFailed)
 203
 204 type DomainEventMetadataChange struct {
 205         Type  int
 206         NSURI string
 207 }
 208
 209 type DomainEventMetadataChangeCallback func(c *Connect, d *Domain, event *DomainEventMetadataChange)
 210
 211 type DomainEventBlockThreshold struct {
 212         Dev       string
 213         Path      string
 214         Threshold uint64
 215         Excess    uint64
 216 }
 217
 218 type DomainEventBlockThresholdCallback func(c *Connect, d *Domain, event *DomainEventBlockThreshold)
 219
 220 //export domainEventLifecycleCallback
 221 func domainEventLifecycleCallback(c C.virConnectPtr, d C.virDomainPtr,
 222         event int, detail int,
 223         goCallbackId int) {
 224
 225         domain := &Domain{ptr: d}
 226         connection := &Connect{ptr: c}
 227
 228         eventDetails := &DomainEventLifecycle{
 229                 Event:  DomainEventType(event),
 230                 Detail: detail,
 231         }
 232
 233         callbackFunc := getCallbackId(goCallbackId)
 234         callback, ok := callbackFunc.(DomainEventLifecycleCallback)
 235         if !ok {
 236                 panic("Inappropriate callback type called")
 237         }
 238         callback(connection, domain, eventDetails)
 239 }
 240
 241 //export domainEventGenericCallback
 242 func domainEventGenericCallback(c C.virConnectPtr, d C.virDomainPtr,
 243         goCallbackId int) {
 244
 245         domain := &Domain{ptr: d}
 246         connection := &Connect{ptr: c}
 247
 248         callbackFunc := getCallbackId(goCallbackId)
 249         callback, ok := callbackFunc.(DomainEventGenericCallback)
 250         if !ok {
 251                 panic("Inappropriate callback type called")
 252         }
 253         callback(connection, domain)
 254 }
 255
 256 //export domainEventRTCChangeCallback
 257 func domainEventRTCChangeCallback(c C.virConnectPtr, d C.virDomainPtr,
 258         utcoffset int64, goCallbackId int) {
 259
 260         domain := &Domain{ptr: d}
 261         connection := &Connect{ptr: c}
 262
 263         eventDetails := &DomainEventRTCChange{
 264                 Utcoffset: utcoffset,
 265         }
 266
 267         callbackFunc := getCallbackId(goCallbackId)
 268         callback, ok := callbackFunc.(DomainEventRTCChangeCallback)
 269         if !ok {
 270                 panic("Inappropriate callback type called")
 271         }
 272         callback(connection, domain, eventDetails)
 273
 274 }
 275
 276 //export domainEventWatchdogCallback
 277 func domainEventWatchdogCallback(c C.virConnectPtr, d C.virDomainPtr,
 278         action int, goCallbackId int) {
 279
 280         domain := &Domain{ptr: d}
 281         connection := &Connect{ptr: c}
 282
 283         eventDetails := &DomainEventWatchdog{
 284                 Action: DomainEventWatchdogAction(action),
 285         }
 286
 287         callbackFunc := getCallbackId(goCallbackId)
 288         callback, ok := callbackFunc.(DomainEventWatchdogCallback)
 289         if !ok {
 290                 panic("Inappropriate callback type called")
 291         }
 292         callback(connection, domain, eventDetails)
 293
 294 }
 295
 296 //export domainEventIOErrorCallback
 297 func domainEventIOErrorCallback(c C.virConnectPtr, d C.virDomainPtr,
 298         srcPath *C.char, devAlias *C.char, action int, goCallbackId int) {
 299
 300         domain := &Domain{ptr: d}
 301         connection := &Connect{ptr: c}
 302
 303         eventDetails := &DomainEventIOError{
 304                 SrcPath:  C.GoString(srcPath),
 305                 DevAlias: C.GoString(devAlias),
 306                 Action:   DomainEventIOErrorAction(action),
 307         }
 308
 309         callbackFunc := getCallbackId(goCallbackId)
 310         callback, ok := callbackFunc.(DomainEventIOErrorCallback)
 311         if !ok {
 312                 panic("Inappropriate callback type called")
 313         }
 314         callback(connection, domain, eventDetails)
 315
 316 }
 317
 318 //export domainEventGraphicsCallback
 319 func domainEventGraphicsCallback(c C.virConnectPtr, d C.virDomainPtr,
 320         phase int,
 321         local C.virDomainEventGraphicsAddressPtr,
 322         remote C.virDomainEventGraphicsAddressPtr,
 323         authScheme *C.char,
 324         subject C.virDomainEventGraphicsSubjectPtr,
 325         goCallbackId int) {
 326
 327         domain := &Domain{ptr: d}
 328         connection := &Connect{ptr: c}
 329
 330         subjectGo := make([]DomainEventGraphicsSubjectIdentity, 0)
 331         nidentities := int(subject.nidentity)
 332         identities := (*[1 << 30]C.virDomainEventGraphicsSubjectIdentity)(unsafe.Pointer(&subject.identities))[:nidentities:nidentities]
 333         for _, identity := range identities {
 334                 subjectGo = append(subjectGo,
 335                         DomainEventGraphicsSubjectIdentity{
 336                                 Type: C.GoString(identity._type),
 337                                 Name: C.GoString(identity.name),
 338                         },
 339                 )
 340         }
 341
 342         eventDetails := &DomainEventGraphics{
 343                 Phase: DomainEventGraphicsPhase(phase),
 344                 Local: DomainEventGraphicsAddress{
 345                         Family:  DomainEventGraphicsAddressType(local.family),
 346                         Node:    C.GoString(local.node),
 347                         Service: C.GoString(local.service),
 348                 },
 349                 Remote: DomainEventGraphicsAddress{
 350                         Family:  DomainEventGraphicsAddressType(remote.family),
 351                         Node:    C.GoString(remote.node),
 352                         Service: C.GoString(remote.service),
 353                 },
 354                 AuthScheme: C.GoString(authScheme),
 355                 Subject:    subjectGo,
 356         }
 357
 358         callbackFunc := getCallbackId(goCallbackId)
 359         callback, ok := callbackFunc.(DomainEventGraphicsCallback)
 360         if !ok {
 361                 panic("Inappropriate callback type called")
 362         }
 363         callback(connection, domain, eventDetails)
 364
 365 }
 366
 367 //export domainEventIOErrorReasonCallback
 368 func domainEventIOErrorReasonCallback(c C.virConnectPtr, d C.virDomainPtr,
 369         srcPath *C.char, devAlias *C.char, action int, reason *C.char,
 370         goCallbackId int) {
 371
 372         domain := &Domain{ptr: d}
 373         connection := &Connect{ptr: c}
 374
 375         eventDetails := &DomainEventIOErrorReason{
 376                 SrcPath:  C.GoString(srcPath),
 377                 DevAlias: C.GoString(devAlias),
 378                 Action:   DomainEventIOErrorAction(action),
 379                 Reason:   C.GoString(reason),
 380         }
 381
 382         callbackFunc := getCallbackId(goCallbackId)
 383         callback, ok := callbackFunc.(DomainEventIOErrorReasonCallback)
 384         if !ok {
 385                 panic("Inappropriate callback type called")
 386         }
 387         callback(connection, domain, eventDetails)
 388
 389 }
 390
 391 //export domainEventBlockJobCallback
 392 func domainEventBlockJobCallback(c C.virConnectPtr, d C.virDomainPtr,
 393         disk *C.char, _type int, status int, goCallbackId int) {
 394
 395         domain := &Domain{ptr: d}
 396         connection := &Connect{ptr: c}
 397
 398         eventDetails := &DomainEventBlockJob{
 399                 Disk:   C.GoString(disk),
 400                 Type:   DomainBlockJobType(_type),
 401                 Status: ConnectDomainEventBlockJobStatus(status),
 402         }
 403
 404         callbackFunc := getCallbackId(goCallbackId)
 405         callback, ok := callbackFunc.(DomainEventBlockJobCallback)
 406         if !ok {
 407                 panic("Inappropriate callback type called")
 408         }
 409         callback(connection, domain, eventDetails)
 410
 411 }
 412
 413 //export domainEventDiskChangeCallback
 414 func domainEventDiskChangeCallback(c C.virConnectPtr, d C.virDomainPtr,
 415         oldSrcPath *C.char, newSrcPath *C.char, devAlias *C.char,
 416         reason int, goCallbackId int) {
 417
 418         domain := &Domain{ptr: d}
 419         connection := &Connect{ptr: c}
 420
 421         eventDetails := &DomainEventDiskChange{
 422                 OldSrcPath: C.GoString(oldSrcPath),
 423                 NewSrcPath: C.GoString(newSrcPath),
 424                 DevAlias:   C.GoString(devAlias),
 425                 Reason:     ConnectDomainEventDiskChangeReason(reason),
 426         }
 427
 428         callbackFunc := getCallbackId(goCallbackId)
 429         callback, ok := callbackFunc.(DomainEventDiskChangeCallback)
 430         if !ok {
 431                 panic("Inappropriate callback type called")
 432         }
 433         callback(connection, domain, eventDetails)
 434
 435 }
 436
 437 //export domainEventTrayChangeCallback
 438 func domainEventTrayChangeCallback(c C.virConnectPtr, d C.virDomainPtr,
 439         devAlias *C.char, reason int, goCallbackId int) {
 440
 441         domain := &Domain{ptr: d}
 442         connection := &Connect{ptr: c}
 443
 444         eventDetails := &DomainEventTrayChange{
 445                 DevAlias: C.GoString(devAlias),
 446                 Reason:   ConnectDomainEventTrayChangeReason(reason),
 447         }
 448
 449         callbackFunc := getCallbackId(goCallbackId)
 450         callback, ok := callbackFunc.(DomainEventTrayChangeCallback)
 451         if !ok {
 452                 panic("Inappropriate callback type called")
 453         }
 454         callback(connection, domain, eventDetails)
 455
 456 }
 457
 458 //export domainEventPMSuspendCallback
 459 func domainEventPMSuspendCallback(c C.virConnectPtr, d C.virDomainPtr,
 460         reason int, goCallbackId int) {
 461
 462         domain := &Domain{ptr: d}
 463         connection := &Connect{ptr: c}
 464
 465         eventDetails := &DomainEventPMSuspend{
 466                 Reason: reason,
 467         }
 468
 469         callbackFunc := getCallbackId(goCallbackId)
 470         callback, ok := callbackFunc.(DomainEventPMSuspendCallback)
 471         if !ok {
 472                 panic("Inappropriate callback type called")
 473         }
 474         callback(connection, domain, eventDetails)
 475
 476 }
 477
 478 //export domainEventPMWakeupCallback
 479 func domainEventPMWakeupCallback(c C.virConnectPtr, d C.virDomainPtr,
 480         reason int, goCallbackId int) {
 481
 482         domain := &Domain{ptr: d}
 483         connection := &Connect{ptr: c}
 484
 485         eventDetails := &DomainEventPMWakeup{
 486                 Reason: reason,
 487         }
 488
 489         callbackFunc := getCallbackId(goCallbackId)
 490         callback, ok := callbackFunc.(DomainEventPMWakeupCallback)
 491         if !ok {
 492                 panic("Inappropriate callback type called")
 493         }
 494         callback(connection, domain, eventDetails)
 495
 496 }
 497
 498 //export domainEventPMSuspendDiskCallback
 499 func domainEventPMSuspendDiskCallback(c C.virConnectPtr, d C.virDomainPtr,
 500         reason int, goCallbackId int) {
 501
 502         domain := &Domain{ptr: d}
 503         connection := &Connect{ptr: c}
 504
 505         eventDetails := &DomainEventPMSuspendDisk{
 506                 Reason: reason,
 507         }
 508
 509         callbackFunc := getCallbackId(goCallbackId)
 510         callback, ok := callbackFunc.(DomainEventPMSuspendDiskCallback)
 511         if !ok {
 512                 panic("Inappropriate callback type called")
 513         }
 514         callback(connection, domain, eventDetails)
 515
 516 }
 517
 518 //export domainEventBalloonChangeCallback
 519 func domainEventBalloonChangeCallback(c C.virConnectPtr, d C.virDomainPtr,
 520         actual uint64, goCallbackId int) {
 521
 522         domain := &Domain{ptr: d}
 523         connection := &Connect{ptr: c}
 524
 525         eventDetails := &DomainEventBalloonChange{
 526                 Actual: actual,
 527         }
 528
 529         callbackFunc := getCallbackId(goCallbackId)
 530         callback, ok := callbackFunc.(DomainEventBalloonChangeCallback)
 531         if !ok {
 532                 panic("Inappropriate callback type called")
 533         }
 534         callback(connection, domain, eventDetails)
 535
 536 }
 537
 538 //export domainEventDeviceRemovedCallback
 539 func domainEventDeviceRemovedCallback(c C.virConnectPtr, d C.virDomainPtr,
 540         devAlias *C.char, goCallbackId int) {
 541
 542         domain := &Domain{ptr: d}
 543         connection := &Connect{ptr: c}
 544
 545         eventDetails := &DomainEventDeviceRemoved{
 546                 DevAlias: C.GoString(devAlias),
 547         }
 548         callbackFunc := getCallbackId(goCallbackId)
 549         callback, ok := callbackFunc.(DomainEventDeviceRemovedCallback)
 550         if !ok {
 551                 panic("Inappropriate callback type called")
 552         }
 553         callback(connection, domain, eventDetails)
 554
 555 }
 556
 557 //export domainEventMetadataChangeCallback
 558 func domainEventMetadataChangeCallback(c C.virConnectPtr, d C.virDomainPtr,
 559         mtype int, nsuri *C.char, goCallbackId int) {
 560
 561         domain := &Domain{ptr: d}
 562         connection := &Connect{ptr: c}
 563
 564         eventDetails := &DomainEventMetadataChange{
 565                 Type:  (int)(mtype),
 566                 NSURI: C.GoString(nsuri),
 567         }
 568         callbackFunc := getCallbackId(goCallbackId)
 569         callback, ok := callbackFunc.(DomainEventMetadataChangeCallback)
 570         if !ok {
 571                 panic("Inappropriate callback type called")
 572         }
 573         callback(connection, domain, eventDetails)
 574
 575 }
 576
 577 func getDomainTuneSchedulerParametersFieldInfo(params *DomainSchedulerParameters) map[string]typedParamsFieldInfo {
 578         return map[string]typedParamsFieldInfo{
 579                 C.VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES: typedParamsFieldInfo{
 580                         set: &params.CpuSharesSet,
 581                         ul:  &params.CpuShares,
 582                 },
 583                 C.VIR_DOMAIN_TUNABLE_CPU_GLOBAL_PERIOD: typedParamsFieldInfo{
 584                         set: &params.GlobalPeriodSet,
 585                         ul:  &params.GlobalPeriod,
 586                 },
 587                 C.VIR_DOMAIN_TUNABLE_CPU_GLOBAL_QUOTA: typedParamsFieldInfo{
 588                         set: &params.GlobalQuotaSet,
 589                         l:   &params.GlobalQuota,
 590                 },
 591                 C.VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD: typedParamsFieldInfo{
 592                         set: &params.EmulatorPeriodSet,
 593                         ul:  &params.EmulatorPeriod,
 594                 },
 595                 C.VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA: typedParamsFieldInfo{
 596                         set: &params.EmulatorQuotaSet,
 597                         l:   &params.EmulatorQuota,
 598                 },
 599                 C.VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD: typedParamsFieldInfo{
 600                         set: &params.VcpuPeriodSet,
 601                         ul:  &params.VcpuPeriod,
 602                 },
 603                 C.VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA: typedParamsFieldInfo{
 604                         set: &params.VcpuQuotaSet,
 605                         l:   &params.VcpuQuota,
 606                 },
 607                 C.VIR_DOMAIN_TUNABLE_CPU_IOTHREAD_PERIOD: typedParamsFieldInfo{
 608                         set: &params.IothreadPeriodSet,
 609                         ul:  &params.IothreadPeriod,
 610                 },
 611                 C.VIR_DOMAIN_TUNABLE_CPU_IOTHREAD_QUOTA: typedParamsFieldInfo{
 612                         set: &params.IothreadQuotaSet,
 613                         l:   &params.IothreadQuota,
 614                 },
 615         }
 616 }
 617
 618 func getTuneBlockIoTuneParametersFieldInfo(params *DomainBlockIoTuneParameters) map[string]typedParamsFieldInfo {
 619         return map[string]typedParamsFieldInfo{
 620                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC: typedParamsFieldInfo{
 621                         set: &params.TotalBytesSecSet,
 622                         ul:  &params.TotalBytesSec,
 623                 },
 624                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC: typedParamsFieldInfo{
 625                         set: &params.ReadBytesSecSet,
 626                         ul:  &params.ReadBytesSec,
 627                 },
 628                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC: typedParamsFieldInfo{
 629                         set: &params.WriteBytesSecSet,
 630                         ul:  &params.WriteBytesSec,
 631                 },
 632                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC: typedParamsFieldInfo{
 633                         set: &params.TotalIopsSecSet,
 634                         ul:  &params.TotalIopsSec,
 635                 },
 636                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC: typedParamsFieldInfo{
 637                         set: &params.ReadIopsSecSet,
 638                         ul:  &params.ReadIopsSec,
 639                 },
 640                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC: typedParamsFieldInfo{
 641                         set: &params.WriteIopsSecSet,
 642                         ul:  &params.WriteIopsSec,
 643                 },
 644                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC_MAX: typedParamsFieldInfo{
 645                         set: &params.TotalBytesSecMaxSet,
 646                         ul:  &params.TotalBytesSecMax,
 647                 },
 648                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC_MAX: typedParamsFieldInfo{
 649                         set: &params.ReadBytesSecMaxSet,
 650                         ul:  &params.ReadBytesSecMax,
 651                 },
 652                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC_MAX: typedParamsFieldInfo{
 653                         set: &params.WriteBytesSecMaxSet,
 654                         ul:  &params.WriteBytesSecMax,
 655                 },
 656                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC_MAX: typedParamsFieldInfo{
 657                         set: &params.TotalIopsSecMaxSet,
 658                         ul:  &params.TotalIopsSecMax,
 659                 },
 660                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC_MAX: typedParamsFieldInfo{
 661                         set: &params.ReadIopsSecMaxSet,
 662                         ul:  &params.ReadIopsSecMax,
 663                 },
 664                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC_MAX: typedParamsFieldInfo{
 665                         set: &params.WriteIopsSecMaxSet,
 666                         ul:  &params.WriteIopsSecMax,
 667                 },
 668                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
 669                         set: &params.TotalBytesSecMaxLengthSet,
 670                         ul:  &params.TotalBytesSecMaxLength,
 671                 },
 672                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
 673                         set: &params.ReadBytesSecMaxLengthSet,
 674                         ul:  &params.ReadBytesSecMaxLength,
 675                 },
 676                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC_MAX_LENGTH: typedParamsFieldInfo{
 677                         set: &params.WriteBytesSecMaxLengthSet,
 678                         ul:  &params.WriteBytesSecMaxLength,
 679                 },
 680                 C.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
 681                         set: &params.TotalIopsSecMaxLengthSet,
 682                         ul:  &params.TotalIopsSecMaxLength,
 683                 },
 684                 C.VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
 685                         set: &params.ReadIopsSecMaxLengthSet,
 686                         ul:  &params.ReadIopsSecMaxLength,
 687                 },
 688                 C.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC_MAX_LENGTH: typedParamsFieldInfo{
 689                         set: &params.WriteIopsSecMaxLengthSet,
 690                         ul:  &params.WriteIopsSecMaxLength,
 691                 },
 692                 C.VIR_DOMAIN_TUNABLE_BLKDEV_SIZE_IOPS_SEC: typedParamsFieldInfo{
 693                         set: &params.SizeIopsSecSet,
 694                         ul:  &params.SizeIopsSec,
 695                 },
 696                 C.VIR_DOMAIN_TUNABLE_BLKDEV_GROUP_NAME: typedParamsFieldInfo{
 697                         set: &params.GroupNameSet,
 698                         s:   &params.GroupName,
 699                 },
 700         }
 701 }
 702
 703 type domainEventTunablePinTemp struct {
 704         VcpuPinSet     bool
 705         VcpuPin        []string
 706         EmulatorPinSet bool
 707         EmulatorPin    string
 708         IOThreadPinSet bool
 709         IOThreadPin    []string
 710 }
 711
 712 func getDomainPinTempFieldInfo(numvcpu int, numiothread int, params *domainEventTunablePinTemp) map[string]typedParamsFieldInfo {
 713         ret := map[string]typedParamsFieldInfo{
 714                 C.VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN: typedParamsFieldInfo{
 715                         set: &params.EmulatorPinSet,
 716                         s:   &params.EmulatorPin,
 717                 },
 718         }
 719         for i := 0; i < numvcpu; i++ {
 720                 ret[fmt.Sprintf("cputune.vcpupin%d", i)] = typedParamsFieldInfo{
 721                         s: &params.VcpuPin[i],
 722                 }
 723         }
 724         for i := 0; i < numiothread; i++ {
 725                 ret[fmt.Sprintf("cputune.iothreadpin%d", i)] = typedParamsFieldInfo{
 726                         s: &params.IOThreadPin[i],
 727                 }
 728         }
 729
 730         return ret
 731 }
 732
 733 func countPinInfo(cparams C.virTypedParameterPtr, nparams C.int) (int, int) {
 734         maxvcpus := 0
 735         maxiothreads := 0
 736         for i := 0; i < int(nparams); i++ {
 737                 var cparam *C.virTypedParameter
 738                 cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) + unsafe.Sizeof(*cparam)*uintptr(i)))
 739                 name := C.GoString((*C.char)(unsafe.Pointer(&cparam.field)))
 740
 741                 var vcpu int
 742                 _, err := fmt.Scanf(name, "cputune.vcpupin%d", &vcpu)
 743                 if err == nil {
 744                         if vcpu > maxvcpus {
 745                                 maxvcpus = vcpu
 746                         }
 747                 }
 748
 749                 var iothread int
 750                 _, err = fmt.Scanf(name, "cputune.iothreadpin%d", &iothread)
 751                 if err == nil {
 752                         if iothread > maxiothreads {
 753                                 maxiothreads = iothread
 754                         }
 755                 }
 756         }
 757
 758         return maxvcpus + 1, maxiothreads + 1
 759 }
 760
 761 func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams C.int) *DomainEventTunableCpuPin {
 762         var pin domainEventTunablePinTemp
 763         numvcpus, numiothreads := countPinInfo(params, nparams)
 764         pinInfo := getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin)
 765
 766         num, err := typedParamsUnpackLen(params, int(nparams), pinInfo)
 767         if num == 0 || err != nil {
 768                 return nil
 769         }
 770
 771         info := &DomainEventTunableCpuPin{}
 772
 773         if pin.VcpuPinSet {
 774                 info.VcpuPinSet = true
 775                 info.VcpuPin = make([][]bool, len(pin.VcpuPin))
 776
 777                 for i := 0; i < len(pin.VcpuPin); i++ {
 778                         bits, err := parseCPUString(pin.VcpuPin[i])
 779                         if err == nil {
 780                                 info.VcpuPin[i] = bits
 781                         }
 782                 }
 783         }
 784
 785         if pin.EmulatorPinSet {
 786                 bits, err := parseCPUString(pin.EmulatorPin)
 787                 if err == nil {
 788                         info.EmulatorPinSet = true
 789                         info.EmulatorPin = bits
 790                 }
 791         }
 792
 793         if pin.IOThreadPinSet {
 794                 info.IOThreadPinSet = true
 795                 info.IOThreadPin = make([][]bool, len(pin.IOThreadPin))
 796
 797                 for i := 0; i < len(pin.IOThreadPin); i++ {
 798                         bits, err := parseCPUString(pin.IOThreadPin[i])
 799                         if err == nil {
 800                                 info.IOThreadPin[i] = bits
 801                         }
 802                 }
 803         }
 804
 805         return info
 806 }
 807
 808 //export domainEventTunableCallback
 809 func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, nparams C.int, goCallbackId int) {
 810         domain := &Domain{ptr: d}
 811         connection := &Connect{ptr: c}
 812
 813         eventDetails := &DomainEventTunable{}
 814
 815         pin := domainEventTunableGetPin(params, nparams)
 816         if pin != nil {
 817                 eventDetails.CpuPin = pin
 818         }
 819
 820         var sched DomainSchedulerParameters
 821         schedInfo := getDomainTuneSchedulerParametersFieldInfo(&sched)
 822
 823         num, _ := typedParamsUnpackLen(params, int(nparams), schedInfo)
 824         if num > 0 {
 825                 eventDetails.CpuSched = &sched
 826         }
 827
 828         blknameInfo := map[string]typedParamsFieldInfo{
 829                 C.VIR_DOMAIN_TUNABLE_BLKDEV_DISK: typedParamsFieldInfo{
 830                         set: &eventDetails.BlkdevDiskSet,
 831                         s:   &eventDetails.BlkdevDisk,
 832                 },
 833         }
 834         typedParamsUnpackLen(params, int(nparams), blknameInfo)
 835
 836         var blktune DomainBlockIoTuneParameters
 837         blktuneInfo := getTuneBlockIoTuneParametersFieldInfo(&blktune)
 838
 839         num, _ = typedParamsUnpackLen(params, int(nparams), blktuneInfo)
 840         if num > 0 {
 841                 eventDetails.BlkdevTune = &blktune
 842         }
 843
 844         callbackFunc := getCallbackId(goCallbackId)
 845         callback, ok := callbackFunc.(DomainEventTunableCallback)
 846         if !ok {
 847                 panic("Inappropriate callback type called")
 848         }
 849         callback(connection, domain, eventDetails)
 850
 851 }
 852
 853 //export domainEventAgentLifecycleCallback
 854 func domainEventAgentLifecycleCallback(c C.virConnectPtr, d C.virDomainPtr, state C.int, reason C.int, goCallbackId int) {
 855         domain := &Domain{ptr: d}
 856         connection := &Connect{ptr: c}
 857
 858         eventDetails := &DomainEventAgentLifecycle{
 859                 State:  ConnectDomainEventAgentLifecycleState(state),
 860                 Reason: ConnectDomainEventAgentLifecycleReason(reason),
 861         }
 862         callbackFunc := getCallbackId(goCallbackId)
 863         callback, ok := callbackFunc.(DomainEventAgentLifecycleCallback)
 864         if !ok {
 865                 panic("Inappropriate callback type called")
 866         }
 867         callback(connection, domain, eventDetails)
 868
 869 }
 870
 871 //export domainEventDeviceAddedCallback
 872 func domainEventDeviceAddedCallback(c C.virConnectPtr, d C.virDomainPtr, devalias *C.char, goCallbackId int) {
 873         domain := &Domain{ptr: d}
 874         connection := &Connect{ptr: c}
 875
 876         eventDetails := &DomainEventDeviceAdded{
 877                 DevAlias: C.GoString(devalias),
 878         }
 879         callbackFunc := getCallbackId(goCallbackId)
 880         callback, ok := callbackFunc.(DomainEventDeviceAddedCallback)
 881         if !ok {
 882                 panic("Inappropriate callback type called")
 883         }
 884         callback(connection, domain, eventDetails)
 885
 886 }
 887
 888 //export domainEventMigrationIterationCallback
 889 func domainEventMigrationIterationCallback(c C.virConnectPtr, d C.virDomainPtr, iteration C.int, goCallbackId int) {
 890         domain := &Domain{ptr: d}
 891         connection := &Connect{ptr: c}
 892
 893         eventDetails := &DomainEventMigrationIteration{
 894                 Iteration: int(iteration),
 895         }
 896         callbackFunc := getCallbackId(goCallbackId)
 897         callback, ok := callbackFunc.(DomainEventMigrationIterationCallback)
 898         if !ok {
 899                 panic("Inappropriate callback type called")
 900         }
 901         callback(connection, domain, eventDetails)
 902
 903 }
 904
 905 //export domainEventJobCompletedCallback
 906 func domainEventJobCompletedCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, nparams C.int, goCallbackId int) {
 907         domain := &Domain{ptr: d}
 908         connection := &Connect{ptr: c}
 909
 910         eventDetails := &DomainEventJobCompleted{}
 911         info := getDomainJobInfoFieldInfo(&eventDetails.Info)
 912
 913         typedParamsUnpackLen(params, int(nparams), info)
 914
 915         callbackFunc := getCallbackId(goCallbackId)
 916         callback, ok := callbackFunc.(DomainEventJobCompletedCallback)
 917         if !ok {
 918                 panic("Inappropriate callback type called")
 919         }
 920         callback(connection, domain, eventDetails)
 921
 922 }
 923
 924 //export domainEventDeviceRemovalFailedCallback
 925 func domainEventDeviceRemovalFailedCallback(c C.virConnectPtr, d C.virDomainPtr, devalias *C.char, goCallbackId int) {
 926         domain := &Domain{ptr: d}
 927         connection := &Connect{ptr: c}
 928
 929         eventDetails := &DomainEventDeviceRemovalFailed{
 930                 DevAlias: C.GoString(devalias),
 931         }
 932         callbackFunc := getCallbackId(goCallbackId)
 933         callback, ok := callbackFunc.(DomainEventDeviceRemovalFailedCallback)
 934         if !ok {
 935                 panic("Inappropriate callback type called")
 936         }
 937         callback(connection, domain, eventDetails)
 938
 939 }
 940
 941 //export domainEventBlockThresholdCallback
 942 func domainEventBlockThresholdCallback(c C.virConnectPtr, d C.virDomainPtr, dev *C.char, path *C.char, threshold C.ulonglong, excess C.ulonglong, goCallbackId int) {
 943         domain := &Domain{ptr: d}
 944         connection := &Connect{ptr: c}
 945
 946         eventDetails := &DomainEventBlockThreshold{
 947                 Dev:       C.GoString(dev),
 948                 Path:      C.GoString(path),
 949                 Threshold: uint64(threshold),
 950                 Excess:    uint64(excess),
 951         }
 952         callbackFunc := getCallbackId(goCallbackId)
 953         callback, ok := callbackFunc.(DomainEventBlockThresholdCallback)
 954         if !ok {
 955                 panic("Inappropriate callback type called")
 956         }
 957         callback(connection, domain, eventDetails)
 958
 959 }
 960
 961 func (c *Connect) DomainEventLifecycleRegister(dom *Domain, callback DomainEventLifecycleCallback) (int, error) {
 962         goCallBackId := registerCallbackId(callback)
 963
 964         callbackPtr := unsafe.Pointer(C.domainEventLifecycleCallbackHelper)
 965         var cdom C.virDomainPtr
 966         if dom != nil {
 967                 cdom = dom.ptr
 968         }
 969         var err C.virError
 970         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
 971                 C.VIR_DOMAIN_EVENT_ID_LIFECYCLE,
 972                 C.virConnectDomainEventGenericCallback(callbackPtr),
 973                 C.long(goCallBackId), &err)
 974         if ret == -1 {
 975                 freeCallbackId(goCallBackId)
 976                 return 0, makeError(&err)
 977         }
 978         return int(ret), nil
 979 }
 980
 981 func (c *Connect) DomainEventRebootRegister(dom *Domain, callback DomainEventGenericCallback) (int, error) {
 982         goCallBackId := registerCallbackId(callback)
 983
 984         callbackPtr := unsafe.Pointer(C.domainEventGenericCallbackHelper)
 985         var cdom C.virDomainPtr
 986         if dom != nil {
 987                 cdom = dom.ptr
 988         }
 989         var err C.virError
 990         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
 991                 C.VIR_DOMAIN_EVENT_ID_REBOOT,
 992                 C.virConnectDomainEventGenericCallback(callbackPtr),
 993                 C.long(goCallBackId), &err)
 994         if ret == -1 {
 995                 freeCallbackId(goCallBackId)
 996                 return 0, makeError(&err)
 997         }
 998         return int(ret), nil
 999 }
1000
1001 func (c *Connect) DomainEventRTCChangeRegister(dom *Domain, callback DomainEventRTCChangeCallback) (int, error) {
1002         goCallBackId := registerCallbackId(callback)
1003
1004         callbackPtr := unsafe.Pointer(C.domainEventRTCChangeCallbackHelper)
1005         var cdom C.virDomainPtr
1006         if dom != nil {
1007                 cdom = dom.ptr
1008         }
1009         var err C.virError
1010         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1011                 C.VIR_DOMAIN_EVENT_ID_RTC_CHANGE,
1012                 C.virConnectDomainEventGenericCallback(callbackPtr),
1013                 C.long(goCallBackId), &err)
1014         if ret == -1 {
1015                 freeCallbackId(goCallBackId)
1016                 return 0, makeError(&err)
1017         }
1018         return int(ret), nil
1019 }
1020
1021 func (c *Connect) DomainEventWatchdogRegister(dom *Domain, callback DomainEventWatchdogCallback) (int, error) {
1022         goCallBackId := registerCallbackId(callback)
1023
1024         callbackPtr := unsafe.Pointer(C.domainEventWatchdogCallbackHelper)
1025         var cdom C.virDomainPtr
1026         if dom != nil {
1027                 cdom = dom.ptr
1028         }
1029         var err C.virError
1030         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1031                 C.VIR_DOMAIN_EVENT_ID_WATCHDOG,
1032                 C.virConnectDomainEventGenericCallback(callbackPtr),
1033                 C.long(goCallBackId), &err)
1034         if ret == -1 {
1035                 freeCallbackId(goCallBackId)
1036                 return 0, makeError(&err)
1037         }
1038         return int(ret), nil
1039 }
1040
1041 func (c *Connect) DomainEventIOErrorRegister(dom *Domain, callback DomainEventIOErrorCallback) (int, error) {
1042         goCallBackId := registerCallbackId(callback)
1043
1044         callbackPtr := unsafe.Pointer(C.domainEventIOErrorCallbackHelper)
1045         var cdom C.virDomainPtr
1046         if dom != nil {
1047                 cdom = dom.ptr
1048         }
1049         var err C.virError
1050         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1051                 C.VIR_DOMAIN_EVENT_ID_IO_ERROR,
1052                 C.virConnectDomainEventGenericCallback(callbackPtr),
1053                 C.long(goCallBackId), &err)
1054         if ret == -1 {
1055                 freeCallbackId(goCallBackId)
1056                 return 0, makeError(&err)
1057         }
1058         return int(ret), nil
1059 }
1060
1061 func (c *Connect) DomainEventGraphicsRegister(dom *Domain, callback DomainEventGraphicsCallback) (int, error) {
1062         goCallBackId := registerCallbackId(callback)
1063
1064         callbackPtr := unsafe.Pointer(C.domainEventGraphicsCallbackHelper)
1065         var cdom C.virDomainPtr
1066         if dom != nil {
1067                 cdom = dom.ptr
1068         }
1069         var err C.virError
1070         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1071                 C.VIR_DOMAIN_EVENT_ID_GRAPHICS,
1072                 C.virConnectDomainEventGenericCallback(callbackPtr),
1073                 C.long(goCallBackId), &err)
1074         if ret == -1 {
1075                 freeCallbackId(goCallBackId)
1076                 return 0, makeError(&err)
1077         }
1078         return int(ret), nil
1079 }
1080
1081 func (c *Connect) DomainEventIOErrorReasonRegister(dom *Domain, callback DomainEventIOErrorReasonCallback) (int, error) {
1082         goCallBackId := registerCallbackId(callback)
1083
1084         callbackPtr := unsafe.Pointer(C.domainEventIOErrorReasonCallbackHelper)
1085         var cdom C.virDomainPtr
1086         if dom != nil {
1087                 cdom = dom.ptr
1088         }
1089         var err C.virError
1090         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1091                 C.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON,
1092                 C.virConnectDomainEventGenericCallback(callbackPtr),
1093                 C.long(goCallBackId), &err)
1094         if ret == -1 {
1095                 freeCallbackId(goCallBackId)
1096                 return 0, makeError(&err)
1097         }
1098         return int(ret), nil
1099 }
1100
1101 func (c *Connect) DomainEventControlErrorRegister(dom *Domain, callback DomainEventGenericCallback) (int, error) {
1102         goCallBackId := registerCallbackId(callback)
1103
1104         callbackPtr := unsafe.Pointer(C.domainEventGenericCallbackHelper)
1105         var cdom C.virDomainPtr
1106         if dom != nil {
1107                 cdom = dom.ptr
1108         }
1109         var err C.virError
1110         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1111                 C.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR,
1112                 C.virConnectDomainEventGenericCallback(callbackPtr),
1113                 C.long(goCallBackId), &err)
1114         if ret == -1 {
1115                 freeCallbackId(goCallBackId)
1116                 return 0, makeError(&err)
1117         }
1118         return int(ret), nil
1119 }
1120
1121 func (c *Connect) DomainEventBlockJobRegister(dom *Domain, callback DomainEventBlockJobCallback) (int, error) {
1122         goCallBackId := registerCallbackId(callback)
1123
1124         callbackPtr := unsafe.Pointer(C.domainEventBlockJobCallbackHelper)
1125         var cdom C.virDomainPtr
1126         if dom != nil {
1127                 cdom = dom.ptr
1128         }
1129         var err C.virError
1130         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1131                 C.VIR_DOMAIN_EVENT_ID_BLOCK_JOB,
1132                 C.virConnectDomainEventGenericCallback(callbackPtr),
1133                 C.long(goCallBackId), &err)
1134         if ret == -1 {
1135                 freeCallbackId(goCallBackId)
1136                 return 0, makeError(&err)
1137         }
1138         return int(ret), nil
1139 }
1140
1141 func (c *Connect) DomainEventDiskChangeRegister(dom *Domain, callback DomainEventDiskChangeCallback) (int, error) {
1142         goCallBackId := registerCallbackId(callback)
1143
1144         callbackPtr := unsafe.Pointer(C.domainEventDiskChangeCallbackHelper)
1145         var cdom C.virDomainPtr
1146         if dom != nil {
1147                 cdom = dom.ptr
1148         }
1149         var err C.virError
1150         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1151                 C.VIR_DOMAIN_EVENT_ID_DISK_CHANGE,
1152                 C.virConnectDomainEventGenericCallback(callbackPtr),
1153                 C.long(goCallBackId), &err)
1154         if ret == -1 {
1155                 freeCallbackId(goCallBackId)
1156                 return 0, makeError(&err)
1157         }
1158         return int(ret), nil
1159 }
1160
1161 func (c *Connect) DomainEventTrayChangeRegister(dom *Domain, callback DomainEventTrayChangeCallback) (int, error) {
1162         goCallBackId := registerCallbackId(callback)
1163
1164         callbackPtr := unsafe.Pointer(C.domainEventTrayChangeCallbackHelper)
1165         var cdom C.virDomainPtr
1166         if dom != nil {
1167                 cdom = dom.ptr
1168         }
1169         var err C.virError
1170         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1171                 C.VIR_DOMAIN_EVENT_ID_TRAY_CHANGE,
1172                 C.virConnectDomainEventGenericCallback(callbackPtr),
1173                 C.long(goCallBackId), &err)
1174         if ret == -1 {
1175                 freeCallbackId(goCallBackId)
1176                 return 0, makeError(&err)
1177         }
1178         return int(ret), nil
1179 }
1180
1181 func (c *Connect) DomainEventPMWakeupRegister(dom *Domain, callback DomainEventPMWakeupCallback) (int, error) {
1182         goCallBackId := registerCallbackId(callback)
1183
1184         callbackPtr := unsafe.Pointer(C.domainEventPMWakeupCallbackHelper)
1185         var cdom C.virDomainPtr
1186         if dom != nil {
1187                 cdom = dom.ptr
1188         }
1189         var err C.virError
1190         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1191                 C.VIR_DOMAIN_EVENT_ID_PMWAKEUP,
1192                 C.virConnectDomainEventGenericCallback(callbackPtr),
1193                 C.long(goCallBackId), &err)
1194         if ret == -1 {
1195                 freeCallbackId(goCallBackId)
1196                 return 0, makeError(&err)
1197         }
1198         return int(ret), nil
1199 }
1200
1201 func (c *Connect) DomainEventPMSuspendRegister(dom *Domain, callback DomainEventPMSuspendCallback) (int, error) {
1202         goCallBackId := registerCallbackId(callback)
1203
1204         callbackPtr := unsafe.Pointer(C.domainEventPMSuspendCallbackHelper)
1205         var cdom C.virDomainPtr
1206         if dom != nil {
1207                 cdom = dom.ptr
1208         }
1209         var err C.virError
1210         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1211                 C.VIR_DOMAIN_EVENT_ID_PMSUSPEND,
1212                 C.virConnectDomainEventGenericCallback(callbackPtr),
1213                 C.long(goCallBackId), &err)
1214         if ret == -1 {
1215                 freeCallbackId(goCallBackId)
1216                 return 0, makeError(&err)
1217         }
1218         return int(ret), nil
1219 }
1220
1221 func (c *Connect) DomainEventBalloonChangeRegister(dom *Domain, callback DomainEventBalloonChangeCallback) (int, error) {
1222         goCallBackId := registerCallbackId(callback)
1223
1224         callbackPtr := unsafe.Pointer(C.domainEventBalloonChangeCallbackHelper)
1225         var cdom C.virDomainPtr
1226         if dom != nil {
1227                 cdom = dom.ptr
1228         }
1229         var err C.virError
1230         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1231                 C.VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE,
1232                 C.virConnectDomainEventGenericCallback(callbackPtr),
1233                 C.long(goCallBackId), &err)
1234         if ret == -1 {
1235                 freeCallbackId(goCallBackId)
1236                 return 0, makeError(&err)
1237         }
1238         return int(ret), nil
1239 }
1240
1241 func (c *Connect) DomainEventPMSuspendDiskRegister(dom *Domain, callback DomainEventPMSuspendDiskCallback) (int, error) {
1242         goCallBackId := registerCallbackId(callback)
1243
1244         callbackPtr := unsafe.Pointer(C.domainEventPMSuspendDiskCallbackHelper)
1245         var cdom C.virDomainPtr
1246         if dom != nil {
1247                 cdom = dom.ptr
1248         }
1249         var err C.virError
1250         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1251                 C.VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK,
1252                 C.virConnectDomainEventGenericCallback(callbackPtr),
1253                 C.long(goCallBackId), &err)
1254         if ret == -1 {
1255                 freeCallbackId(goCallBackId)
1256                 return 0, makeError(&err)
1257         }
1258         return int(ret), nil
1259 }
1260
1261 func (c *Connect) DomainEventDeviceRemovedRegister(dom *Domain, callback DomainEventDeviceRemovedCallback) (int, error) {
1262         goCallBackId := registerCallbackId(callback)
1263
1264         callbackPtr := unsafe.Pointer(C.domainEventDeviceRemovedCallbackHelper)
1265         var cdom C.virDomainPtr
1266         if dom != nil {
1267                 cdom = dom.ptr
1268         }
1269         var err C.virError
1270         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1271                 C.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED,
1272                 C.virConnectDomainEventGenericCallback(callbackPtr),
1273                 C.long(goCallBackId), &err)
1274         if ret == -1 {
1275                 freeCallbackId(goCallBackId)
1276                 return 0, makeError(&err)
1277         }
1278         return int(ret), nil
1279 }
1280
1281 func (c *Connect) DomainEventBlockJob2Register(dom *Domain, callback DomainEventBlockJobCallback) (int, error) {
1282         goCallBackId := registerCallbackId(callback)
1283
1284         callbackPtr := unsafe.Pointer(C.domainEventBlockJobCallbackHelper)
1285         var cdom C.virDomainPtr
1286         if dom != nil {
1287                 cdom = dom.ptr
1288         }
1289         var err C.virError
1290         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1291                 C.VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2,
1292                 C.virConnectDomainEventGenericCallback(callbackPtr),
1293                 C.long(goCallBackId), &err)
1294         if ret == -1 {
1295                 freeCallbackId(goCallBackId)
1296                 return 0, makeError(&err)
1297         }
1298         return int(ret), nil
1299 }
1300
1301 func (c *Connect) DomainEventTunableRegister(dom *Domain, callback DomainEventTunableCallback) (int, error) {
1302         goCallBackId := registerCallbackId(callback)
1303
1304         callbackPtr := unsafe.Pointer(C.domainEventTunableCallbackHelper)
1305         var cdom C.virDomainPtr
1306         if dom != nil {
1307                 cdom = dom.ptr
1308         }
1309         var err C.virError
1310         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1311                 C.VIR_DOMAIN_EVENT_ID_TUNABLE,
1312                 C.virConnectDomainEventGenericCallback(callbackPtr),
1313                 C.long(goCallBackId), &err)
1314         if ret == -1 {
1315                 freeCallbackId(goCallBackId)
1316                 return 0, makeError(&err)
1317         }
1318         return int(ret), nil
1319 }
1320
1321 func (c *Connect) DomainEventAgentLifecycleRegister(dom *Domain, callback DomainEventAgentLifecycleCallback) (int, error) {
1322         goCallBackId := registerCallbackId(callback)
1323
1324         callbackPtr := unsafe.Pointer(C.domainEventAgentLifecycleCallbackHelper)
1325         var cdom C.virDomainPtr
1326         if dom != nil {
1327                 cdom = dom.ptr
1328         }
1329         var err C.virError
1330         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1331                 C.VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE,
1332                 C.virConnectDomainEventGenericCallback(callbackPtr),
1333                 C.long(goCallBackId), &err)
1334         if ret == -1 {
1335                 freeCallbackId(goCallBackId)
1336                 return 0, makeError(&err)
1337         }
1338         return int(ret), nil
1339 }
1340
1341 func (c *Connect) DomainEventDeviceAddedRegister(dom *Domain, callback DomainEventDeviceAddedCallback) (int, error) {
1342         goCallBackId := registerCallbackId(callback)
1343
1344         callbackPtr := unsafe.Pointer(C.domainEventDeviceAddedCallbackHelper)
1345         var cdom C.virDomainPtr
1346         if dom != nil {
1347                 cdom = dom.ptr
1348         }
1349         var err C.virError
1350         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1351                 C.VIR_DOMAIN_EVENT_ID_DEVICE_ADDED,
1352                 C.virConnectDomainEventGenericCallback(callbackPtr),
1353                 C.long(goCallBackId), &err)
1354         if ret == -1 {
1355                 freeCallbackId(goCallBackId)
1356                 return 0, makeError(&err)
1357         }
1358         return int(ret), nil
1359 }
1360
1361 func (c *Connect) DomainEventMigrationIterationRegister(dom *Domain, callback DomainEventMigrationIterationCallback) (int, error) {
1362         goCallBackId := registerCallbackId(callback)
1363
1364         callbackPtr := unsafe.Pointer(C.domainEventMigrationIterationCallbackHelper)
1365         var cdom C.virDomainPtr
1366         if dom != nil {
1367                 cdom = dom.ptr
1368         }
1369         var err C.virError
1370         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1371                 C.VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION,
1372                 C.virConnectDomainEventGenericCallback(callbackPtr),
1373                 C.long(goCallBackId), &err)
1374         if ret == -1 {
1375                 freeCallbackId(goCallBackId)
1376                 return 0, makeError(&err)
1377         }
1378         return int(ret), nil
1379 }
1380
1381 func (c *Connect) DomainEventJobCompletedRegister(dom *Domain, callback DomainEventJobCompletedCallback) (int, error) {
1382         goCallBackId := registerCallbackId(callback)
1383
1384         callbackPtr := unsafe.Pointer(C.domainEventJobCompletedCallbackHelper)
1385         var cdom C.virDomainPtr
1386         if dom != nil {
1387                 cdom = dom.ptr
1388         }
1389         var err C.virError
1390         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1391                 C.VIR_DOMAIN_EVENT_ID_JOB_COMPLETED,
1392                 C.virConnectDomainEventGenericCallback(callbackPtr),
1393                 C.long(goCallBackId), &err)
1394         if ret == -1 {
1395                 freeCallbackId(goCallBackId)
1396                 return 0, makeError(&err)
1397         }
1398         return int(ret), nil
1399 }
1400
1401 func (c *Connect) DomainEventDeviceRemovalFailedRegister(dom *Domain, callback DomainEventDeviceRemovalFailedCallback) (int, error) {
1402         goCallBackId := registerCallbackId(callback)
1403
1404         callbackPtr := unsafe.Pointer(C.domainEventDeviceRemovalFailedCallbackHelper)
1405         var cdom C.virDomainPtr
1406         if dom != nil {
1407                 cdom = dom.ptr
1408         }
1409         var err C.virError
1410         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1411                 C.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED,
1412                 C.virConnectDomainEventGenericCallback(callbackPtr),
1413                 C.long(goCallBackId), &err)
1414         if ret == -1 {
1415                 freeCallbackId(goCallBackId)
1416                 return 0, makeError(&err)
1417         }
1418         return int(ret), nil
1419 }
1420
1421 func (c *Connect) DomainEventMetadataChangeRegister(dom *Domain, callback DomainEventMetadataChangeCallback) (int, error) {
1422         goCallBackId := registerCallbackId(callback)
1423
1424         callbackPtr := unsafe.Pointer(C.domainEventMetadataChangeCallbackHelper)
1425         var cdom C.virDomainPtr
1426         if dom != nil {
1427                 cdom = dom.ptr
1428         }
1429         var err C.virError
1430         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1431                 C.VIR_DOMAIN_EVENT_ID_METADATA_CHANGE,
1432                 C.virConnectDomainEventGenericCallback(callbackPtr),
1433                 C.long(goCallBackId), &err)
1434         if ret == -1 {
1435                 freeCallbackId(goCallBackId)
1436                 return 0, makeError(&err)
1437         }
1438         return int(ret), nil
1439 }
1440
1441 func (c *Connect) DomainEventBlockThresholdRegister(dom *Domain, callback DomainEventBlockThresholdCallback) (int, error) {
1442         goCallBackId := registerCallbackId(callback)
1443
1444         callbackPtr := unsafe.Pointer(C.domainEventBlockThresholdCallbackHelper)
1445         var cdom C.virDomainPtr
1446         if dom != nil {
1447                 cdom = dom.ptr
1448         }
1449         var err C.virError
1450         ret := C.virConnectDomainEventRegisterAnyWrapper(c.ptr, cdom,
1451                 C.VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD,
1452                 C.virConnectDomainEventGenericCallback(callbackPtr),
1453                 C.long(goCallBackId), &err)
1454         if ret == -1 {
1455                 freeCallbackId(goCallBackId)
1456                 return 0, makeError(&err)
1457         }
1458         return int(ret), nil
1459 }
1460
1461 func (c *Connect) DomainEventDeregister(callbackId int) error {
1462         // Deregister the callback
1463         var err C.virError
1464         ret := int(C.virConnectDomainEventDeregisterAnyWrapper(c.ptr, C.int(callbackId), &err))
1465         if ret < 0 {
1466                 return makeError(&err)
1467         }
1468         return nil
1469 }
1470
1471 func (e DomainEventLifecycle) String() string {
1472         var detail, event string
1473         switch e.Event {
1474         case DOMAIN_EVENT_DEFINED:
1475                 event = "defined"
1476                 switch DomainEventDefinedDetailType(e.Detail) {
1477                 case DOMAIN_EVENT_DEFINED_ADDED:
1478                         detail = "added"
1479                 case DOMAIN_EVENT_DEFINED_UPDATED:
1480                         detail = "updated"
1481                 default:
1482                         detail = "unknown"
1483                 }
1484
1485         case DOMAIN_EVENT_UNDEFINED:
1486                 event = "undefined"
1487                 switch DomainEventUndefinedDetailType(e.Detail) {
1488                 case DOMAIN_EVENT_UNDEFINED_REMOVED:
1489                         detail = "removed"
1490                 default:
1491                         detail = "unknown"
1492                 }
1493
1494         case DOMAIN_EVENT_STARTED:
1495                 event = "started"
1496                 switch DomainEventStartedDetailType(e.Detail) {
1497                 case DOMAIN_EVENT_STARTED_BOOTED:
1498                         detail = "booted"
1499                 case DOMAIN_EVENT_STARTED_MIGRATED:
1500                         detail = "migrated"
1501                 case DOMAIN_EVENT_STARTED_RESTORED:
1502                         detail = "restored"
1503                 case DOMAIN_EVENT_STARTED_FROM_SNAPSHOT:
1504                         detail = "snapshot"
1505                 default:
1506                         detail = "unknown"
1507                 }
1508
1509         case DOMAIN_EVENT_SUSPENDED:
1510                 event = "suspended"
1511                 switch DomainEventSuspendedDetailType(e.Detail) {
1512                 case DOMAIN_EVENT_SUSPENDED_PAUSED:
1513                         detail = "paused"
1514                 case DOMAIN_EVENT_SUSPENDED_MIGRATED:
1515                         detail = "migrated"
1516                 case DOMAIN_EVENT_SUSPENDED_IOERROR:
1517                         detail = "I/O error"
1518                 case DOMAIN_EVENT_SUSPENDED_WATCHDOG:
1519                         detail = "watchdog"
1520                 case DOMAIN_EVENT_SUSPENDED_RESTORED:
1521                         detail = "restored"
1522                 case DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT:
1523                         detail = "snapshot"
1524                 default:
1525                         detail = "unknown"
1526                 }
1527
1528         case DOMAIN_EVENT_RESUMED:
1529                 event = "resumed"
1530                 switch DomainEventResumedDetailType(e.Detail) {
1531                 case DOMAIN_EVENT_RESUMED_UNPAUSED:
1532                         detail = "unpaused"
1533                 case DOMAIN_EVENT_RESUMED_MIGRATED:
1534                         detail = "migrated"
1535                 case DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT:
1536                         detail = "snapshot"
1537                 default:
1538                         detail = "unknown"
1539                 }
1540
1541         case DOMAIN_EVENT_STOPPED:
1542                 event = "stopped"
1543                 switch DomainEventStoppedDetailType(e.Detail) {
1544                 case DOMAIN_EVENT_STOPPED_SHUTDOWN:
1545                         detail = "shutdown"
1546                 case DOMAIN_EVENT_STOPPED_DESTROYED:
1547                         detail = "destroyed"
1548                 case DOMAIN_EVENT_STOPPED_CRASHED:
1549                         detail = "crashed"
1550                 case DOMAIN_EVENT_STOPPED_MIGRATED:
1551                         detail = "migrated"
1552                 case DOMAIN_EVENT_STOPPED_SAVED:
1553                         detail = "saved"
1554                 case DOMAIN_EVENT_STOPPED_FAILED:
1555                         detail = "failed"
1556                 case DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT:
1557                         detail = "snapshot"
1558                 default:
1559                         detail = "unknown"
1560                 }
1561
1562         case DOMAIN_EVENT_SHUTDOWN:
1563                 event = "shutdown"
1564                 switch DomainEventShutdownDetailType(e.Detail) {
1565                 case DOMAIN_EVENT_SHUTDOWN_FINISHED:
1566                         detail = "finished"
1567                 default:
1568                         detail = "unknown"
1569                 }
1570
1571         default:
1572                 event = "unknown"
1573         }
1574
1575         return fmt.Sprintf("Domain event=%q detail=%q", event, detail)
1576 }
1577
1578 func (e DomainEventRTCChange) String() string {
1579         return fmt.Sprintf("RTC change offset=%d", e.Utcoffset)
1580 }
1581
1582 func (e DomainEventWatchdog) String() string {
1583         return fmt.Sprintf("Watchdog action=%d", e.Action)
1584 }
1585
1586 func (e DomainEventIOError) String() string {
1587         return fmt.Sprintf("I/O error path=%q alias=%q action=%d",
1588                 e.SrcPath, e.DevAlias, e.Action)
1589 }
1590
1591 func (e DomainEventGraphics) String() string {
1592         var phase string
1593         switch e.Phase {
1594         case DOMAIN_EVENT_GRAPHICS_CONNECT:
1595                 phase = "connected"
1596         case DOMAIN_EVENT_GRAPHICS_INITIALIZE:
1597                 phase = "initialized"
1598         case DOMAIN_EVENT_GRAPHICS_DISCONNECT:
1599                 phase = "disconnected"
1600         default:
1601                 phase = "unknown"
1602         }
1603
1604         return fmt.Sprintf("Graphics phase=%q", phase)
1605 }
1606
1607 func (e DomainEventIOErrorReason) String() string {
1608         return fmt.Sprintf("IO error path=%q alias=%q action=%d reason=%q",
1609                 e.SrcPath, e.DevAlias, e.Action, e.Reason)
1610 }
1611
1612 func (e DomainEventBlockJob) String() string {
1613         return fmt.Sprintf("Block job disk=%q status=%d type=%d",
1614                 e.Disk, e.Status, e.Type)
1615 }
1616
1617 func (e DomainEventDiskChange) String() string {
1618         return fmt.Sprintf("Disk change old=%q new=%q alias=%q reason=%d",
1619                 e.OldSrcPath, e.NewSrcPath, e.DevAlias, e.Reason)
1620 }
1621
1622 func (e DomainEventTrayChange) String() string {
1623         return fmt.Sprintf("Tray change dev=%q reason=%d",
1624                 e.DevAlias, e.Reason)
1625 }
1626
1627 func (e DomainEventBalloonChange) String() string {
1628         return fmt.Sprintf("Ballon change %d", e.Actual)
1629 }
1630
1631 func (e DomainEventDeviceRemoved) String() string {
1632         return fmt.Sprintf("Device %q removed ", e.DevAlias)
1633 }