src/dma/vendor/github.com/libvirt/libvirt-go/domain_wrapper.h

   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 #ifndef LIBVIRT_GO_DOMAIN_WRAPPER_H__
  28 #define LIBVIRT_GO_DOMAIN_WRAPPER_H__
  29
  30 #include <libvirt/libvirt.h>
  31 #include <libvirt/virterror.h>
  32 #include "domain_compat.h"
  33
  34 int
  35 virDomainAbortJobWrapper(virDomainPtr domain,
  36                          virErrorPtr err);
  37
  38 int
  39 virDomainAddIOThreadWrapper(virDomainPtr domain,
  40                             unsigned int iothread_id,
  41                             unsigned int flags,
  42                             virErrorPtr err);
  43
  44 int
  45 virDomainAttachDeviceWrapper(virDomainPtr domain,
  46                              const char *xml,
  47                              virErrorPtr err);
  48
  49 int
  50 virDomainAttachDeviceFlagsWrapper(virDomainPtr domain,
  51                                   const char *xml,
  52                                   unsigned int flags,
  53                                   virErrorPtr err);
  54
  55 int
  56 virDomainBlockCommitWrapper(virDomainPtr dom,
  57                             const char *disk,
  58                             const char *base,
  59                             const char *top,
  60                             unsigned long bandwidth,
  61                             unsigned int flags,
  62                             virErrorPtr err);
  63
  64 int
  65 virDomainBlockCopyWrapper(virDomainPtr dom,
  66                           const char *disk,
  67                           const char *destxml,
  68                           virTypedParameterPtr params,
  69                           int nparams,
  70                           unsigned int flags,
  71                           virErrorPtr err);
  72
  73 int
  74 virDomainBlockJobAbortWrapper(virDomainPtr dom,
  75                               const char *disk,
  76                               unsigned int flags,
  77                               virErrorPtr err);
  78
  79 int
  80 virDomainBlockJobSetSpeedWrapper(virDomainPtr dom,
  81                                  const char *disk,
  82                                  unsigned long bandwidth,
  83                                  unsigned int flags,
  84                                  virErrorPtr err);
  85
  86 int
  87 virDomainBlockPeekWrapper(virDomainPtr dom,
  88                           const char *disk,
  89                           unsigned long long offset,
  90                           size_t size,
  91                           void *buffer,
  92                           unsigned int flags,
  93                           virErrorPtr err);
  94
  95 int
  96 virDomainBlockPullWrapper(virDomainPtr dom,
  97                           const char *disk,
  98                           unsigned long bandwidth,
  99                           unsigned int flags,
 100                           virErrorPtr err);
 101
 102 int
 103 virDomainBlockRebaseWrapper(virDomainPtr dom,
 104                             const char *disk,
 105                             const char *base,
 106                             unsigned long bandwidth,
 107                             unsigned int flags,
 108                             virErrorPtr err);
 109
 110 int
 111 virDomainBlockResizeWrapper(virDomainPtr dom,
 112                             const char *disk,
 113                             unsigned long long size,
 114                             unsigned int flags,
 115                             virErrorPtr err);
 116
 117 int
 118 virDomainBlockStatsWrapper(virDomainPtr dom,
 119                            const char *disk,
 120                            virDomainBlockStatsPtr stats,
 121                            size_t size,
 122                            virErrorPtr err);
 123
 124 int
 125 virDomainBlockStatsFlagsWrapper(virDomainPtr dom,
 126                                 const char *disk,
 127                                 virTypedParameterPtr params,
 128                                 int *nparams,
 129                                 unsigned int flags,
 130                                 virErrorPtr err);
 131
 132 int
 133 virDomainCoreDumpWrapper(virDomainPtr domain,
 134                          const char *to,
 135                          unsigned int flags,
 136                          virErrorPtr err);
 137
 138 int
 139 virDomainCoreDumpWithFormatWrapper(virDomainPtr domain,
 140                                    const char *to,
 141                                    unsigned int dumpformat,
 142                                    unsigned int flags,
 143                                    virErrorPtr err);
 144
 145 int
 146 virDomainCreateWrapper(virDomainPtr domain,
 147                        virErrorPtr err);
 148
 149 int
 150 virDomainCreateWithFilesWrapper(virDomainPtr domain,
 151                                 unsigned int nfiles,
 152                                 int *files,
 153                                 unsigned int flags,
 154                                 virErrorPtr err);
 155
 156 int
 157 virDomainCreateWithFlagsWrapper(virDomainPtr domain,
 158                                 unsigned int flags,
 159                                 virErrorPtr err);
 160
 161 int
 162 virDomainDelIOThreadWrapper(virDomainPtr domain,
 163                             unsigned int iothread_id,
 164                             unsigned int flags,
 165                             virErrorPtr err);
 166
 167 int
 168 virDomainDestroyWrapper(virDomainPtr domain,
 169                         virErrorPtr err);
 170
 171 int
 172 virDomainDestroyFlagsWrapper(virDomainPtr domain,
 173                              unsigned int flags,
 174                              virErrorPtr err);
 175
 176 int
 177 virDomainDetachDeviceWrapper(virDomainPtr domain,
 178                              const char *xml,
 179                              virErrorPtr err);
 180
 181 int
 182 virDomainDetachDeviceAliasWrapper(virDomainPtr domain,
 183                                   const char *alias,
 184                                   unsigned int flags,
 185                                   virErrorPtr err);
 186
 187 int
 188 virDomainDetachDeviceFlagsWrapper(virDomainPtr domain,
 189                                   const char *xml,
 190                                   unsigned int flags,
 191                                   virErrorPtr err);
 192
 193 int
 194 virDomainFSFreezeWrapper(virDomainPtr dom,
 195                          const char **mountpoints,
 196                          unsigned int nmountpoints,
 197                          unsigned int flags,
 198                          virErrorPtr err);
 199
 200 void
 201 virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info);
 202
 203 int
 204 virDomainFSThawWrapper(virDomainPtr dom,
 205                        const char **mountpoints,
 206                        unsigned int nmountpoints,
 207                        unsigned int flags,
 208                        virErrorPtr err);
 209
 210 int
 211 virDomainFSTrimWrapper(virDomainPtr dom,
 212                        const char *mountPoint,
 213                        unsigned long long minimum,
 214                        unsigned int flags,
 215                        virErrorPtr err);
 216
 217 int
 218 virDomainFreeWrapper(virDomainPtr domain,
 219                      virErrorPtr err);
 220
 221 int
 222 virDomainGetAutostartWrapper(virDomainPtr domain,
 223                              int *autostart,
 224                              virErrorPtr err);
 225
 226 int
 227 virDomainGetBlkioParametersWrapper(virDomainPtr domain,
 228                                    virTypedParameterPtr params,
 229                                    int *nparams,
 230                                    unsigned int flags,
 231                                    virErrorPtr err);
 232
 233 int
 234 virDomainGetBlockInfoWrapper(virDomainPtr domain,
 235                              const char *disk,
 236                              virDomainBlockInfoPtr info,
 237                              unsigned int flags,
 238                              virErrorPtr err);
 239
 240 int
 241 virDomainGetBlockIoTuneWrapper(virDomainPtr dom,
 242                                const char *disk,
 243                                virTypedParameterPtr params,
 244                                int *nparams,
 245                                unsigned int flags,
 246                                virErrorPtr err);
 247
 248 int
 249 virDomainGetBlockJobInfoWrapper(virDomainPtr dom,
 250                                 const char *disk,
 251                                 virDomainBlockJobInfoPtr info,
 252                                 unsigned int flags,
 253                                 virErrorPtr err);
 254
 255 int
 256 virDomainGetCPUStatsWrapper(virDomainPtr domain,
 257                             virTypedParameterPtr params,
 258                             unsigned int nparams,
 259                             int start_cpu,
 260                             unsigned int ncpus,
 261                             unsigned int flags,
 262                             virErrorPtr err);
 263
 264 virConnectPtr
 265 virDomainGetConnectWrapper(virDomainPtr dom,
 266                            virErrorPtr err);
 267
 268 int
 269 virDomainGetControlInfoWrapper(virDomainPtr domain,
 270                                virDomainControlInfoPtr info,
 271                                unsigned int flags,
 272                                virErrorPtr err);
 273
 274 int
 275 virDomainGetDiskErrorsWrapper(virDomainPtr dom,
 276                               virDomainDiskErrorPtr errors,
 277                               unsigned int maxerrors,
 278                               unsigned int flags,
 279                               virErrorPtr err);
 280
 281 int
 282 virDomainGetEmulatorPinInfoWrapper(virDomainPtr domain,
 283                                    unsigned char *cpumap,
 284                                    int maplen,
 285                                    unsigned int flags,
 286                                    virErrorPtr err);
 287
 288 int
 289 virDomainGetFSInfoWrapper(virDomainPtr dom,
 290                           virDomainFSInfoPtr **info,
 291                           unsigned int flags,
 292                           virErrorPtr err);
 293
 294 int
 295 virDomainGetGuestVcpusWrapper(virDomainPtr domain,
 296                               virTypedParameterPtr *params,
 297                               unsigned int *nparams,
 298                               unsigned int flags,
 299                               virErrorPtr err);
 300
 301 char *
 302 virDomainGetHostnameWrapper(virDomainPtr domain,
 303                             unsigned int flags,
 304                             virErrorPtr err);
 305
 306 unsigned int
 307 virDomainGetIDWrapper(virDomainPtr domain,
 308                       virErrorPtr err);
 309
 310 int
 311 virDomainGetIOThreadInfoWrapper(virDomainPtr dom,
 312                                 virDomainIOThreadInfoPtr **info,
 313                                 unsigned int flags,
 314                                 virErrorPtr err);
 315
 316 int
 317 virDomainGetInfoWrapper(virDomainPtr domain,
 318                         virDomainInfoPtr info,
 319                         virErrorPtr err);
 320
 321 int
 322 virDomainGetInterfaceParametersWrapper(virDomainPtr domain,
 323                                        const char *device,
 324                                        virTypedParameterPtr params,
 325                                        int *nparams,
 326                                        unsigned int flags,
 327                                        virErrorPtr err);
 328
 329 int
 330 virDomainGetJobInfoWrapper(virDomainPtr domain,
 331                            virDomainJobInfoPtr info,
 332                            virErrorPtr err);
 333
 334 int
 335 virDomainGetJobStatsWrapper(virDomainPtr domain,
 336                             int *type,
 337                             virTypedParameterPtr *params,
 338                             int *nparams,
 339                             unsigned int flags,
 340                             virErrorPtr err);
 341
 342 int
 343 virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain,
 344                                       virTypedParameterPtr *params,
 345                                       int *nparams,
 346                                       unsigned int flags,
 347                                       virErrorPtr err);
 348
 349 unsigned long
 350 virDomainGetMaxMemoryWrapper(virDomainPtr domain,
 351                              virErrorPtr err);
 352
 353 int
 354 virDomainGetMaxVcpusWrapper(virDomainPtr domain,
 355                             virErrorPtr err);
 356
 357 int
 358 virDomainGetMemoryParametersWrapper(virDomainPtr domain,
 359                                     virTypedParameterPtr params,
 360                                     int *nparams,
 361                                     unsigned int flags,
 362                                     virErrorPtr err);
 363
 364 char *
 365 virDomainGetMetadataWrapper(virDomainPtr domain,
 366                             int type,
 367                             const char *uri,
 368                             unsigned int flags,
 369                             virErrorPtr err);
 370
 371 const char *
 372 virDomainGetNameWrapper(virDomainPtr domain,
 373                         virErrorPtr err);
 374
 375 int
 376 virDomainGetNumaParametersWrapper(virDomainPtr domain,
 377                                   virTypedParameterPtr params,
 378                                   int *nparams,
 379                                   unsigned int flags,
 380                                   virErrorPtr err);
 381
 382 char *
 383 virDomainGetOSTypeWrapper(virDomainPtr domain,
 384                           virErrorPtr err);
 385
 386 int
 387 virDomainGetPerfEventsWrapper(virDomainPtr domain,
 388                               virTypedParameterPtr *params,
 389                               int *nparams,
 390                               unsigned int flags,
 391                               virErrorPtr err);
 392
 393 int
 394 virDomainGetSchedulerParametersWrapper(virDomainPtr domain,
 395                                        virTypedParameterPtr params,
 396                                        int *nparams,
 397                                        virErrorPtr err);
 398
 399 int
 400 virDomainGetSchedulerParametersFlagsWrapper(virDomainPtr domain,
 401                                             virTypedParameterPtr params,
 402                                             int *nparams,
 403                                             unsigned int flags,
 404                                             virErrorPtr err);
 405
 406 char *
 407 virDomainGetSchedulerTypeWrapper(virDomainPtr domain,
 408                                  int *nparams,
 409                                  virErrorPtr err);
 410
 411 int
 412 virDomainGetSecurityLabelWrapper(virDomainPtr domain,
 413                                  virSecurityLabelPtr seclabel,
 414                                  virErrorPtr err);
 415
 416 int
 417 virDomainGetSecurityLabelListWrapper(virDomainPtr domain,
 418                                      virSecurityLabelPtr *seclabels,
 419                                      virErrorPtr err);
 420
 421 int
 422 virDomainGetStateWrapper(virDomainPtr domain,
 423                          int *state,
 424                          int *reason,
 425                          unsigned int flags,
 426                          virErrorPtr err);
 427
 428 int
 429 virDomainGetTimeWrapper(virDomainPtr dom,
 430                         long long *seconds,
 431                         unsigned int *nseconds,
 432                         unsigned int flags,
 433                         virErrorPtr err);
 434
 435 int
 436 virDomainGetUUIDWrapper(virDomainPtr domain,
 437                         unsigned char *uuid,
 438                         virErrorPtr err);
 439
 440 int
 441 virDomainGetUUIDStringWrapper(virDomainPtr domain,
 442                               char *buf,
 443                               virErrorPtr err);
 444
 445 int
 446 virDomainGetVcpuPinInfoWrapper(virDomainPtr domain,
 447                                int ncpumaps,
 448                                unsigned char *cpumaps,
 449                                int maplen,
 450                                unsigned int flags,
 451                                virErrorPtr err);
 452
 453 int
 454 virDomainGetVcpusWrapper(virDomainPtr domain,
 455                          virVcpuInfoPtr info,
 456                          int maxinfo,
 457                          unsigned char *cpumaps,
 458                          int maplen,
 459                          virErrorPtr err);
 460
 461 int
 462 virDomainGetVcpusFlagsWrapper(virDomainPtr domain,
 463                               unsigned int flags,
 464                               virErrorPtr err);
 465
 466 char *
 467 virDomainGetXMLDescWrapper(virDomainPtr domain,
 468                            unsigned int flags,
 469                            virErrorPtr err);
 470
 471 int
 472 virDomainHasCurrentSnapshotWrapper(virDomainPtr domain,
 473                                    unsigned int flags,
 474                                    virErrorPtr err);
 475
 476 int
 477 virDomainHasManagedSaveImageWrapper(virDomainPtr dom,
 478                                     unsigned int flags,
 479                                     virErrorPtr err);
 480
 481 int
 482 virDomainInjectNMIWrapper(virDomainPtr domain,
 483                           unsigned int flags,
 484                           virErrorPtr err);
 485
 486 int
 487 virDomainInterfaceAddressesWrapper(virDomainPtr dom,
 488                                    virDomainInterfacePtr **ifaces,
 489                                    unsigned int source,
 490                                    unsigned int flags,
 491                                    virErrorPtr err);
 492
 493 void
 494 virDomainInterfaceFreeWrapper(virDomainInterfacePtr iface);
 495
 496 int
 497 virDomainInterfaceStatsWrapper(virDomainPtr dom,
 498                                const char *device,
 499                                virDomainInterfaceStatsPtr stats,
 500                                size_t size,
 501                                virErrorPtr err);
 502
 503 void
 504 virDomainIOThreadInfoFreeWrapper(virDomainIOThreadInfoPtr info);
 505
 506 int
 507 virDomainIsActiveWrapper(virDomainPtr dom,
 508                          virErrorPtr err);
 509
 510 int
 511 virDomainIsPersistentWrapper(virDomainPtr dom,
 512                              virErrorPtr err);
 513
 514 int
 515 virDomainIsUpdatedWrapper(virDomainPtr dom,
 516                           virErrorPtr err);
 517
 518 int
 519 virDomainListAllSnapshotsWrapper(virDomainPtr domain,
 520                                  virDomainSnapshotPtr **snaps,
 521                                  unsigned int flags,
 522                                  virErrorPtr err);
 523
 524 int
 525 virDomainManagedSaveWrapper(virDomainPtr dom,
 526                             unsigned int flags,
 527                             virErrorPtr err);
 528
 529 int
 530 virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain,
 531                                      const char *dxml,
 532                                      unsigned int flags,
 533                                      virErrorPtr err);
 534
 535 char *
 536 virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain,
 537                                       unsigned int flags,
 538                                       virErrorPtr err);
 539
 540 int
 541 virDomainManagedSaveRemoveWrapper(virDomainPtr dom,
 542                                   unsigned int flags,
 543                                   virErrorPtr err);
 544
 545 int
 546 virDomainMemoryPeekWrapper(virDomainPtr dom,
 547                            unsigned long long start,
 548                            size_t size,
 549                            void *buffer,
 550                            unsigned int flags,
 551                            virErrorPtr err);
 552
 553 int
 554 virDomainMemoryStatsWrapper(virDomainPtr dom,
 555                             virDomainMemoryStatPtr stats,
 556                             unsigned int nr_stats,
 557                             unsigned int flags,
 558                             virErrorPtr err);
 559
 560 virDomainPtr
 561 virDomainMigrateWrapper(virDomainPtr domain,
 562                         virConnectPtr dconn,
 563                         unsigned long flags,
 564                         const char *dname,
 565                         const char *uri,
 566                         unsigned long bandwidth,
 567                         virErrorPtr err);
 568
 569 virDomainPtr
 570 virDomainMigrate2Wrapper(virDomainPtr domain,
 571                          virConnectPtr dconn,
 572                          const char *dxml,
 573                          unsigned long flags,
 574                          const char *dname,
 575                          const char *uri,
 576                          unsigned long bandwidth,
 577                          virErrorPtr err);
 578
 579 virDomainPtr
 580 virDomainMigrate3Wrapper(virDomainPtr domain,
 581                          virConnectPtr dconn,
 582                          virTypedParameterPtr params,
 583                          unsigned int nparams,
 584                          unsigned int flags,
 585                          virErrorPtr err);
 586
 587 int
 588 virDomainMigrateGetCompressionCacheWrapper(virDomainPtr domain,
 589                                            unsigned long long *cacheSize,
 590                                            unsigned int flags,
 591                                            virErrorPtr err);
 592
 593 int
 594 virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain,
 595                                       unsigned long long *downtime,
 596                                       unsigned int flags,
 597                                       virErrorPtr err);
 598
 599 int
 600 virDomainMigrateGetMaxSpeedWrapper(virDomainPtr domain,
 601                                    unsigned long *bandwidth,
 602                                    unsigned int flags,
 603                                    virErrorPtr err);
 604
 605 int
 606 virDomainMigrateSetCompressionCacheWrapper(virDomainPtr domain,
 607                                            unsigned long long cacheSize,
 608                                            unsigned int flags,
 609                                            virErrorPtr err);
 610
 611 int
 612 virDomainMigrateSetMaxDowntimeWrapper(virDomainPtr domain,
 613                                       unsigned long long downtime,
 614                                       unsigned int flags,
 615                                       virErrorPtr err);
 616
 617 int
 618 virDomainMigrateSetMaxSpeedWrapper(virDomainPtr domain,
 619                                    unsigned long bandwidth,
 620                                    unsigned int flags,
 621                                    virErrorPtr err);
 622
 623 int
 624 virDomainMigrateStartPostCopyWrapper(virDomainPtr domain,
 625                                      unsigned int flags,
 626                                      virErrorPtr err);
 627
 628 int
 629 virDomainMigrateToURIWrapper(virDomainPtr domain,
 630                              const char *duri,
 631                              unsigned long flags,
 632                              const char *dname,
 633                              unsigned long bandwidth,
 634                              virErrorPtr err);
 635
 636 int
 637 virDomainMigrateToURI2Wrapper(virDomainPtr domain,
 638                               const char *dconnuri,
 639                               const char *miguri,
 640                               const char *dxml,
 641                               unsigned long flags,
 642                               const char *dname,
 643                               unsigned long bandwidth,
 644                               virErrorPtr err);
 645
 646 int
 647 virDomainMigrateToURI3Wrapper(virDomainPtr domain,
 648                               const char *dconnuri,
 649                               virTypedParameterPtr params,
 650                               unsigned int nparams,
 651                               unsigned int flags,
 652                               virErrorPtr err);
 653
 654 int
 655 virDomainOpenChannelWrapper(virDomainPtr dom,
 656                             const char *name,
 657                             virStreamPtr st,
 658                             unsigned int flags,
 659                             virErrorPtr err);
 660
 661 int
 662 virDomainOpenConsoleWrapper(virDomainPtr dom,
 663                             const char *dev_name,
 664                             virStreamPtr st,
 665                             unsigned int flags,
 666                             virErrorPtr err);
 667
 668 int
 669 virDomainOpenGraphicsWrapper(virDomainPtr dom,
 670                              unsigned int idx,
 671                              int fd,
 672                              unsigned int flags,
 673                              virErrorPtr err);
 674
 675 int
 676 virDomainOpenGraphicsFDWrapper(virDomainPtr dom,
 677                                unsigned int idx,
 678                                unsigned int flags,
 679                                virErrorPtr err);
 680
 681 int
 682 virDomainPMSuspendForDurationWrapper(virDomainPtr dom,
 683                                      unsigned int target,
 684                                      unsigned long long duration,
 685                                      unsigned int flags,
 686                                      virErrorPtr err);
 687
 688 int
 689 virDomainPMWakeupWrapper(virDomainPtr dom,
 690                          unsigned int flags,
 691                          virErrorPtr err);
 692
 693 int
 694 virDomainPinEmulatorWrapper(virDomainPtr domain,
 695                             unsigned char *cpumap,
 696                             int maplen,
 697                             unsigned int flags,
 698                             virErrorPtr err);
 699
 700 int
 701 virDomainPinIOThreadWrapper(virDomainPtr domain,
 702                             unsigned int iothread_id,
 703                             unsigned char *cpumap,
 704                             int maplen,
 705                             unsigned int flags,
 706                             virErrorPtr err);
 707
 708 int
 709 virDomainPinVcpuWrapper(virDomainPtr domain,
 710                         unsigned int vcpu,
 711                         unsigned char *cpumap,
 712                         int maplen,
 713                         virErrorPtr err);
 714
 715 int
 716 virDomainPinVcpuFlagsWrapper(virDomainPtr domain,
 717                              unsigned int vcpu,
 718                              unsigned char *cpumap,
 719                              int maplen,
 720                              unsigned int flags,
 721                              virErrorPtr err);
 722
 723 int
 724 virDomainRebootWrapper(virDomainPtr domain,
 725                        unsigned int flags,
 726                        virErrorPtr err);
 727
 728 int
 729 virDomainRefWrapper(virDomainPtr domain,
 730                     virErrorPtr err);
 731
 732 int
 733 virDomainRenameWrapper(virDomainPtr dom,
 734                        const char *new_name,
 735                        unsigned int flags,
 736                        virErrorPtr err);
 737
 738 int
 739 virDomainResetWrapper(virDomainPtr domain,
 740                       unsigned int flags,
 741                       virErrorPtr err);
 742
 743 int
 744 virDomainResumeWrapper(virDomainPtr domain,
 745                        virErrorPtr err);
 746
 747 int
 748 virDomainSaveWrapper(virDomainPtr domain,
 749                      const char *to,
 750                      virErrorPtr err);
 751
 752 int
 753 virDomainSaveFlagsWrapper(virDomainPtr domain,
 754                           const char *to,
 755                           const char *dxml,
 756                           unsigned int flags,
 757                           virErrorPtr err);
 758
 759 char *
 760 virDomainScreenshotWrapper(virDomainPtr domain,
 761                            virStreamPtr stream,
 762                            unsigned int screen,
 763                            unsigned int flags,
 764                            virErrorPtr err);
 765
 766 int
 767 virDomainSendKeyWrapper(virDomainPtr domain,
 768                         unsigned int codeset,
 769                         unsigned int holdtime,
 770                         unsigned int *keycodes,
 771                         int nkeycodes,
 772                         unsigned int flags,
 773                         virErrorPtr err);
 774
 775 int
 776 virDomainSendProcessSignalWrapper(virDomainPtr domain,
 777                                   long long pid_value,
 778                                   unsigned int signum,
 779                                   unsigned int flags,
 780                                   virErrorPtr err);
 781
 782 int
 783 virDomainSetAutostartWrapper(virDomainPtr domain,
 784                              int autostart,
 785                              virErrorPtr err);
 786
 787 int
 788 virDomainSetBlkioParametersWrapper(virDomainPtr domain,
 789                                    virTypedParameterPtr params,
 790                                    int nparams,
 791                                    unsigned int flags,
 792                                    virErrorPtr err);
 793
 794 int
 795 virDomainSetBlockIoTuneWrapper(virDomainPtr dom,
 796                                const char *disk,
 797                                virTypedParameterPtr params,
 798                                int nparams,
 799                                unsigned int flags,
 800                                virErrorPtr err);
 801
 802 int
 803 virDomainSetBlockThresholdWrapper(virDomainPtr domain,
 804                                   const char *dev,
 805                                   unsigned long long threshold,
 806                                   unsigned int flags,
 807                                   virErrorPtr err);
 808
 809 int
 810 virDomainSetGuestVcpusWrapper(virDomainPtr domain,
 811                               const char *cpumap,
 812                               int state,
 813                               unsigned int flags,
 814                               virErrorPtr err);
 815
 816 int
 817 virDomainSetIOThreadParamsWrapper(virDomainPtr domain,
 818                                   unsigned int iothread_id,
 819                                   virTypedParameterPtr params,
 820                                   int nparams,
 821                                   unsigned int flags,
 822                                   virErrorPtr err);
 823
 824 int
 825 virDomainSetInterfaceParametersWrapper(virDomainPtr domain,
 826                                        const char *device,
 827                                        virTypedParameterPtr params,
 828                                        int nparams,
 829                                        unsigned int flags,
 830                                        virErrorPtr err);
 831
 832 int
 833 virDomainSetLifecycleActionWrapper(virDomainPtr domain,
 834                                    unsigned int type,
 835                                    unsigned int action,
 836                                    unsigned int flags,
 837                                    virErrorPtr err);
 838
 839 int
 840 virDomainSetMaxMemoryWrapper(virDomainPtr domain,
 841                              unsigned long memory,
 842                              virErrorPtr err);
 843
 844 int
 845 virDomainSetMemoryWrapper(virDomainPtr domain,
 846                           unsigned long memory,
 847                           virErrorPtr err);
 848
 849 int
 850 virDomainSetMemoryFlagsWrapper(virDomainPtr domain,
 851                                unsigned long memory,
 852                                unsigned int flags,
 853                                virErrorPtr err);
 854
 855 int
 856 virDomainSetMemoryParametersWrapper(virDomainPtr domain,
 857                                     virTypedParameterPtr params,
 858                                     int nparams,
 859                                     unsigned int flags,
 860                                     virErrorPtr err);
 861
 862 int
 863 virDomainSetMemoryStatsPeriodWrapper(virDomainPtr domain,
 864                                      int period,
 865                                      unsigned int flags,
 866                                      virErrorPtr err);
 867
 868 int
 869 virDomainSetMetadataWrapper(virDomainPtr domain,
 870                             int type,
 871                             const char *metadata,
 872                             const char *key,
 873                             const char *uri,
 874                             unsigned int flags,
 875                             virErrorPtr err);
 876
 877 int
 878 virDomainSetNumaParametersWrapper(virDomainPtr domain,
 879                                   virTypedParameterPtr params,
 880                                   int nparams,
 881                                   unsigned int flags,
 882                                   virErrorPtr err);
 883
 884 int
 885 virDomainSetPerfEventsWrapper(virDomainPtr domain,
 886                               virTypedParameterPtr params,
 887                               int nparams,
 888                               unsigned int flags,
 889                               virErrorPtr err);
 890
 891 int
 892 virDomainSetSchedulerParametersWrapper(virDomainPtr domain,
 893                                        virTypedParameterPtr params,
 894                                        int nparams,
 895                                        virErrorPtr err);
 896
 897 int
 898 virDomainSetSchedulerParametersFlagsWrapper(virDomainPtr domain,
 899                                             virTypedParameterPtr params,
 900                                             int nparams,
 901                                             unsigned int flags,
 902                                             virErrorPtr err);
 903
 904 int
 905 virDomainSetTimeWrapper(virDomainPtr dom,
 906                         long long seconds,
 907                         unsigned int nseconds,
 908                         unsigned int flags,
 909                         virErrorPtr err);
 910
 911 int
 912 virDomainSetUserPasswordWrapper(virDomainPtr dom,
 913                                 const char *user,
 914                                 const char *password,
 915                                 unsigned int flags,
 916                                 virErrorPtr err);
 917
 918 int
 919 virDomainSetVcpuWrapper(virDomainPtr domain,
 920                         const char *vcpumap,
 921                         int state,
 922                         unsigned int flags,
 923                         virErrorPtr err);
 924
 925 int
 926 virDomainSetVcpusWrapper(virDomainPtr domain,
 927                          unsigned int nvcpus,
 928                          virErrorPtr err);
 929
 930 int
 931 virDomainSetVcpusFlagsWrapper(virDomainPtr domain,
 932                               unsigned int nvcpus,
 933                               unsigned int flags,
 934                               virErrorPtr err);
 935
 936 int
 937 virDomainShutdownWrapper(virDomainPtr domain,
 938                          virErrorPtr err);
 939
 940 int
 941 virDomainShutdownFlagsWrapper(virDomainPtr domain,
 942                               unsigned int flags,
 943                               virErrorPtr err);
 944
 945 virDomainSnapshotPtr
 946 virDomainSnapshotCreateXMLWrapper(virDomainPtr domain,
 947                                   const char *xmlDesc,
 948                                   unsigned int flags,
 949                                   virErrorPtr err);
 950
 951 virDomainSnapshotPtr
 952 virDomainSnapshotCurrentWrapper(virDomainPtr domain,
 953                                 unsigned int flags,
 954                                 virErrorPtr err);
 955
 956 int
 957 virDomainSnapshotListNamesWrapper(virDomainPtr domain,
 958                                   char **names,
 959                                   int nameslen,
 960                                   unsigned int flags,
 961                                   virErrorPtr err);
 962
 963 virDomainSnapshotPtr
 964 virDomainSnapshotLookupByNameWrapper(virDomainPtr domain,
 965                                      const char *name,
 966                                      unsigned int flags,
 967                                      virErrorPtr err);
 968
 969 int
 970 virDomainSnapshotNumWrapper(virDomainPtr domain,
 971                             unsigned int flags,
 972                             virErrorPtr err);
 973
 974 int
 975 virDomainSuspendWrapper(virDomainPtr domain,
 976                         virErrorPtr err);
 977
 978 int
 979 virDomainUndefineWrapper(virDomainPtr domain,
 980                          virErrorPtr err);
 981
 982 int
 983 virDomainUndefineFlagsWrapper(virDomainPtr domain,
 984                               unsigned int flags,
 985                               virErrorPtr err);
 986
 987 int
 988 virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain,
 989                                   const char *xml,
 990                                   unsigned int flags,
 991                                   virErrorPtr err);
 992
 993
 994 #endif /* LIBVIRT_GO_DOMAIN_WRAPPER_H__ */