1 module libvirt.libvirt; 2 import core.stdc.config; 3 import core.stdc.stdarg: va_list; 4 struct struct___locale_data { int dummy; } 5 6 extern(C) { 7 alias __FILE = struct__IO_FILE; 8 alias FILE = struct__IO_FILE; 9 alias __mbstate_t = _Anonymous_1; 10 struct _Anonymous_1 11 { 12 int __count; 13 union _Anonymous_2 14 { 15 uint __wch; 16 char[4] __wchb; 17 } 18 _Anonymous_2 __value; 19 } 20 alias _G_fpos_t = _Anonymous_3; 21 struct _Anonymous_3 22 { 23 __off_t __pos; 24 __mbstate_t __state; 25 } 26 extern __gshared int sys_nerr; 27 28 29 30 31 extern __gshared const(const(char)*)[0] sys_errlist; 32 struct _Anonymous_4 33 { 34 __off64_t __pos; 35 __mbstate_t __state; 36 } 37 alias _G_fpos64_t = _Anonymous_4; 38 39 40 41 42 alias __u_char = ubyte; 43 44 45 alias __u_short = ushort; 46 alias __u_int = uint; 47 48 49 alias __u_long = c_ulong; 50 alias __int8_t = byte; 51 52 53 54 55 56 57 alias __uint8_t = ubyte; 58 alias __int16_t = short; 59 alias __uint16_t = ushort; 60 61 62 63 64 alias __int32_t = int; 65 66 67 alias __uint32_t = uint; 68 alias __int64_t = c_long; 69 70 71 72 73 alias __uint64_t = c_ulong; 74 alias __quad_t = c_long; 75 76 77 alias __u_quad_t = c_ulong; 78 alias off_t = __off_t; 79 alias __intmax_t = c_long; 80 81 82 83 84 alias __uintmax_t = c_ulong; 85 alias ssize_t = __ssize_t; 86 alias fpos_t = _G_fpos_t; 87 alias __dev_t = c_ulong; 88 89 90 alias __uid_t = uint; 91 92 93 alias __gid_t = uint; 94 extern __gshared struct__IO_FILE* stdin; 95 extern __gshared struct__IO_FILE* stdout; 96 97 98 alias __ino_t = c_ulong; 99 100 101 extern __gshared struct__IO_FILE* stderr; 102 alias __ino64_t = c_ulong; 103 104 105 alias __mode_t = uint; 106 107 108 alias __nlink_t = c_ulong; 109 110 111 112 113 alias __off_t = c_long; 114 115 116 117 118 119 120 alias __off64_t = c_long; 121 122 123 124 125 alias __pid_t = int; 126 127 128 alias __fsid_t = _Anonymous_5; 129 struct _Anonymous_5 130 { 131 int[2] __val; 132 } 133 alias __clock_t = c_long; 134 int remove(const(char)*, ); 135 alias __rlim_t = c_ulong; 136 struct struct__IO_jump_t; 137 int rename(const(char)*, const(char)*, ); 138 139 140 alias __rlim64_t = c_ulong; 141 alias __id_t = uint; 142 alias __time_t = c_long; 143 alias __useconds_t = uint; 144 int renameat(int, const(char)*, int, const(char)*, ); 145 alias _IO_lock_t = void; 146 alias __suseconds_t = c_long; 147 alias __daddr_t = int; 148 alias __key_t = int; 149 alias __clockid_t = int; 150 struct struct__IO_marker 151 { 152 struct__IO_marker* _next; 153 struct__IO_FILE* _sbuf; 154 int _pos; 155 } 156 157 158 159 FILE* tmpfile(); 160 alias __timer_t = void*; 161 alias __blksize_t = c_long; 162 alias __blkcnt_t = c_long; 163 164 165 166 alias __blkcnt64_t = c_long; 167 168 169 alias __fsblkcnt_t = c_ulong; 170 alias __fsblkcnt64_t = c_ulong; 171 char* tmpnam(char*, ); 172 173 174 alias __fsfilcnt_t = c_ulong; 175 alias __fsfilcnt64_t = c_ulong; 176 enum enum___codecvt_result 177 { 178 __codecvt_ok = 0, 179 __codecvt_partial = 1, 180 __codecvt_error = 2, 181 __codecvt_noconv = 3, 182 } 183 enum 184 { 185 __codecvt_ok = 0, 186 __codecvt_partial = 1, 187 __codecvt_error = 2, 188 __codecvt_noconv = 3, 189 } 190 191 192 193 char* tmpnam_r(char*, ); 194 alias __fsword_t = c_long; 195 196 197 198 alias __ssize_t = c_long; 199 200 201 202 203 alias __syscall_slong_t = c_long; 204 alias __syscall_ulong_t = c_ulong; 205 alias __loff_t = __off64_t; 206 char* tempnam(const(char)*, const(char)*, ); 207 alias __qaddr_t = __quad_t; 208 alias __caddr_t = char*; 209 alias __intptr_t = c_long*; 210 alias __socklen_t = uint; 211 int fclose(FILE*, ); 212 alias __sig_atomic_t = int; 213 int fflush(FILE*, ); 214 215 216 int fflush_unlocked(FILE*, ); 217 FILE* fopen(const(char)*, const(char)*, ); 218 219 220 FILE* freopen(const(char)*, const(char)*, FILE*, ); 221 222 223 224 225 struct struct__IO_FILE 226 { 227 int _flags; 228 char* _IO_read_ptr; 229 char* _IO_read_end; 230 char* _IO_read_base; 231 char* _IO_write_base; 232 char* _IO_write_ptr; 233 char* _IO_write_end; 234 char* _IO_buf_base; 235 char* _IO_buf_end; 236 char* _IO_save_base; 237 char* _IO_backup_base; 238 char* _IO_save_end; 239 struct__IO_marker* _markers; 240 struct__IO_FILE* _chain; 241 int _fileno; 242 int _flags2; 243 __off_t _old_offset; 244 ushort _cur_column; 245 byte _vtable_offset; 246 char[1] _shortbuf; 247 _IO_lock_t* _lock; 248 __off64_t _offset; 249 void* __pad1; 250 void* __pad2; 251 void* __pad3; 252 void* __pad4; 253 int __pad5; 254 int _mode; 255 char _unused2; 256 } 257 FILE* fdopen(int, const(char)*, ); 258 259 260 261 262 FILE* fmemopen(void*, int, const(char)*, ); 263 264 265 266 FILE* open_memstream(char**, int*, ); 267 268 269 void setbuf(FILE*, char*, ); 270 int setvbuf(FILE*, char*, int, int, ); 271 272 273 274 275 276 277 278 void setbuffer(FILE*, char*, int, ); 279 280 281 void setlinebuf(FILE*, ); 282 283 284 285 286 alias _IO_FILE = struct__IO_FILE; 287 288 289 int fprintf(FILE*, const(char)*, ...); 290 struct struct__IO_FILE_plus; 291 292 293 int printf(const(char)*, ...); 294 295 296 297 298 299 300 int sprintf(char*, const(char)*, ...); 301 302 303 304 305 306 307 int vfprintf(FILE*, const(char)*, int, ); 308 alias __io_read_fn = __ssize_t; 309 int vprintf(const(char)*, int, ); 310 int vsprintf(char*, const(char)*, int, ); 311 int snprintf(char*, int, const(char)*, ...); 312 alias __io_write_fn = __ssize_t; 313 314 315 316 317 318 int vsnprintf(char*, int, const(char)*, int, ); 319 320 321 int vdprintf(int, const(char)*, int, ); 322 323 324 int dprintf(int, const(char)*, ...); 325 326 327 int __underflow(_IO_FILE*, ); 328 329 330 int __uflow(_IO_FILE*, ); 331 int __overflow(_IO_FILE*, int, ); 332 333 334 335 336 337 338 int fscanf(FILE*, const(char)*, ...); 339 340 341 int scanf(const(char)*, ...); 342 343 344 345 346 int sscanf(const(char)*, const(char)*, ...); 347 int vfscanf(FILE*, const(char)*, int, ); 348 349 350 351 352 int vscanf(const(char)*, int, ); 353 int _IO_getc(_IO_FILE*, ); 354 int _IO_putc(int, _IO_FILE*, ); 355 int _IO_feof(_IO_FILE*, ); 356 int _IO_ferror(_IO_FILE*, ); 357 int vsscanf(const(char)*, const(char)*, int, ); 358 int _IO_peekc_locked(_IO_FILE*, ); 359 360 361 362 void _IO_flockfile(_IO_FILE*, ); 363 void _IO_funlockfile(_IO_FILE*, ); 364 int _IO_ftrylockfile(_IO_FILE*, ); 365 int _IO_vfscanf(_IO_FILE*, const(char)*, int, int*, ); 366 367 368 int _IO_vfprintf(_IO_FILE*, const(char)*, int, ); 369 370 371 372 __ssize_t _IO_padn(_IO_FILE*, int, __ssize_t, ); 373 int _IO_sgetn(); 374 __off64_t _IO_seekoff(_IO_FILE*, __off64_t, int, int, ); 375 __off64_t _IO_seekpos(_IO_FILE*, __off64_t, int, ); 376 void _IO_free_backup_area(_IO_FILE*, ); 377 int fgetc(FILE*, ); 378 int getc(FILE*, ); 379 380 381 int getchar(); 382 383 384 int getc_unlocked(FILE*, ); 385 int getchar_unlocked(); 386 int fgetc_unlocked(FILE*, ); 387 int fputc(int, FILE*, ); 388 int putc(int, FILE*, ); 389 int putchar(int, ); 390 391 392 int fputc_unlocked(int, FILE*, ); 393 int putc_unlocked(int, FILE*, ); 394 int putchar_unlocked(int, ); 395 int getw(FILE*, ); 396 int putw(int, FILE*, ); 397 char* fgets(char*, int, FILE*, ); 398 __ssize_t __getdelim(char**, int*, int, FILE*, ); 399 __ssize_t getdelim(char**, int*, int, FILE*, ); 400 __ssize_t getline(char**, int*, FILE*, ); 401 int fputs(const(char)*, FILE*, ); 402 int puts(const(char)*, ); 403 int ungetc(int, FILE*, ); 404 int fread(); 405 int fwrite(); 406 int fread_unlocked(); 407 int fwrite_unlocked(); 408 int fseek(FILE*, c_long, int, ); 409 c_long ftell(FILE*, ); 410 void rewind(FILE*, ); 411 int fseeko(FILE*, __off_t, int, ); 412 __off_t ftello(FILE*, ); 413 int fgetpos(FILE*, fpos_t*, ); 414 int fsetpos(FILE*, const(const fpos_t)*, ); 415 void clearerr(FILE*, ); 416 int feof(FILE*, ); 417 int ferror(FILE*, ); 418 void clearerr_unlocked(FILE*, ); 419 int feof_unlocked(FILE*, ); 420 int ferror_unlocked(FILE*, ); 421 void perror(const(char)*, ); 422 int fileno(FILE*, ); 423 int fileno_unlocked(FILE*, ); 424 FILE* popen(const(char)*, const(char)*, ); 425 int pclose(FILE*, ); 426 char* ctermid(char*, ); 427 void flockfile(FILE*, ); 428 int ftrylockfile(FILE*, ); 429 void funlockfile(FILE*, ); 430 431 } 432 433 extern(C) { 434 alias __sigset_t = _Anonymous_6; 435 struct _Anonymous_6 436 { 437 c_ulong[16] __val; 438 } 439 alias timer_t = __timer_t; 440 441 442 alias clock_t = __clock_t; 443 alias clockid_t = __clockid_t; 444 alias sigset_t = __sigset_t; 445 alias time_t = __time_t; 446 struct struct_timespec 447 { 448 __time_t tv_sec; 449 __syscall_slong_t tv_nsec; 450 } 451 struct struct_timeval 452 { 453 __time_t tv_sec; 454 __suseconds_t tv_usec; 455 } 456 alias int8_t = __int8_t; 457 alias int16_t = __int16_t; 458 alias int32_t = __int32_t; 459 460 461 alias pthread_t = c_ulong; 462 alias int64_t = __int64_t; 463 void* alloca(int, ); 464 alias pthread_mutexattr_t = _Anonymous_7; 465 union _Anonymous_7 466 { 467 char[4] __size; 468 int __align; 469 } 470 __uint16_t __uint16_identity(__uint16_t, ); 471 472 473 474 475 476 477 alias u_char = __u_char; 478 alias u_short = __u_short; 479 480 481 482 483 alias u_int = __u_int; 484 485 486 alias u_long = __u_long; 487 488 489 490 alias quad_t = __quad_t; 491 492 493 494 495 alias u_quad_t = __u_quad_t; 496 497 498 499 500 501 502 __uint32_t __uint32_identity(__uint32_t, ); 503 alias fsid_t = __fsid_t; 504 505 506 507 508 509 510 511 union _Anonymous_8 512 { 513 char[4] __size; 514 int __align; 515 } 516 alias pthread_condattr_t = _Anonymous_8; 517 518 519 520 521 alias suseconds_t = __suseconds_t; 522 523 524 alias loff_t = __loff_t; 525 526 527 __uint64_t __uint64_identity(__uint64_t, ); 528 alias ino_t = __ino_t; 529 alias __fd_mask = c_long; 530 alias pthread_key_t = uint; 531 alias pthread_once_t = int; 532 union union_pthread_attr_t 533 { 534 char[56] __size; 535 c_long __align; 536 } 537 538 539 struct _Anonymous_9 540 { 541 int quot; 542 int rem; 543 } 544 545 546 547 548 549 alias div_t = _Anonymous_9; 550 struct _Anonymous_10 551 { 552 __fd_mask[16] __fds_bits; 553 } 554 555 556 alias fd_set = _Anonymous_10; 557 558 559 560 alias dev_t = __dev_t; 561 562 563 564 565 566 567 568 alias pthread_attr_t = union_pthread_attr_t; 569 alias gid_t = __gid_t; 570 struct struct___pthread_rwlock_arch_t 571 { 572 uint __readers; 573 uint __writers; 574 uint __wrphase_futex; 575 uint __writers_futex; 576 uint __pad3; 577 uint __pad4; 578 int __cur_writer; 579 int __shared; 580 byte __rwelision; 581 ubyte[7] __pad1; 582 c_ulong __pad2; 583 uint __flags; 584 } 585 586 587 588 589 alias ldiv_t = _Anonymous_11; 590 struct _Anonymous_11 591 { 592 c_long quot; 593 c_long rem; 594 } 595 596 597 598 599 alias pthread_mutex_t = _Anonymous_12; 600 union _Anonymous_12 601 { 602 struct___pthread_mutex_s __data; 603 char[40] __size; 604 c_long __align; 605 } 606 alias mode_t = __mode_t; 607 uint gnu_dev_major(__dev_t, ); 608 609 610 uint gnu_dev_minor(__dev_t, ); 611 __dev_t gnu_dev_makedev(uint, uint, ); 612 613 614 union _Anonymous_13 615 { 616 struct___pthread_cond_s __data; 617 char[48] __size; 618 long __align; 619 } 620 alias pthread_cond_t = _Anonymous_13; 621 alias nlink_t = __nlink_t; 622 alias lldiv_t = _Anonymous_14; 623 struct _Anonymous_14 624 { 625 long quot; 626 long rem; 627 } 628 629 630 631 632 633 634 alias fd_mask = __fd_mask; 635 636 637 alias uid_t = __uid_t; 638 639 640 641 642 643 644 struct struct___pthread_internal_list 645 { 646 struct___pthread_internal_list* __prev; 647 struct___pthread_internal_list* __next; 648 } 649 alias __pthread_list_t = struct___pthread_internal_list; 650 651 652 alias pthread_rwlock_t = _Anonymous_15; 653 union _Anonymous_15 654 { 655 struct___pthread_rwlock_arch_t __data; 656 char[56] __size; 657 c_long __align; 658 } 659 alias pthread_rwlockattr_t = _Anonymous_16; 660 union _Anonymous_16 661 { 662 char[8] __size; 663 c_long __align; 664 } 665 666 667 int __ctype_get_mb_cur_max(); 668 alias pid_t = __pid_t; 669 670 671 672 673 double atof(const(char)*, ); 674 675 676 int select(int, fd_set*, fd_set*, fd_set*, struct_timeval*, ); 677 678 679 alias pthread_spinlock_t = int; 680 681 682 int atoi(const(char)*, ); 683 alias id_t = __id_t; 684 685 686 c_long atol(const(char)*, ); 687 union _Anonymous_17 688 { 689 char[32] __size; 690 c_long __align; 691 } 692 alias pthread_barrier_t = _Anonymous_17; 693 long atoll(const(char)*, ); 694 int pselect(int, fd_set*, fd_set*, fd_set*, const struct_timespec*, const(const __sigset_t)*, ); 695 alias pthread_barrierattr_t = _Anonymous_18; 696 union _Anonymous_18 697 { 698 char[4] __size; 699 int __align; 700 } 701 alias daddr_t = __daddr_t; 702 alias caddr_t = __caddr_t; 703 704 705 double strtod(const(char)*, char**, ); 706 struct struct___pthread_mutex_s 707 { 708 int __lock; 709 uint __count; 710 int __owner; 711 uint __nusers; 712 int __kind; 713 short __spins; 714 short __elision; 715 __pthread_list_t __list; 716 } 717 alias key_t = __key_t; 718 float strtof(const(char)*, char**, ); 719 720 721 real strtold(const(char)*, char**, ); 722 723 724 c_long strtol(const(char)*, char**, int, ); 725 struct _Anonymous_19 726 { 727 int[2] __val; 728 } 729 c_ulong strtoul(const(char)*, char**, int, ); 730 long strtoq(const(char)*, char**, int, ); 731 struct struct___pthread_cond_s 732 { 733 union _Anonymous_20 734 { 735 ulong __wseq; 736 struct _Anonymous_21 737 { 738 uint __low; 739 uint __high; 740 } 741 _Anonymous_21 __wseq32; 742 } 743 union _Anonymous_22 744 { 745 ulong __g1_start; 746 struct _Anonymous_23 747 { 748 uint __low; 749 uint __high; 750 } 751 _Anonymous_23 __g1_start32; 752 } 753 uint[2] __g_refs; 754 uint[2] __g_size; 755 uint __g1_orig_size; 756 uint __wrefs; 757 uint[2] __g_signals; 758 } 759 ulong strtouq(const(char)*, char**, int, ); 760 long strtoll(const(char)*, char**, int, ); 761 ulong strtoull(const(char)*, char**, int, ); 762 763 764 765 alias u_int8_t = ubyte; 766 alias u_int16_t = ushort; 767 alias u_int32_t = uint; 768 alias u_int64_t = c_ulong; 769 alias register_t = c_long; 770 771 772 773 774 alias blksize_t = __blksize_t; 775 776 777 alias blkcnt_t = __blkcnt_t; 778 779 780 alias fsblkcnt_t = __fsblkcnt_t; 781 782 783 alias fsfilcnt_t = __fsfilcnt_t; 784 785 786 char* l64a(c_long, ); 787 c_long a64l(const(char)*, ); 788 c_long random(); 789 void srandom(uint, ); 790 char* initstate(uint, char*, int, ); 791 char* setstate(char*, ); 792 struct struct_random_data 793 { 794 int32_t* fptr; 795 int32_t* rptr; 796 int32_t* state; 797 int rand_type; 798 int rand_deg; 799 int rand_sep; 800 int32_t* end_ptr; 801 } 802 int random_r(struct_random_data*, int32_t*, ); 803 int srandom_r(uint, struct_random_data*, ); 804 int initstate_r(uint, char*, int, struct_random_data*, ); 805 int setstate_r(char*, struct_random_data*, ); 806 int rand(); 807 void srand(uint, ); 808 int rand_r(uint*, ); 809 double drand48(); 810 double erand48(ushort*, ); 811 c_long lrand48(); 812 c_long nrand48(ushort*, ); 813 c_long mrand48(); 814 c_long jrand48(ushort*, ); 815 void srand48(c_long, ); 816 ushort* seed48(ushort*, ); 817 void lcong48(ushort*, ); 818 struct struct_drand48_data 819 { 820 ushort[3] __x; 821 ushort[3] __old_x; 822 ushort __c; 823 ushort __init; 824 ulong __a; 825 } 826 int drand48_r(struct_drand48_data*, double*, ); 827 int erand48_r(ushort*, struct_drand48_data*, double*, ); 828 int lrand48_r(struct_drand48_data*, c_long*, ); 829 int nrand48_r(ushort*, struct_drand48_data*, c_long*, ); 830 int mrand48_r(struct_drand48_data*, c_long*, ); 831 int jrand48_r(ushort*, struct_drand48_data*, c_long*, ); 832 int srand48_r(c_long, struct_drand48_data*, ); 833 int seed48_r(ushort*, struct_drand48_data*, ); 834 int lcong48_r(ushort*, struct_drand48_data*, ); 835 void* malloc(int, ); 836 void* calloc(int, int, ); 837 void* realloc(void*, int, ); 838 void free(void*, ); 839 void* valloc(int, ); 840 int posix_memalign(void**, int, int, ); 841 void* aligned_alloc(int, int, ); 842 void abort(); 843 int atexit(void function(), ); 844 int at_quick_exit(void function(), ); 845 int on_exit(void function(int, void*), void*, ); 846 void exit(int, ); 847 void quick_exit(int, ); 848 void _Exit(int, ); 849 char* getenv(const(char)*, ); 850 int putenv(char*, ); 851 int setenv(const(char)*, const(char)*, int, ); 852 int unsetenv(const(char)*, ); 853 int clearenv(); 854 char* mktemp(char*, ); 855 int mkstemp(char*, ); 856 int mkstemps(char*, int, ); 857 char* mkdtemp(char*, ); 858 int system(const(char)*, ); 859 char* realpath(const(char)*, char*, ); 860 861 862 alias __compar_fn_t = void*; // _Anonymous_24; 863 void* bsearch(const(void)*, const(void)*, int, int, __compar_fn_t, ); 864 void qsort(void*, int, int, __compar_fn_t, ); 865 int abs(int, ); 866 c_long labs(c_long, ); 867 long llabs(long, ); 868 div_t div(int, int, ); 869 ldiv_t ldiv(c_long, c_long, ); 870 lldiv_t lldiv(long, long, ); 871 char* ecvt(double, int, int*, int*, ); 872 char* fcvt(double, int, int*, int*, ); 873 char* gcvt(double, int, char*, ); 874 char* qecvt(real, int, int*, int*, ); 875 char* qfcvt(real, int, int*, int*, ); 876 char* qgcvt(real, int, char*, ); 877 int ecvt_r(double, int, int*, int*, char*, int, ); 878 int fcvt_r(double, int, int*, int*, char*, int, ); 879 int qecvt_r(real, int, int*, int*, char*, int, ); 880 int qfcvt_r(real, int, int*, int*, char*, int, ); 881 int mblen(const(char)*, int, ); 882 int mbtowc(int*, const(char)*, int, ); 883 int wctomb(char*, int, ); 884 int mbstowcs(); 885 int wcstombs(); 886 int rpmatch(const(char)*, ); 887 int getsubopt(char**, char**, char**, ); 888 int getloadavg(double*, int, ); 889 } 890 891 extern(C) { 892 struct _Anonymous_25 893 { 894 c_ulong[16] __val; 895 } 896 enum _Anonymous_26 897 { 898 VIR_NETWORK_XML_INACTIVE = 1, 899 } 900 enum 901 { 902 VIR_NETWORK_XML_INACTIVE = 1, 903 } 904 alias virNetworkXMLFlags = _Anonymous_26; 905 alias virStreamFlags = _Anonymous_27; 906 enum _Anonymous_27 907 { 908 VIR_STREAM_NONBLOCK = 1, 909 } 910 enum 911 { 912 VIR_STREAM_NONBLOCK = 1, 913 } 914 union _Anonymous_28 915 { 916 char[4] __size; 917 int __align; 918 } 919 920 921 struct struct__virNWFilter; 922 alias virNWFilter = struct__virNWFilter*; 923 virStreamPtr virStreamNew(virConnectPtr, uint, ); 924 alias virInterface = struct__virInterface*; 925 struct struct__virInterface; 926 struct struct__virStoragePool; 927 struct struct__virDomainSnapshot; 928 alias virStoragePool = struct__virStoragePool*; 929 alias virDomainSnapshot = struct__virDomainSnapshot*; 930 struct struct__virDomain; 931 alias virDomain = struct__virDomain*; 932 struct struct__virConnect; 933 struct struct__virNodeDevice; 934 alias virNodeDevice = struct__virNodeDevice*; 935 int virStreamRef(virStreamPtr, ); 936 alias virSecret = struct__virSecret*; 937 struct struct__virSecret; 938 alias virConnect = struct__virConnect*; 939 enum _Anonymous_29 940 { 941 VIR_EVENT_HANDLE_READABLE = 1, 942 VIR_EVENT_HANDLE_WRITABLE = 2, 943 VIR_EVENT_HANDLE_ERROR = 4, 944 VIR_EVENT_HANDLE_HANGUP = 8, 945 } 946 enum 947 { 948 VIR_EVENT_HANDLE_READABLE = 1, 949 VIR_EVENT_HANDLE_WRITABLE = 2, 950 VIR_EVENT_HANDLE_ERROR = 4, 951 VIR_EVENT_HANDLE_HANGUP = 8, 952 } 953 alias virEventHandleType = _Anonymous_29; 954 alias virSecretPtr = virSecret*; 955 alias virNetwork = struct__virNetwork*; 956 struct struct__virNetwork; 957 int virStreamSend(virStreamPtr, const(char)*, int, ); 958 enum _Anonymous_30 959 { 960 VIR_SECRET_USAGE_TYPE_NONE = 0, 961 VIR_SECRET_USAGE_TYPE_VOLUME = 1, 962 VIR_SECRET_USAGE_TYPE_CEPH = 2, 963 VIR_SECRET_USAGE_TYPE_ISCSI = 3, 964 VIR_SECRET_USAGE_TYPE_TLS = 4, 965 } 966 enum 967 { 968 VIR_SECRET_USAGE_TYPE_NONE = 0, 969 VIR_SECRET_USAGE_TYPE_VOLUME = 1, 970 VIR_SECRET_USAGE_TYPE_CEPH = 2, 971 VIR_SECRET_USAGE_TYPE_ISCSI = 3, 972 VIR_SECRET_USAGE_TYPE_TLS = 4, 973 } 974 alias virSecretUsageType = _Anonymous_30; 975 union _Anonymous_31 976 { 977 char[4] __size; 978 int __align; 979 } 980 981 982 alias virInterfacePtr = virInterface*; 983 int virStreamRecv(virStreamPtr, char*, int, ); 984 alias virNWFilterPtr = virNWFilter*; 985 alias virDomainPtr = virDomain*; 986 alias virDomainSnapshotPtr = virDomainSnapshot*; 987 alias virStoragePoolPtr = virStoragePool*; 988 virConnectPtr virInterfaceGetConnect(virInterfacePtr, ); 989 alias virConnectPtr = virConnect*; 990 const(char)* virDomainSnapshotGetName(virDomainSnapshotPtr, ); 991 int virConnectNumOfInterfaces(virConnectPtr, ); 992 enum _Anonymous_32 993 { 994 VIR_STREAM_RECV_STOP_AT_HOLE = 1, 995 } 996 enum 997 { 998 VIR_STREAM_RECV_STOP_AT_HOLE = 1, 999 } 1000 alias virNetworkPtr = virNetwork*; 1001 virDomainPtr virDomainSnapshotGetDomain(virDomainSnapshotPtr, ); 1002 alias virStreamRecvFlagsValues = _Anonymous_32; 1003 alias virStoragePoolState = _Anonymous_33; 1004 enum _Anonymous_33 1005 { 1006 VIR_STORAGE_POOL_INACTIVE = 0, 1007 VIR_STORAGE_POOL_BUILDING = 1, 1008 VIR_STORAGE_POOL_RUNNING = 2, 1009 VIR_STORAGE_POOL_DEGRADED = 3, 1010 VIR_STORAGE_POOL_INACCESSIBLE = 4, 1011 } 1012 enum 1013 { 1014 VIR_STORAGE_POOL_INACTIVE = 0, 1015 VIR_STORAGE_POOL_BUILDING = 1, 1016 VIR_STORAGE_POOL_RUNNING = 2, 1017 VIR_STORAGE_POOL_DEGRADED = 3, 1018 VIR_STORAGE_POOL_INACCESSIBLE = 4, 1019 } 1020 virConnectPtr virDomainSnapshotGetConnect(virDomainSnapshotPtr, ); 1021 int virConnectListInterfaces(virConnectPtr, char**, int, ); 1022 alias virNodeDevicePtr = virNodeDevice*; 1023 int virConnectNumOfNWFilters(virConnectPtr, ); 1024 alias virDomainSnapshotCreateFlags = _Anonymous_34; 1025 enum _Anonymous_34 1026 { 1027 VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = 1, 1028 VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = 2, 1029 VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = 4, 1030 VIR_DOMAIN_SNAPSHOT_CREATE_HALT = 8, 1031 VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = 16, 1032 VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = 32, 1033 VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = 64, 1034 VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = 128, 1035 VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = 256, 1036 } 1037 enum 1038 { 1039 VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = 1, 1040 VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = 2, 1041 VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = 4, 1042 VIR_DOMAIN_SNAPSHOT_CREATE_HALT = 8, 1043 VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = 16, 1044 VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = 32, 1045 VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = 64, 1046 VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = 128, 1047 VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = 256, 1048 } 1049 int virConnectListNWFilters(virConnectPtr, char**, int, ); 1050 enum _Anonymous_35 1051 { 1052 VIR_DOMAIN_NOSTATE = 0, 1053 VIR_DOMAIN_RUNNING = 1, 1054 VIR_DOMAIN_BLOCKED = 2, 1055 VIR_DOMAIN_PAUSED = 3, 1056 VIR_DOMAIN_SHUTDOWN = 4, 1057 VIR_DOMAIN_SHUTOFF = 5, 1058 VIR_DOMAIN_CRASHED = 6, 1059 VIR_DOMAIN_PMSUSPENDED = 7, 1060 } 1061 enum 1062 { 1063 VIR_DOMAIN_NOSTATE = 0, 1064 VIR_DOMAIN_RUNNING = 1, 1065 VIR_DOMAIN_BLOCKED = 2, 1066 VIR_DOMAIN_PAUSED = 3, 1067 VIR_DOMAIN_SHUTDOWN = 4, 1068 VIR_DOMAIN_SHUTOFF = 5, 1069 VIR_DOMAIN_CRASHED = 6, 1070 VIR_DOMAIN_PMSUSPENDED = 7, 1071 } 1072 alias virDomainState = _Anonymous_35; 1073 int virNodeNumOfDevices(virConnectPtr, const(char)*, uint, ); 1074 int virStreamRecvFlags(virStreamPtr, char*, int, uint, ); 1075 virConnectPtr virNetworkGetConnect(virNetworkPtr, ); 1076 int virConnectNumOfDefinedInterfaces(virConnectPtr, ); 1077 alias virNodeSuspendTarget = _Anonymous_36; 1078 int virConnectListDefinedInterfaces(virConnectPtr, char**, int, ); 1079 enum _Anonymous_36 1080 { 1081 VIR_NODE_SUSPEND_TARGET_MEM = 0, 1082 VIR_NODE_SUSPEND_TARGET_DISK = 1, 1083 VIR_NODE_SUSPEND_TARGET_HYBRID = 2, 1084 } 1085 enum 1086 { 1087 VIR_NODE_SUSPEND_TARGET_MEM = 0, 1088 VIR_NODE_SUSPEND_TARGET_DISK = 1, 1089 VIR_NODE_SUSPEND_TARGET_HYBRID = 2, 1090 } 1091 int virConnectListAllNWFilters(virConnectPtr, virNWFilterPtr**, uint, ); 1092 int virNodeListDevices(virConnectPtr, const(char)*, char**, int, uint, ); 1093 alias virEventHandleCallback = void function(int watch, int fd, int events, void *opaque); 1094 int virStreamSendHole(virStreamPtr, long, uint, ); 1095 virConnectPtr virSecretGetConnect(virSecretPtr, ); 1096 1097 1098 int virConnectNumOfNetworks(virConnectPtr, ); 1099 struct _Anonymous_37 1100 { 1101 __fd_mask[16] __fds_bits; 1102 } 1103 int virConnectNumOfSecrets(virConnectPtr, ); 1104 int virConnectListNetworks(virConnectPtr, char**, int, ); 1105 virNWFilterPtr virNWFilterLookupByName(virConnectPtr, const(char)*, ); 1106 int virConnectListSecrets(virConnectPtr, char**, int, ); 1107 alias virStoragePoolBuildFlags = _Anonymous_38; 1108 enum _Anonymous_38 1109 { 1110 VIR_STORAGE_POOL_BUILD_NEW = 0, 1111 VIR_STORAGE_POOL_BUILD_REPAIR = 1, 1112 VIR_STORAGE_POOL_BUILD_RESIZE = 2, 1113 VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = 4, 1114 VIR_STORAGE_POOL_BUILD_OVERWRITE = 8, 1115 } 1116 enum 1117 { 1118 VIR_STORAGE_POOL_BUILD_NEW = 0, 1119 VIR_STORAGE_POOL_BUILD_REPAIR = 1, 1120 VIR_STORAGE_POOL_BUILD_RESIZE = 2, 1121 VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = 4, 1122 VIR_STORAGE_POOL_BUILD_OVERWRITE = 8, 1123 } 1124 int virStreamRecvHole(virStreamPtr, long*, uint, ); 1125 alias virConnectListAllInterfacesFlags = _Anonymous_39; 1126 enum _Anonymous_39 1127 { 1128 VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1, 1129 VIR_CONNECT_LIST_INTERFACES_ACTIVE = 2, 1130 } 1131 enum 1132 { 1133 VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1, 1134 VIR_CONNECT_LIST_INTERFACES_ACTIVE = 2, 1135 } 1136 virNWFilterPtr virNWFilterLookupByUUID(virConnectPtr, const(ubyte)*, ); 1137 virNWFilterPtr virNWFilterLookupByUUIDString(virConnectPtr, const(char)*, ); 1138 int virConnectNumOfDefinedNetworks(virConnectPtr, ); 1139 int virConnectListAllInterfaces(virConnectPtr, virInterfacePtr**, uint, ); 1140 int virConnectListDefinedNetworks(virConnectPtr, char**, int, ); 1141 union _Anonymous_40 1142 { 1143 struct___pthread_mutex_s __data; 1144 char[40] __size; 1145 c_long __align; 1146 } 1147 enum _Anonymous_41 1148 { 1149 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1, 1150 VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 2, 1151 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 4, 1152 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 8, 1153 VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 16, 1154 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 32, 1155 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 64, 1156 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 128, 1157 VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 256, 1158 VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 512, 1159 VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1024, 1160 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 2048, 1161 VIR_CONNECT_LIST_NODE_DEVICES_CAP_DRM = 4096, 1162 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV_TYPES = 8192, 1163 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV = 16384, 1164 VIR_CONNECT_LIST_NODE_DEVICES_CAP_CCW_DEV = 32768, 1165 } 1166 enum 1167 { 1168 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1, 1169 VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 2, 1170 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 4, 1171 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 8, 1172 VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 16, 1173 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 32, 1174 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 64, 1175 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 128, 1176 VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 256, 1177 VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 512, 1178 VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1024, 1179 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 2048, 1180 VIR_CONNECT_LIST_NODE_DEVICES_CAP_DRM = 4096, 1181 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV_TYPES = 8192, 1182 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV = 16384, 1183 VIR_CONNECT_LIST_NODE_DEVICES_CAP_CCW_DEV = 32768, 1184 } 1185 alias virStoragePoolDeleteFlags = _Anonymous_42; 1186 enum _Anonymous_42 1187 { 1188 VIR_STORAGE_POOL_DELETE_NORMAL = 0, 1189 VIR_STORAGE_POOL_DELETE_ZEROED = 1, 1190 } 1191 enum 1192 { 1193 VIR_STORAGE_POOL_DELETE_NORMAL = 0, 1194 VIR_STORAGE_POOL_DELETE_ZEROED = 1, 1195 } 1196 alias virConnectListAllNodeDeviceFlags = _Anonymous_41; 1197 alias virStream = struct__virStream*; 1198 struct struct__virStream; 1199 virNWFilterPtr virNWFilterDefineXML(virConnectPtr, const(char)*, ); 1200 alias virConnectListAllSecretsFlags = _Anonymous_43; 1201 enum _Anonymous_43 1202 { 1203 VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1, 1204 VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 2, 1205 VIR_CONNECT_LIST_SECRETS_PRIVATE = 4, 1206 VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 8, 1207 } 1208 enum 1209 { 1210 VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1, 1211 VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 2, 1212 VIR_CONNECT_LIST_SECRETS_PRIVATE = 4, 1213 VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 8, 1214 } 1215 virInterfacePtr virInterfaceLookupByName(virConnectPtr, const(char)*, ); 1216 alias virStoragePoolCreateFlags = _Anonymous_44; 1217 enum _Anonymous_44 1218 { 1219 VIR_STORAGE_POOL_CREATE_NORMAL = 0, 1220 VIR_STORAGE_POOL_CREATE_WITH_BUILD = 1, 1221 VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE = 2, 1222 VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE = 4, 1223 } 1224 enum 1225 { 1226 VIR_STORAGE_POOL_CREATE_NORMAL = 0, 1227 VIR_STORAGE_POOL_CREATE_WITH_BUILD = 1, 1228 VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE = 2, 1229 VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE = 4, 1230 } 1231 enum _Anonymous_45 1232 { 1233 VIR_DOMAIN_NOSTATE_UNKNOWN = 0, 1234 } 1235 enum 1236 { 1237 VIR_DOMAIN_NOSTATE_UNKNOWN = 0, 1238 } 1239 alias virDomainNostateReason = _Anonymous_45; 1240 virInterfacePtr virInterfaceLookupByMACString(virConnectPtr, const(char)*, ); 1241 union _Anonymous_46 1242 { 1243 struct___pthread_cond_s __data; 1244 char[48] __size; 1245 long __align; 1246 } 1247 1248 1249 int virNWFilterUndefine(virNWFilterPtr, ); 1250 virDomainSnapshotPtr virDomainSnapshotCreateXML(virDomainPtr, const(char)*, uint, ); 1251 enum _Anonymous_47 1252 { 1253 VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1, 1254 VIR_CONNECT_LIST_NETWORKS_ACTIVE = 2, 1255 VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 4, 1256 VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 8, 1257 VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 16, 1258 VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 32, 1259 } 1260 enum 1261 { 1262 VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1, 1263 VIR_CONNECT_LIST_NETWORKS_ACTIVE = 2, 1264 VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 4, 1265 VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 8, 1266 VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 16, 1267 VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 32, 1268 } 1269 alias virConnectListAllNetworksFlags = _Anonymous_47; 1270 const(char)* virInterfaceGetName(virInterfacePtr, ); 1271 const(char)* virInterfaceGetMACString(virInterfacePtr, ); 1272 alias virStreamPtr = virStream*; 1273 alias virInterfaceXMLFlags = _Anonymous_48; 1274 enum _Anonymous_48 1275 { 1276 VIR_INTERFACE_XML_INACTIVE = 1, 1277 } 1278 enum 1279 { 1280 VIR_INTERFACE_XML_INACTIVE = 1, 1281 } 1282 alias virEventAddHandleFunc = int function(int fd, int event, virEventHandleCallback cb, void *opaque, virFreeCallback ff); 1283 int virNWFilterRef(virNWFilterPtr, ); 1284 enum _Anonymous_49 1285 { 1286 VIR_DOMAIN_RUNNING_UNKNOWN = 0, 1287 VIR_DOMAIN_RUNNING_BOOTED = 1, 1288 VIR_DOMAIN_RUNNING_MIGRATED = 2, 1289 VIR_DOMAIN_RUNNING_RESTORED = 3, 1290 VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4, 1291 VIR_DOMAIN_RUNNING_UNPAUSED = 5, 1292 VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6, 1293 VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7, 1294 VIR_DOMAIN_RUNNING_WAKEUP = 8, 1295 VIR_DOMAIN_RUNNING_CRASHED = 9, 1296 VIR_DOMAIN_RUNNING_POSTCOPY = 10, 1297 } 1298 enum 1299 { 1300 VIR_DOMAIN_RUNNING_UNKNOWN = 0, 1301 VIR_DOMAIN_RUNNING_BOOTED = 1, 1302 VIR_DOMAIN_RUNNING_MIGRATED = 2, 1303 VIR_DOMAIN_RUNNING_RESTORED = 3, 1304 VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4, 1305 VIR_DOMAIN_RUNNING_UNPAUSED = 5, 1306 VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6, 1307 VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7, 1308 VIR_DOMAIN_RUNNING_WAKEUP = 8, 1309 VIR_DOMAIN_RUNNING_CRASHED = 9, 1310 VIR_DOMAIN_RUNNING_POSTCOPY = 10, 1311 } 1312 int virConnectListAllSecrets(virConnectPtr, virSecretPtr**, uint, ); 1313 alias virDomainRunningReason = _Anonymous_49; 1314 char* virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr, uint, ); 1315 int virNWFilterFree(virNWFilterPtr, ); 1316 char* virInterfaceGetXMLDesc(virInterfacePtr, uint, ); 1317 virSecretPtr virSecretLookupByUUID(virConnectPtr, const(ubyte)*, ); 1318 1319 1320 virInterfacePtr virInterfaceDefineXML(virConnectPtr, const(char)*, uint, ); 1321 virSecretPtr virSecretLookupByUUIDString(virConnectPtr, const(char)*, ); 1322 union _Anonymous_50 1323 { 1324 struct___pthread_rwlock_arch_t __data; 1325 char[56] __size; 1326 c_long __align; 1327 } 1328 int virConnectListAllNetworks(virConnectPtr, virNetworkPtr**, uint, ); 1329 int virConnectListAllNodeDevices(virConnectPtr, virNodeDevicePtr**, uint, ); 1330 const(char)* virNWFilterGetName(virNWFilterPtr, ); 1331 virSecretPtr virSecretLookupByUsage(virConnectPtr, int, const(char)*, ); 1332 int virNWFilterGetUUID(virNWFilterPtr, ubyte*, ); 1333 int virInterfaceUndefine(virInterfacePtr, ); 1334 alias virStoragePoolInfo = struct__virStoragePoolInfo; 1335 int virNWFilterGetUUIDString(virNWFilterPtr, char*, ); 1336 int virInterfaceCreate(virInterfacePtr, uint, ); 1337 virSecretPtr virSecretDefineXML(virConnectPtr, const(char)*, uint, ); 1338 virNodeDevicePtr virNodeDeviceLookupByName(virConnectPtr, const(char)*, ); 1339 1340 1341 1342 char* virNWFilterGetXMLDesc(virNWFilterPtr, uint, ); 1343 struct struct__virStoragePoolInfo 1344 { 1345 int state; 1346 ulong capacity; 1347 ulong allocation; 1348 ulong available; 1349 } 1350 union _Anonymous_51 1351 { 1352 char[8] __size; 1353 c_long __align; 1354 } 1355 alias virStreamSourceFunc = int function(virStreamPtr st, 1356 char *data, 1357 size_t nbytes, 1358 void *opaque); 1359 alias virEventUpdateHandleFunc = void function(int watch, int event); 1360 int virSecretGetUUID(virSecretPtr, ubyte*, ); 1361 int virInterfaceDestroy(virInterfacePtr, uint, ); 1362 alias virSecurityLabel = struct__virSecurityLabel; 1363 virNodeDevicePtr virNodeDeviceLookupSCSIHostByWWN(virConnectPtr, const(char)*, const(char)*, uint, ); 1364 virNetworkPtr virNetworkLookupByName(virConnectPtr, const(char)*, ); 1365 enum _Anonymous_52 1366 { 1367 VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = 1, 1368 VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = 1, 1369 VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = 4, 1370 VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = 8, 1371 VIR_DOMAIN_SNAPSHOT_LIST_METADATA = 2, 1372 VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = 16, 1373 VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = 32, 1374 VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = 64, 1375 VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = 128, 1376 VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = 256, 1377 VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = 512, 1378 } 1379 enum 1380 { 1381 VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = 1, 1382 VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = 1, 1383 VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = 4, 1384 VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = 8, 1385 VIR_DOMAIN_SNAPSHOT_LIST_METADATA = 2, 1386 VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = 16, 1387 VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = 32, 1388 VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = 64, 1389 VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = 128, 1390 VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = 256, 1391 VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = 512, 1392 } 1393 alias virDomainSnapshotListFlags = _Anonymous_52; 1394 virNetworkPtr virNetworkLookupByUUID(virConnectPtr, const(ubyte)*, ); 1395 struct struct__virSecurityLabel 1396 { 1397 char[4097] label; 1398 int enforcing; 1399 } 1400 int virSecretGetUUIDString(virSecretPtr, char*, ); 1401 int virInterfaceRef(virInterfacePtr, ); 1402 virNetworkPtr virNetworkLookupByUUIDString(virConnectPtr, const(char)*, ); 1403 int virInterfaceFree(virInterfacePtr, ); 1404 int virSecretGetUsageType(virSecretPtr, ); 1405 int virStreamSendAll(virStreamPtr, virStreamSourceFunc, void*, ); 1406 const(char)* virNodeDeviceGetName(virNodeDevicePtr, ); 1407 const(char)* virSecretGetUsageID(virSecretPtr, ); 1408 alias virStoragePoolInfoPtr = virStoragePoolInfo*; 1409 char* virSecretGetXMLDesc(virSecretPtr, uint, ); 1410 alias virDomainBlockedReason = _Anonymous_53; 1411 enum _Anonymous_53 1412 { 1413 VIR_DOMAIN_BLOCKED_UNKNOWN = 0, 1414 } 1415 enum 1416 { 1417 VIR_DOMAIN_BLOCKED_UNKNOWN = 0, 1418 } 1419 int virInterfaceChangeBegin(virConnectPtr, uint, ); 1420 const(char)* virNodeDeviceGetParent(virNodeDevicePtr, ); 1421 int virInterfaceChangeCommit(virConnectPtr, uint, ); 1422 int virSecretSetValue(virSecretPtr, const(ubyte)*, int, uint, ); 1423 int virNodeDeviceNumOfCaps(virNodeDevicePtr, ); 1424 virNetworkPtr virNetworkCreateXML(virConnectPtr, const(char)*, ); 1425 int virInterfaceChangeRollback(virConnectPtr, uint, ); 1426 int virNodeDeviceListCaps(virNodeDevicePtr, char**, int, ); 1427 alias virSecurityLabelPtr = virSecurityLabel*; 1428 ubyte* virSecretGetValue(virSecretPtr, int*, uint, ); 1429 int virInterfaceIsActive(virInterfacePtr, ); 1430 struct struct__virStorageVol; 1431 alias virStorageVol = struct__virStorageVol*; 1432 alias virDomainPausedReason = _Anonymous_54; 1433 union _Anonymous_55 1434 { 1435 char[32] __size; 1436 c_long __align; 1437 } 1438 enum _Anonymous_54 1439 { 1440 VIR_DOMAIN_PAUSED_UNKNOWN = 0, 1441 VIR_DOMAIN_PAUSED_USER = 1, 1442 VIR_DOMAIN_PAUSED_MIGRATION = 2, 1443 VIR_DOMAIN_PAUSED_SAVE = 3, 1444 VIR_DOMAIN_PAUSED_DUMP = 4, 1445 VIR_DOMAIN_PAUSED_IOERROR = 5, 1446 VIR_DOMAIN_PAUSED_WATCHDOG = 6, 1447 VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7, 1448 VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8, 1449 VIR_DOMAIN_PAUSED_SNAPSHOT = 9, 1450 VIR_DOMAIN_PAUSED_CRASHED = 10, 1451 VIR_DOMAIN_PAUSED_STARTING_UP = 11, 1452 VIR_DOMAIN_PAUSED_POSTCOPY = 12, 1453 VIR_DOMAIN_PAUSED_POSTCOPY_FAILED = 13, 1454 } 1455 enum 1456 { 1457 VIR_DOMAIN_PAUSED_UNKNOWN = 0, 1458 VIR_DOMAIN_PAUSED_USER = 1, 1459 VIR_DOMAIN_PAUSED_MIGRATION = 2, 1460 VIR_DOMAIN_PAUSED_SAVE = 3, 1461 VIR_DOMAIN_PAUSED_DUMP = 4, 1462 VIR_DOMAIN_PAUSED_IOERROR = 5, 1463 VIR_DOMAIN_PAUSED_WATCHDOG = 6, 1464 VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7, 1465 VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8, 1466 VIR_DOMAIN_PAUSED_SNAPSHOT = 9, 1467 VIR_DOMAIN_PAUSED_CRASHED = 10, 1468 VIR_DOMAIN_PAUSED_STARTING_UP = 11, 1469 VIR_DOMAIN_PAUSED_POSTCOPY = 12, 1470 VIR_DOMAIN_PAUSED_POSTCOPY_FAILED = 13, 1471 } 1472 alias virEventRemoveHandleFunc = int function(int watch); 1473 alias virFreeCallback = void* function(void *opaque); 1474 int virSecretUndefine(virSecretPtr, ); 1475 char* virNodeDeviceGetXMLDesc(virNodeDevicePtr, uint, ); 1476 int virSecretRef(virSecretPtr, ); 1477 virNetworkPtr virNetworkDefineXML(virConnectPtr, const(char)*, ); 1478 int virSecretFree(virSecretPtr, ); 1479 alias virConnectCloseReason = _Anonymous_56; 1480 enum _Anonymous_56 1481 { 1482 VIR_CONNECT_CLOSE_REASON_ERROR = 0, 1483 VIR_CONNECT_CLOSE_REASON_EOF = 1, 1484 VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2, 1485 VIR_CONNECT_CLOSE_REASON_CLIENT = 3, 1486 } 1487 enum 1488 { 1489 VIR_CONNECT_CLOSE_REASON_ERROR = 0, 1490 VIR_CONNECT_CLOSE_REASON_EOF = 1, 1491 VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2, 1492 VIR_CONNECT_CLOSE_REASON_CLIENT = 3, 1493 } 1494 int virNodeDeviceRef(virNodeDevicePtr, ); 1495 1496 1497 int virNodeDeviceFree(virNodeDevicePtr, ); 1498 union _Anonymous_57 1499 { 1500 char[4] __size; 1501 int __align; 1502 } 1503 int virNodeDeviceDettach(virNodeDevicePtr, ); 1504 alias virStorageVolPtr = virStorageVol*; 1505 int virNodeDeviceDetachFlags(virNodeDevicePtr, const(char)*, uint, ); 1506 int virNetworkUndefine(virNetworkPtr, ); 1507 alias virEventTimeoutCallback = void function(int timer, void *opaque); 1508 alias virStorageVolType = _Anonymous_58; 1509 enum _Anonymous_58 1510 { 1511 VIR_STORAGE_VOL_FILE = 0, 1512 VIR_STORAGE_VOL_BLOCK = 1, 1513 VIR_STORAGE_VOL_DIR = 2, 1514 VIR_STORAGE_VOL_NETWORK = 3, 1515 VIR_STORAGE_VOL_NETDIR = 4, 1516 VIR_STORAGE_VOL_PLOOP = 5, 1517 } 1518 enum 1519 { 1520 VIR_STORAGE_VOL_FILE = 0, 1521 VIR_STORAGE_VOL_BLOCK = 1, 1522 VIR_STORAGE_VOL_DIR = 2, 1523 VIR_STORAGE_VOL_NETWORK = 3, 1524 VIR_STORAGE_VOL_NETDIR = 4, 1525 VIR_STORAGE_VOL_PLOOP = 5, 1526 } 1527 1528 1529 int virNodeDeviceReAttach(virNodeDevicePtr, ); 1530 1531 1532 int virNodeDeviceReset(virNodeDevicePtr, ); 1533 virNodeDevicePtr virNodeDeviceCreateXML(virConnectPtr, const(char)*, uint, ); 1534 enum _Anonymous_59 1535 { 1536 VIR_NETWORK_UPDATE_COMMAND_NONE = 0, 1537 VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1, 1538 VIR_NETWORK_UPDATE_COMMAND_DELETE = 2, 1539 VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3, 1540 VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4, 1541 } 1542 enum 1543 { 1544 VIR_NETWORK_UPDATE_COMMAND_NONE = 0, 1545 VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1, 1546 VIR_NETWORK_UPDATE_COMMAND_DELETE = 2, 1547 VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3, 1548 VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4, 1549 } 1550 alias virNetworkUpdateCommand = _Anonymous_59; 1551 int virNodeDeviceDestroy(virNodeDevicePtr, ); 1552 enum _Anonymous_60 1553 { 1554 VIR_TYPED_PARAM_INT = 1, 1555 VIR_TYPED_PARAM_UINT = 2, 1556 VIR_TYPED_PARAM_LLONG = 3, 1557 VIR_TYPED_PARAM_ULLONG = 4, 1558 VIR_TYPED_PARAM_DOUBLE = 5, 1559 VIR_TYPED_PARAM_BOOLEAN = 6, 1560 VIR_TYPED_PARAM_STRING = 7, 1561 } 1562 enum 1563 { 1564 VIR_TYPED_PARAM_INT = 1, 1565 VIR_TYPED_PARAM_UINT = 2, 1566 VIR_TYPED_PARAM_LLONG = 3, 1567 VIR_TYPED_PARAM_ULLONG = 4, 1568 VIR_TYPED_PARAM_DOUBLE = 5, 1569 VIR_TYPED_PARAM_BOOLEAN = 6, 1570 VIR_TYPED_PARAM_STRING = 7, 1571 } 1572 alias virTypedParameterType = _Anonymous_60; 1573 alias virSecretEventID = _Anonymous_61; 1574 enum _Anonymous_61 1575 { 1576 VIR_SECRET_EVENT_ID_LIFECYCLE = 0, 1577 VIR_SECRET_EVENT_ID_VALUE_CHANGED = 1, 1578 } 1579 enum 1580 { 1581 VIR_SECRET_EVENT_ID_LIFECYCLE = 0, 1582 VIR_SECRET_EVENT_ID_VALUE_CHANGED = 1, 1583 } 1584 enum _Anonymous_62 1585 { 1586 VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, 1587 VIR_DOMAIN_SHUTDOWN_USER = 1, 1588 } 1589 enum 1590 { 1591 VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, 1592 VIR_DOMAIN_SHUTDOWN_USER = 1, 1593 } 1594 alias virSecurityModel = struct__virSecurityModel; 1595 alias virDomainShutdownReason = _Anonymous_62; 1596 alias virStreamSourceHoleFunc = int function(virStreamPtr st, 1597 int *inData, 1598 long *length, 1599 void *opaque); 1600 struct struct__virSecurityModel 1601 { 1602 char[257] model; 1603 char[257] doi; 1604 } 1605 alias virStorageVolDeleteFlags = _Anonymous_63; 1606 enum _Anonymous_63 1607 { 1608 VIR_STORAGE_VOL_DELETE_NORMAL = 0, 1609 VIR_STORAGE_VOL_DELETE_ZEROED = 1, 1610 VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS = 2, 1611 } 1612 enum 1613 { 1614 VIR_STORAGE_VOL_DELETE_NORMAL = 0, 1615 VIR_STORAGE_VOL_DELETE_ZEROED = 1, 1616 VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS = 2, 1617 } 1618 1619 1620 int virDomainSnapshotNum(virDomainPtr, uint, ); 1621 alias virEventAddTimeoutFunc = int function(int timeout, 1622 virEventTimeoutCallback cb, 1623 void *opaque, 1624 virFreeCallback ff); 1625 alias virStorageVolWipeAlgorithm = _Anonymous_64; 1626 alias virDomainShutoffReason = _Anonymous_65; 1627 enum _Anonymous_65 1628 { 1629 VIR_DOMAIN_SHUTOFF_UNKNOWN = 0, 1630 VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1, 1631 VIR_DOMAIN_SHUTOFF_DESTROYED = 2, 1632 VIR_DOMAIN_SHUTOFF_CRASHED = 3, 1633 VIR_DOMAIN_SHUTOFF_MIGRATED = 4, 1634 VIR_DOMAIN_SHUTOFF_SAVED = 5, 1635 VIR_DOMAIN_SHUTOFF_FAILED = 6, 1636 VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7, 1637 } 1638 enum 1639 { 1640 VIR_DOMAIN_SHUTOFF_UNKNOWN = 0, 1641 VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1, 1642 VIR_DOMAIN_SHUTOFF_DESTROYED = 2, 1643 VIR_DOMAIN_SHUTOFF_CRASHED = 3, 1644 VIR_DOMAIN_SHUTOFF_MIGRATED = 4, 1645 VIR_DOMAIN_SHUTOFF_SAVED = 5, 1646 VIR_DOMAIN_SHUTOFF_FAILED = 6, 1647 VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7, 1648 } 1649 enum _Anonymous_64 1650 { 1651 VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0, 1652 VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1, 1653 VIR_STORAGE_VOL_WIPE_ALG_DOD = 2, 1654 VIR_STORAGE_VOL_WIPE_ALG_BSI = 3, 1655 VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4, 1656 VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5, 1657 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6, 1658 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7, 1659 VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8, 1660 VIR_STORAGE_VOL_WIPE_ALG_TRIM = 9, 1661 } 1662 enum 1663 { 1664 VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0, 1665 VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1, 1666 VIR_STORAGE_VOL_WIPE_ALG_DOD = 2, 1667 VIR_STORAGE_VOL_WIPE_ALG_BSI = 3, 1668 VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4, 1669 VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5, 1670 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6, 1671 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7, 1672 VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8, 1673 VIR_STORAGE_VOL_WIPE_ALG_TRIM = 9, 1674 } 1675 int virDomainSnapshotListNames(virDomainPtr, char**, int, uint, ); 1676 alias virSecurityModelPtr = virSecurityModel*; 1677 int virDomainListAllSnapshots(virDomainPtr, virDomainSnapshotPtr**, uint, ); 1678 enum _Anonymous_66 1679 { 1680 VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE = 0, 1681 VIR_NODE_DEVICE_EVENT_ID_UPDATE = 1, 1682 } 1683 enum 1684 { 1685 VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE = 0, 1686 VIR_NODE_DEVICE_EVENT_ID_UPDATE = 1, 1687 } 1688 alias virNetworkUpdateSection = _Anonymous_67; 1689 struct _Anonymous_68 1690 { 1691 int[2] __val; 1692 } 1693 alias virNodeDeviceEventID = _Anonymous_66; 1694 enum _Anonymous_67 1695 { 1696 VIR_NETWORK_SECTION_NONE = 0, 1697 VIR_NETWORK_SECTION_BRIDGE = 1, 1698 VIR_NETWORK_SECTION_DOMAIN = 2, 1699 VIR_NETWORK_SECTION_IP = 3, 1700 VIR_NETWORK_SECTION_IP_DHCP_HOST = 4, 1701 VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5, 1702 VIR_NETWORK_SECTION_FORWARD = 6, 1703 VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7, 1704 VIR_NETWORK_SECTION_FORWARD_PF = 8, 1705 VIR_NETWORK_SECTION_PORTGROUP = 9, 1706 VIR_NETWORK_SECTION_DNS_HOST = 10, 1707 VIR_NETWORK_SECTION_DNS_TXT = 11, 1708 VIR_NETWORK_SECTION_DNS_SRV = 12, 1709 } 1710 enum 1711 { 1712 VIR_NETWORK_SECTION_NONE = 0, 1713 VIR_NETWORK_SECTION_BRIDGE = 1, 1714 VIR_NETWORK_SECTION_DOMAIN = 2, 1715 VIR_NETWORK_SECTION_IP = 3, 1716 VIR_NETWORK_SECTION_IP_DHCP_HOST = 4, 1717 VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5, 1718 VIR_NETWORK_SECTION_FORWARD = 6, 1719 VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7, 1720 VIR_NETWORK_SECTION_FORWARD_PF = 8, 1721 VIR_NETWORK_SECTION_PORTGROUP = 9, 1722 VIR_NETWORK_SECTION_DNS_HOST = 10, 1723 VIR_NETWORK_SECTION_DNS_TXT = 11, 1724 VIR_NETWORK_SECTION_DNS_SRV = 12, 1725 } 1726 enum _Anonymous_69 1727 { 1728 VIR_TYPED_PARAM_STRING_OKAY = 4, 1729 } 1730 enum 1731 { 1732 VIR_TYPED_PARAM_STRING_OKAY = 4, 1733 } 1734 alias virTypedParameterFlags = _Anonymous_69; 1735 int virDomainSnapshotNumChildren(virDomainSnapshotPtr, uint, ); 1736 alias virEventUpdateTimeoutFunc = void* function(int timer, int timeout); 1737 int virDomainSnapshotListChildrenNames(virDomainSnapshotPtr, char**, int, uint, ); 1738 alias virDomainCrashedReason = _Anonymous_70; 1739 enum _Anonymous_70 1740 { 1741 VIR_DOMAIN_CRASHED_UNKNOWN = 0, 1742 VIR_DOMAIN_CRASHED_PANICKED = 1, 1743 } 1744 enum 1745 { 1746 VIR_DOMAIN_CRASHED_UNKNOWN = 0, 1747 VIR_DOMAIN_CRASHED_PANICKED = 1, 1748 } 1749 alias virNodeInfo = struct__virNodeInfo; 1750 alias virConnectSecretEventGenericCallback = void* function(virConnectPtr conn, virSecretPtr secret, void *opaque); 1751 struct struct__virNodeInfo 1752 { 1753 char[32] model; 1754 c_ulong memory; 1755 uint cpus; 1756 uint mhz; 1757 uint nodes; 1758 uint sockets; 1759 uint cores; 1760 uint threads; 1761 } 1762 alias virStreamSourceSkipFunc = int function(virStreamPtr st, 1763 long length, 1764 void *opaque); 1765 int virDomainSnapshotListAllChildren(virDomainSnapshotPtr, virDomainSnapshotPtr**, uint, ); 1766 int virConnectSecretEventRegisterAny(virConnectPtr conn, 1767 virSecretPtr secret, 1768 int eventID, 1769 virConnectSecretEventGenericCallback cb, 1770 void *opaque, 1771 virFreeCallback freecb); 1772 1773 int virConnectSecretEventDeregisterAny(virConnectPtr conn, 1774 int callbackID); 1775 1776 int virStreamSparseSendAll(virStreamPtr, virStreamSourceFunc, virStreamSourceHoleFunc, virStreamSourceSkipFunc, void*, ); 1777 virDomainSnapshotPtr virDomainSnapshotLookupByName(virDomainPtr, const(char)*, uint, ); 1778 alias virDomainPMSuspendedReason = _Anonymous_71; 1779 enum _Anonymous_71 1780 { 1781 VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, 1782 } 1783 enum 1784 { 1785 VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, 1786 } 1787 alias virEventRemoveTimeoutFunc = int function(int timer); 1788 void virEventRegisterImpl(virEventAddHandleFunc, virEventUpdateHandleFunc, virEventRemoveHandleFunc, virEventAddTimeoutFunc, virEventUpdateTimeoutFunc, virEventRemoveTimeoutFunc, ); 1789 int virConnectSecretEventDeregisterAny(virConnectPtr, int, ); 1790 enum _Anonymous_72 1791 { 1792 VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0, 1793 VIR_NETWORK_UPDATE_AFFECT_LIVE = 1, 1794 VIR_NETWORK_UPDATE_AFFECT_CONFIG = 2, 1795 } 1796 enum 1797 { 1798 VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0, 1799 VIR_NETWORK_UPDATE_AFFECT_LIVE = 1, 1800 VIR_NETWORK_UPDATE_AFFECT_CONFIG = 2, 1801 } 1802 alias virNetworkUpdateFlags = _Anonymous_72; 1803 int virDomainHasCurrentSnapshot(virDomainPtr, uint, ); 1804 alias virConnectNodeDeviceEventGenericCallback = void* function(virConnectPtr conn, 1805 virNodeDevicePtr dev, 1806 void *opaque); 1807 virDomainSnapshotPtr virDomainSnapshotCurrent(virDomainPtr, uint, ); 1808 alias virDomainPMSuspendedDiskReason = _Anonymous_73; 1809 alias virStorageVolInfoFlags = _Anonymous_74; 1810 enum _Anonymous_74 1811 { 1812 VIR_STORAGE_VOL_USE_ALLOCATION = 0, 1813 VIR_STORAGE_VOL_GET_PHYSICAL = 1, 1814 } 1815 enum 1816 { 1817 VIR_STORAGE_VOL_USE_ALLOCATION = 0, 1818 VIR_STORAGE_VOL_GET_PHYSICAL = 1, 1819 } 1820 enum _Anonymous_73 1821 { 1822 VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, 1823 } 1824 enum 1825 { 1826 VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, 1827 } 1828 1829 1830 int virEventRegisterDefaultImpl(); 1831 int virEventRunDefaultImpl(); 1832 virDomainSnapshotPtr virDomainSnapshotGetParent(virDomainSnapshotPtr, uint, ); 1833 int virConnectNodeDeviceEventRegisterAny(virConnectPtr, virNodeDevicePtr, int, virConnectNodeDeviceEventGenericCallback, void*, virFreeCallback, ); 1834 alias virSecretEventLifecycleType = _Anonymous_75; 1835 enum _Anonymous_75 1836 { 1837 VIR_SECRET_EVENT_DEFINED = 0, 1838 VIR_SECRET_EVENT_UNDEFINED = 1, 1839 } 1840 enum 1841 { 1842 VIR_SECRET_EVENT_DEFINED = 0, 1843 VIR_SECRET_EVENT_UNDEFINED = 1, 1844 } 1845 int virEventAddHandle(int, int, virEventHandleCallback, void*, virFreeCallback, ); 1846 int virNetworkUpdate(virNetworkPtr, uint, uint, int, const(char)*, uint, ); 1847 1848 1849 alias virStorageVolInfo = struct__virStorageVolInfo; 1850 int virDomainSnapshotIsCurrent(virDomainSnapshotPtr, uint, ); 1851 void virEventUpdateHandle(int, int, ); 1852 struct struct__virStorageVolInfo 1853 { 1854 int type; 1855 ulong capacity; 1856 ulong allocation; 1857 } 1858 int virEventRemoveHandle(int, ); 1859 int virConnectNodeDeviceEventDeregisterAny(virConnectPtr, int, ); 1860 alias virTypedParameter = struct__virTypedParameter*; 1861 int virEventAddTimeout(int, virEventTimeoutCallback, void*, virFreeCallback, ); 1862 alias virDomainControlState = _Anonymous_76; 1863 int virDomainSnapshotHasMetadata(virDomainSnapshotPtr, uint, ); 1864 enum _Anonymous_76 1865 { 1866 VIR_DOMAIN_CONTROL_OK = 0, 1867 VIR_DOMAIN_CONTROL_JOB = 1, 1868 VIR_DOMAIN_CONTROL_OCCUPIED = 2, 1869 VIR_DOMAIN_CONTROL_ERROR = 3, 1870 } 1871 enum 1872 { 1873 VIR_DOMAIN_CONTROL_OK = 0, 1874 VIR_DOMAIN_CONTROL_JOB = 1, 1875 VIR_DOMAIN_CONTROL_OCCUPIED = 2, 1876 VIR_DOMAIN_CONTROL_ERROR = 3, 1877 } 1878 enum _Anonymous_77 1879 { 1880 VIR_NODE_CPU_STATS_ALL_CPUS = -1, 1881 } 1882 enum 1883 { 1884 VIR_NODE_CPU_STATS_ALL_CPUS = -1, 1885 } 1886 alias virNodeGetCPUStatsAllCPUs = _Anonymous_77; 1887 struct struct__virTypedParameter 1888 { 1889 char[80] field; 1890 int type; 1891 union _Anonymous_78 1892 { 1893 int i; 1894 uint ui; 1895 long l; 1896 ulong ul; 1897 double d; 1898 char b; 1899 char* s; 1900 } 1901 _Anonymous_78 value; 1902 } 1903 enum _Anonymous_79 1904 { 1905 VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1, 1906 VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 2, 1907 VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 4, 1908 } 1909 enum 1910 { 1911 VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1, 1912 VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 2, 1913 VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 4, 1914 } 1915 void virEventUpdateTimeout(int, int, ); 1916 alias virDomainSnapshotRevertFlags = _Anonymous_79; 1917 alias virStorageVolInfoPtr = virStorageVolInfo*; 1918 int virEventRemoveTimeout(int, ); 1919 int virNetworkCreate(virNetworkPtr, ); 1920 enum _Anonymous_80 1921 { 1922 VIR_STORAGE_XML_INACTIVE = 1, 1923 } 1924 enum 1925 { 1926 VIR_STORAGE_XML_INACTIVE = 1, 1927 } 1928 alias virStorageXMLFlags = _Anonymous_80; 1929 enum _Anonymous_81 1930 { 1931 VIR_NODE_DEVICE_EVENT_CREATED = 0, 1932 VIR_NODE_DEVICE_EVENT_DELETED = 1, 1933 } 1934 enum 1935 { 1936 VIR_NODE_DEVICE_EVENT_CREATED = 0, 1937 VIR_NODE_DEVICE_EVENT_DELETED = 1, 1938 } 1939 alias virNodeDeviceEventLifecycleType = _Anonymous_81; 1940 int virNetworkDestroy(virNetworkPtr, ); 1941 int virNetworkRef(virNetworkPtr, ); 1942 alias virStreamSinkFunc = int function(virStreamPtr st, 1943 const char *data, 1944 size_t nbytes, 1945 void *opaque); 1946 1947 1948 1949 int virNetworkFree(virNetworkPtr, ); 1950 virConnectPtr virStoragePoolGetConnect(virStoragePoolPtr, ); 1951 int virDomainRevertToSnapshot(virDomainSnapshotPtr, uint, ); 1952 const(char)* virNetworkGetName(virNetworkPtr, ); 1953 alias virConnectSecretEventLifecycleCallback =void* function(virConnectPtr conn, 1954 virSecretPtr secret, 1955 int event, 1956 int detail, 1957 void *opaque); 1958 int virStreamRecvAll(virStreamPtr, virStreamSinkFunc, void*, ); 1959 alias virStreamSinkHoleFunc = int function(virStreamPtr st,long length, void *opaque); 1960 1961 alias virDomainSnapshotDeleteFlags = _Anonymous_82; 1962 enum _Anonymous_82 1963 { 1964 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = 1, 1965 VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = 2, 1966 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = 4, 1967 } 1968 enum 1969 { 1970 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = 1, 1971 VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = 2, 1972 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = 4, 1973 } 1974 int virNetworkGetUUID(virNetworkPtr, ubyte*, ); 1975 int virConnectNumOfStoragePools(virConnectPtr, ); 1976 int virConnectListStoragePools(virConnectPtr, char**, int, ); 1977 1978 1979 int virNetworkGetUUIDString(virNetworkPtr, char*, ); 1980 alias virTypedParameterPtr = virTypedParameter*; 1981 alias virDomainControlErrorReason = _Anonymous_83; 1982 enum _Anonymous_83 1983 { 1984 VIR_DOMAIN_CONTROL_ERROR_REASON_NONE = 0, 1985 VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN = 1, 1986 VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR = 2, 1987 VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL = 3, 1988 } 1989 enum 1990 { 1991 VIR_DOMAIN_CONTROL_ERROR_REASON_NONE = 0, 1992 VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN = 1, 1993 VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR = 2, 1994 VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL = 3, 1995 } 1996 char* virNetworkGetXMLDesc(virNetworkPtr, uint, ); 1997 virTypedParameterPtr virTypedParamsGet(virTypedParameterPtr, int, const(char)*, ); 1998 char* virNetworkGetBridgeName(virNetworkPtr, ); 1999 int virDomainSnapshotDelete(virDomainSnapshotPtr, uint, ); 2000 int virTypedParamsGetInt(virTypedParameterPtr, int, const(char)*, int*, ); 2001 int virConnectNumOfDefinedStoragePools(virConnectPtr, ); 2002 int virNetworkGetAutostart(virNetworkPtr, int*, ); 2003 int virConnectListDefinedStoragePools(virConnectPtr, char**, int, ); 2004 int virDomainSnapshotRef(virDomainSnapshotPtr, ); 2005 2006 2007 int virDomainSnapshotFree(virDomainSnapshotPtr, ); 2008 int virNetworkSetAutostart(virNetworkPtr, int, ); 2009 int virTypedParamsGetUInt(virTypedParameterPtr, int, const(char)*, uint*, ); 2010 int virNetworkIsActive(virNetworkPtr net); 2011 alias virConnectNodeDeviceEventLifecycleCallback = void* function(virConnectPtr conn, 2012 virNodeDevicePtr dev, 2013 int event, 2014 int detail, 2015 void *opaque); 2016 int virNetworkIsPersistent(virNetworkPtr net); 2017 int virTypedParamsGetLLong(virTypedParameterPtr, int, const(char)*, long*, ); 2018 2019 2020 int virTypedParamsGetULLong(virTypedParameterPtr, int, const(char)*, ulong*, ); 2021 enum _Anonymous_84 2022 { 2023 VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1, 2024 VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 2, 2025 VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 4, 2026 VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 8, 2027 VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 16, 2028 VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 32, 2029 VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 64, 2030 VIR_CONNECT_LIST_STORAGE_POOLS_FS = 128, 2031 VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 256, 2032 VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 512, 2033 VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1024, 2034 VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 2048, 2035 VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 4096, 2036 VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 8192, 2037 VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 16384, 2038 VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 32768, 2039 VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 65536, 2040 VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 131072, 2041 VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE = 262144, 2042 } 2043 enum 2044 { 2045 VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1, 2046 VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 2, 2047 VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 4, 2048 VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 8, 2049 VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 16, 2050 VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 32, 2051 VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 64, 2052 VIR_CONNECT_LIST_STORAGE_POOLS_FS = 128, 2053 VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 256, 2054 VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 512, 2055 VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1024, 2056 VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 2048, 2057 VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 4096, 2058 VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 8192, 2059 VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 16384, 2060 VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 32768, 2061 VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 65536, 2062 VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 131072, 2063 VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE = 262144, 2064 } 2065 alias virConnectListAllStoragePoolsFlags = _Anonymous_84; 2066 alias virNetworkEventLifecycleType = _Anonymous_85; 2067 enum _Anonymous_85 2068 { 2069 VIR_NETWORK_EVENT_DEFINED = 0, 2070 VIR_NETWORK_EVENT_UNDEFINED = 1, 2071 VIR_NETWORK_EVENT_STARTED = 2, 2072 VIR_NETWORK_EVENT_STOPPED = 3, 2073 } 2074 enum 2075 { 2076 VIR_NETWORK_EVENT_DEFINED = 0, 2077 VIR_NETWORK_EVENT_UNDEFINED = 1, 2078 VIR_NETWORK_EVENT_STARTED = 2, 2079 VIR_NETWORK_EVENT_STOPPED = 3, 2080 } 2081 int virTypedParamsGetDouble(virTypedParameterPtr, int, const(char)*, double*, ); 2082 alias virDomainControlInfo = struct__virDomainControlInfo; 2083 struct struct__virDomainControlInfo 2084 { 2085 uint state; 2086 uint details; 2087 ulong stateTime; 2088 } 2089 2090 2091 int virStreamSparseRecvAll(virStreamPtr, virStreamSinkFunc, virStreamSinkHoleFunc, void*, ); 2092 int virTypedParamsGetBoolean(virTypedParameterPtr, int, const(char)*, int*, ); 2093 int virTypedParamsGetString(virTypedParameterPtr, int, const(char)*, const(char)**, ); 2094 alias virStreamEventType = _Anonymous_86; 2095 enum _Anonymous_86 2096 { 2097 VIR_STREAM_EVENT_READABLE = 1, 2098 VIR_STREAM_EVENT_WRITABLE = 2, 2099 VIR_STREAM_EVENT_ERROR = 4, 2100 VIR_STREAM_EVENT_HANGUP = 8, 2101 } 2102 enum 2103 { 2104 VIR_STREAM_EVENT_READABLE = 1, 2105 VIR_STREAM_EVENT_WRITABLE = 2, 2106 VIR_STREAM_EVENT_ERROR = 4, 2107 VIR_STREAM_EVENT_HANGUP = 8, 2108 } 2109 2110 2111 int virTypedParamsAddInt(virTypedParameterPtr*, int*, int*, const(char)*, int, ); 2112 alias virDomainControlInfoPtr = virDomainControlInfo*; 2113 int virTypedParamsAddUInt(virTypedParameterPtr*, int*, int*, const(char)*, uint, ); 2114 alias virNodeCPUStats = struct__virNodeCPUStats; 2115 struct struct__virNodeCPUStats 2116 { 2117 char[80] field; 2118 ulong value; 2119 } 2120 int virConnectListAllStoragePools(virConnectPtr, virStoragePoolPtr**, uint, ); 2121 alias virConnectNetworkEventLifecycleCallback = void* function(virConnectPtr conn, 2122 virNetworkPtr net, 2123 int event, 2124 int detail, 2125 void *opaque); 2126 int virTypedParamsAddLLong(virTypedParameterPtr*, int*, int*, const(char)*, long, ); 2127 alias virStreamEventCallback = void function(virStreamPtr stream, int events, void *opaque); 2128 int virTypedParamsAddULLong(virTypedParameterPtr*, int*, int*, const(char)*, ulong, ); 2129 char* virConnectFindStoragePoolSources(virConnectPtr, const(char)*, const(char)*, uint, ); 2130 int virStreamEventAddCallback(virStreamPtr, int, virStreamEventCallback, void*, virFreeCallback, ); 2131 2132 2133 int virTypedParamsAddDouble(virTypedParameterPtr*, int*, int*, const(char)*, double, ); 2134 2135 2136 int virStreamEventUpdateCallback(virStreamPtr, int, ); 2137 enum _Anonymous_87 2138 { 2139 VIR_DOMAIN_AFFECT_CURRENT = 0, 2140 VIR_DOMAIN_AFFECT_LIVE = 1, 2141 VIR_DOMAIN_AFFECT_CONFIG = 2, 2142 } 2143 enum 2144 { 2145 VIR_DOMAIN_AFFECT_CURRENT = 0, 2146 VIR_DOMAIN_AFFECT_LIVE = 1, 2147 VIR_DOMAIN_AFFECT_CONFIG = 2, 2148 } 2149 alias virDomainModificationImpact = _Anonymous_87; 2150 virStoragePoolPtr virStoragePoolLookupByName(virConnectPtr, const(char)*, ); 2151 int virStreamEventRemoveCallback(virStreamPtr, ); 2152 virStoragePoolPtr virStoragePoolLookupByUUID(virConnectPtr, const(ubyte)*, ); 2153 enum _Anonymous_88 2154 { 2155 VIR_NODE_MEMORY_STATS_ALL_CELLS = -1, 2156 } 2157 enum 2158 { 2159 VIR_NODE_MEMORY_STATS_ALL_CELLS = -1, 2160 } 2161 int virTypedParamsAddBoolean(virTypedParameterPtr*, int*, int*, const(char)*, int, ); 2162 alias virNodeGetMemoryStatsAllCells = _Anonymous_88; 2163 virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr, const(char)*, ); 2164 int virStreamFinish(virStreamPtr, ); 2165 virStoragePoolPtr virStoragePoolLookupByVolume(virStorageVolPtr, ); 2166 int virStreamAbort(virStreamPtr, ); 2167 alias virNetworkEventID = _Anonymous_89; 2168 virStoragePoolPtr virStoragePoolLookupByTargetPath(virConnectPtr, const(char)*, ); 2169 enum _Anonymous_89 2170 { 2171 VIR_NETWORK_EVENT_ID_LIFECYCLE = 0, 2172 } 2173 enum 2174 { 2175 VIR_NETWORK_EVENT_ID_LIFECYCLE = 0, 2176 } 2177 int virTypedParamsAddString(virTypedParameterPtr*, int*, int*, const(char)*, const(char)*, ); 2178 int virStreamFree(virStreamPtr, ); 2179 2180 2181 int virTypedParamsAddStringList(virTypedParameterPtr*, int*, int*, const(char)*, const(char)**, ); 2182 alias virDomainInfo = struct__virDomainInfo*; 2183 virStoragePoolPtr virStoragePoolCreateXML(virConnectPtr, const(char)*, uint, ); 2184 struct struct__virDomainInfo 2185 { 2186 ubyte state; 2187 c_ulong maxMem; 2188 c_ulong memory; 2189 ushort nrVirtCpu; 2190 ulong cpuTime; 2191 } 2192 virStoragePoolPtr virStoragePoolDefineXML(virConnectPtr, const(char)*, uint, ); 2193 int virTypedParamsAddFromString(virTypedParameterPtr*, int*, int*, const(char)*, int, const(char)*, ); 2194 int virStoragePoolBuild(virStoragePoolPtr, uint, ); 2195 enum _Anonymous_90 2196 { 2197 VIR_IP_ADDR_TYPE_IPV4 = 0, 2198 VIR_IP_ADDR_TYPE_IPV6 = 1, 2199 } 2200 enum 2201 { 2202 VIR_IP_ADDR_TYPE_IPV4 = 0, 2203 VIR_IP_ADDR_TYPE_IPV6 = 1, 2204 } 2205 alias virIPAddrType = _Anonymous_90; 2206 2207 2208 int virStoragePoolUndefine(virStoragePoolPtr, ); 2209 int virStoragePoolCreate(virStoragePoolPtr, uint, ); 2210 void virTypedParamsClear(virTypedParameterPtr, int, ); 2211 int virStoragePoolDestroy(virStoragePoolPtr, ); 2212 int virStoragePoolDelete(virStoragePoolPtr, uint, ); 2213 void virTypedParamsFree(virTypedParameterPtr, int, ); 2214 int virStoragePoolRef(virStoragePoolPtr, ); 2215 int virStoragePoolFree(virStoragePoolPtr, ); 2216 2217 2218 alias virDomainInfoPtr = virDomainInfo*; 2219 int virStoragePoolRefresh(virStoragePoolPtr, uint, ); 2220 alias virNetworkDHCPLease = struct__virNetworkDHCPLease; 2221 alias virNetworkDHCPLeasePtr = virNetworkDHCPLease*; 2222 struct struct__virNetworkDHCPLease 2223 { 2224 char* iface; 2225 long expirytime; 2226 int type; 2227 char* mac; 2228 char* iaid; 2229 char* ipaddr; 2230 uint prefix; 2231 char* hostname; 2232 char* clientid; 2233 } 2234 const(char)* virStoragePoolGetName(virStoragePoolPtr, ); 2235 int virStoragePoolGetUUID(virStoragePoolPtr, ubyte*, ); 2236 alias virDomainCreateFlags = _Anonymous_91; 2237 enum _Anonymous_91 2238 { 2239 VIR_DOMAIN_NONE = 0, 2240 VIR_DOMAIN_START_PAUSED = 1, 2241 VIR_DOMAIN_START_AUTODESTROY = 2, 2242 VIR_DOMAIN_START_BYPASS_CACHE = 4, 2243 VIR_DOMAIN_START_FORCE_BOOT = 8, 2244 VIR_DOMAIN_START_VALIDATE = 16, 2245 } 2246 enum 2247 { 2248 VIR_DOMAIN_NONE = 0, 2249 VIR_DOMAIN_START_PAUSED = 1, 2250 VIR_DOMAIN_START_AUTODESTROY = 2, 2251 VIR_DOMAIN_START_BYPASS_CACHE = 4, 2252 VIR_DOMAIN_START_FORCE_BOOT = 8, 2253 VIR_DOMAIN_START_VALIDATE = 16, 2254 } 2255 2256 2257 int virStoragePoolGetUUIDString(virStoragePoolPtr, char*, ); 2258 int virStoragePoolGetInfo(virStoragePoolPtr, virStoragePoolInfoPtr, ); 2259 void virNetworkDHCPLeaseFree(virNetworkDHCPLeasePtr, ); 2260 char* virStoragePoolGetXMLDesc(virStoragePoolPtr, uint, ); 2261 alias virNodeMemoryStats = struct__virNodeMemoryStats; 2262 int virNetworkGetDHCPLeases(virNetworkPtr, const(char)*, virNetworkDHCPLeasePtr**, uint, ); 2263 int virStoragePoolGetAutostart(virStoragePoolPtr, int*, ); 2264 struct struct__virNodeMemoryStats 2265 { 2266 char[80] field; 2267 ulong value; 2268 } 2269 int virStoragePoolSetAutostart(virStoragePoolPtr, int, ); 2270 2271 2272 int virStoragePoolNumOfVolumes(virStoragePoolPtr, ); 2273 int virStoragePoolListVolumes(virStoragePoolPtr, char**, int, ); 2274 2275 2276 int virStoragePoolListAllVolumes(virStoragePoolPtr, virStorageVolPtr**, uint, ); 2277 alias virConnectNetworkEventGenericCallback = void* function(virConnectPtr conn, 2278 virNetworkPtr net, 2279 void *opaque); 2280 2281 2282 virConnectPtr virStorageVolGetConnect(virStorageVolPtr, ); 2283 2284 2285 int virConnectNetworkEventRegisterAny(virConnectPtr, virNetworkPtr, int, virConnectNetworkEventGenericCallback, void*, virFreeCallback, ); 2286 virStorageVolPtr virStorageVolLookupByName(virStoragePoolPtr, const(char)*, ); 2287 virStorageVolPtr virStorageVolLookupByKey(virConnectPtr, const(char)*, ); 2288 2289 2290 virStorageVolPtr virStorageVolLookupByPath(virConnectPtr, const(char)*, ); 2291 int virConnectNetworkEventDeregisterAny(virConnectPtr, int, ); 2292 2293 2294 const(char)* virStorageVolGetName(virStorageVolPtr, ); 2295 const(char)* virStorageVolGetKey(virStorageVolPtr, ); 2296 2297 2298 alias virStorageVolCreateFlags = _Anonymous_92; 2299 enum _Anonymous_92 2300 { 2301 VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1, 2302 VIR_STORAGE_VOL_CREATE_REFLINK = 2, 2303 } 2304 enum 2305 { 2306 VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1, 2307 VIR_STORAGE_VOL_CREATE_REFLINK = 2, 2308 } 2309 2310 2311 virStorageVolPtr virStorageVolCreateXML(virStoragePoolPtr, const(char)*, uint, ); 2312 virStorageVolPtr virStorageVolCreateXMLFrom(virStoragePoolPtr, const(char)*, virStorageVolPtr, uint, ); 2313 2314 2315 2316 2317 enum _Anonymous_93 2318 { 2319 VIR_STORAGE_VOL_DOWNLOAD_SPARSE_STREAM = 1, 2320 } 2321 enum 2322 { 2323 VIR_STORAGE_VOL_DOWNLOAD_SPARSE_STREAM = 1, 2324 } 2325 alias virStorageVolDownloadFlags = _Anonymous_93; 2326 int virStorageVolDownload(virStorageVolPtr, virStreamPtr, ulong, ulong, uint, ); 2327 2328 2329 2330 2331 enum _Anonymous_94 2332 { 2333 VIR_STORAGE_VOL_UPLOAD_SPARSE_STREAM = 1, 2334 } 2335 enum 2336 { 2337 VIR_STORAGE_VOL_UPLOAD_SPARSE_STREAM = 1, 2338 } 2339 alias virStorageVolUploadFlags = _Anonymous_94; 2340 int virStorageVolUpload(virStorageVolPtr, virStreamPtr, ulong, ulong, uint, ); 2341 2342 2343 2344 2345 int virStorageVolDelete(virStorageVolPtr, uint, ); 2346 int virStorageVolWipe(virStorageVolPtr, uint, ); 2347 2348 2349 int virStorageVolWipePattern(virStorageVolPtr, uint, uint, ); 2350 int virStorageVolRef(virStorageVolPtr, ); 2351 2352 2353 int virStorageVolFree(virStorageVolPtr, ); 2354 int virStorageVolGetInfo(virStorageVolPtr, virStorageVolInfoPtr, ); 2355 2356 2357 int virNodeGetMemoryParameters(virConnectPtr, virTypedParameterPtr, int*, uint, ); 2358 int virStorageVolGetInfoFlags(virStorageVolPtr, virStorageVolInfoPtr, uint, ); 2359 char* virStorageVolGetXMLDesc(virStorageVolPtr, uint, ); 2360 int virNodeSetMemoryParameters(virConnectPtr, virTypedParameterPtr, int, uint, ); 2361 char* virStorageVolGetPath(virStorageVolPtr, ); 2362 2363 2364 alias virStorageVolResizeFlags = _Anonymous_95; 2365 enum _Anonymous_95 2366 { 2367 VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1, 2368 VIR_STORAGE_VOL_RESIZE_DELTA = 2, 2369 VIR_STORAGE_VOL_RESIZE_SHRINK = 4, 2370 } 2371 enum 2372 { 2373 VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1, 2374 VIR_STORAGE_VOL_RESIZE_DELTA = 2, 2375 VIR_STORAGE_VOL_RESIZE_SHRINK = 4, 2376 } 2377 int virNodeGetCPUMap(virConnectPtr, ubyte**, uint*, uint, ); 2378 int virStorageVolResize(virStorageVolPtr, ulong, uint, ); 2379 2380 2381 int virStoragePoolIsActive(virStoragePoolPtr, ); 2382 int virStoragePoolIsPersistent(virStoragePoolPtr, ); 2383 alias virNodeInfoPtr = virNodeInfo*; 2384 enum _Anonymous_96 2385 { 2386 VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE = 0, 2387 VIR_STORAGE_POOL_EVENT_ID_REFRESH = 1, 2388 } 2389 enum 2390 { 2391 VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE = 0, 2392 VIR_STORAGE_POOL_EVENT_ID_REFRESH = 1, 2393 } 2394 alias virStoragePoolEventID = _Anonymous_96; 2395 2396 2397 alias virNodeCPUStatsPtr = virNodeCPUStats; 2398 int virDomainGetSchedulerParameters(virDomainPtr, virTypedParameterPtr, int*, ); 2399 int virDomainGetSchedulerParametersFlags(virDomainPtr, virTypedParameterPtr, int*, uint, ); 2400 alias virNodeMemoryStatsPtr = virNodeMemoryStats; 2401 int virDomainSetSchedulerParameters(virDomainPtr, virTypedParameterPtr, int, ); 2402 alias virConnectFlags = _Anonymous_97; 2403 enum _Anonymous_97 2404 { 2405 VIR_CONNECT_RO = 1, 2406 VIR_CONNECT_NO_ALIASES = 2, 2407 } 2408 enum 2409 { 2410 VIR_CONNECT_RO = 1, 2411 VIR_CONNECT_NO_ALIASES = 2, 2412 } 2413 int virDomainSetSchedulerParametersFlags(virDomainPtr, virTypedParameterPtr, int, uint, ); 2414 alias virConnectStoragePoolEventGenericCallback = void* function(virConnectPtr conn, 2415 virStoragePoolPtr pool, 2416 void *opaque); 2417 alias virConnectCredentialType = _Anonymous_98; 2418 enum _Anonymous_98 2419 { 2420 VIR_CRED_USERNAME = 1, 2421 VIR_CRED_AUTHNAME = 2, 2422 VIR_CRED_LANGUAGE = 3, 2423 VIR_CRED_CNONCE = 4, 2424 VIR_CRED_PASSPHRASE = 5, 2425 VIR_CRED_ECHOPROMPT = 6, 2426 VIR_CRED_NOECHOPROMPT = 7, 2427 VIR_CRED_REALM = 8, 2428 VIR_CRED_EXTERNAL = 9, 2429 } 2430 enum 2431 { 2432 VIR_CRED_USERNAME = 1, 2433 VIR_CRED_AUTHNAME = 2, 2434 VIR_CRED_LANGUAGE = 3, 2435 VIR_CRED_CNONCE = 4, 2436 VIR_CRED_PASSPHRASE = 5, 2437 VIR_CRED_ECHOPROMPT = 6, 2438 VIR_CRED_NOECHOPROMPT = 7, 2439 VIR_CRED_REALM = 8, 2440 VIR_CRED_EXTERNAL = 9, 2441 } 2442 int virConnectStoragePoolEventRegisterAny(virConnectPtr, virStoragePoolPtr, int, virConnectStoragePoolEventGenericCallback, void*, virFreeCallback, ); 2443 alias virDomainBlockStatsStruct = struct__virDomainBlockStats; 2444 int virConnectStoragePoolEventDeregisterAny(virConnectPtr, int, ); 2445 struct struct__virDomainBlockStats 2446 { 2447 long rd_req; 2448 long rd_bytes; 2449 long wr_req; 2450 long wr_bytes; 2451 long errs; 2452 } 2453 struct struct__virConnectCredential 2454 { 2455 int type; 2456 const(char)* prompt; 2457 const(char)* challenge; 2458 const(char)* defresult; 2459 char* result; 2460 uint resultlen; 2461 } 2462 enum _Anonymous_99 2463 { 2464 VIR_STORAGE_POOL_EVENT_DEFINED = 0, 2465 VIR_STORAGE_POOL_EVENT_UNDEFINED = 1, 2466 VIR_STORAGE_POOL_EVENT_STARTED = 2, 2467 VIR_STORAGE_POOL_EVENT_STOPPED = 3, 2468 VIR_STORAGE_POOL_EVENT_CREATED = 4, 2469 VIR_STORAGE_POOL_EVENT_DELETED = 5, 2470 } 2471 enum 2472 { 2473 VIR_STORAGE_POOL_EVENT_DEFINED = 0, 2474 VIR_STORAGE_POOL_EVENT_UNDEFINED = 1, 2475 VIR_STORAGE_POOL_EVENT_STARTED = 2, 2476 VIR_STORAGE_POOL_EVENT_STOPPED = 3, 2477 VIR_STORAGE_POOL_EVENT_CREATED = 4, 2478 VIR_STORAGE_POOL_EVENT_DELETED = 5, 2479 } 2480 alias virStoragePoolEventLifecycleType = _Anonymous_99; 2481 alias virDomainBlockStatsPtr = virDomainBlockStatsStruct*; 2482 alias virConnectCredential = struct__virConnectCredential; 2483 alias virConnectCredentialPtr = virConnectCredential*; 2484 2485 2486 2487 2488 alias virConnectAuthCallbackPtr = int function(virConnectCredentialPtr cred, 2489 uint ncred, 2490 void *cbdata); 2491 struct struct__virConnectAuth 2492 { 2493 int* credtype; 2494 uint ncredtype; 2495 virConnectAuthCallbackPtr cb; 2496 void* cbdata; 2497 } 2498 alias virConnectStoragePoolEventLifecycleCallback = void* function(virConnectPtr conn, 2499 virStoragePoolPtr pool, 2500 int event, 2501 int detail, 2502 void *opaque); 2503 2504 2505 alias virConnectAuth = struct__virConnectAuth; 2506 alias virConnectAuthPtr = virConnectAuth*; 2507 2508 2509 extern __gshared virConnectAuthPtr virConnectAuthPtrDefault; 2510 int virGetVersion(c_ulong*, const(char)*, c_ulong*, ); 2511 2512 2513 int virInitialize(); 2514 virConnectPtr virConnectOpen(const(char)*, ); 2515 virConnectPtr virConnectOpenReadOnly(const(char)*, ); 2516 2517 2518 virConnectPtr virConnectOpenAuth(const(char)*, virConnectAuthPtr, uint, ); 2519 int virConnectRef(virConnectPtr, ); 2520 int virConnectClose(virConnectPtr, ); 2521 const(char)* virConnectGetType(virConnectPtr, ); 2522 int virConnectGetVersion(virConnectPtr, c_ulong*, ); 2523 2524 2525 int virConnectGetLibVersion(virConnectPtr, c_ulong*, ); 2526 char* virConnectGetHostname(virConnectPtr, ); 2527 char* virConnectGetURI(virConnectPtr, ); 2528 char* virConnectGetSysinfo(virConnectPtr, uint, ); 2529 2530 2531 int virConnectSetKeepAlive(virConnectPtr, int, uint, ); 2532 alias virDomainInterfaceStatsStruct = struct__virDomainInterfaceStats; 2533 alias virConnectCloseFunc = void* function(virConnectPtr conn, 2534 int reason, 2535 void *opaque); 2536 struct struct__virDomainInterfaceStats 2537 { 2538 long rx_bytes; 2539 long rx_packets; 2540 long rx_errs; 2541 long rx_drop; 2542 long tx_bytes; 2543 long tx_packets; 2544 long tx_errs; 2545 long tx_drop; 2546 } 2547 int virConnectRegisterCloseCallback(virConnectPtr, virConnectCloseFunc, void*, virFreeCallback, ); 2548 int virConnectUnregisterCloseCallback(virConnectPtr, virConnectCloseFunc, ); 2549 int virConnectGetMaxVcpus(virConnectPtr, const(char)*, ); 2550 alias virDomainInterfaceStatsPtr = virDomainInterfaceStatsStruct*; 2551 int virNodeGetInfo(virConnectPtr, virNodeInfoPtr, ); 2552 char* virConnectGetCapabilities(virConnectPtr, ); 2553 int virNodeGetCPUStats(virConnectPtr, int, virNodeCPUStatsPtr, int*, uint, ); 2554 alias virDomainMemoryStatTags = _Anonymous_100; 2555 enum _Anonymous_100 2556 { 2557 VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0, 2558 VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1, 2559 VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2, 2560 VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3, 2561 VIR_DOMAIN_MEMORY_STAT_UNUSED = 4, 2562 VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5, 2563 VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6, 2564 VIR_DOMAIN_MEMORY_STAT_RSS = 7, 2565 VIR_DOMAIN_MEMORY_STAT_USABLE = 8, 2566 VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE = 9, 2567 VIR_DOMAIN_MEMORY_STAT_NR = 10, 2568 } 2569 enum 2570 { 2571 VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0, 2572 VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1, 2573 VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2, 2574 VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3, 2575 VIR_DOMAIN_MEMORY_STAT_UNUSED = 4, 2576 VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5, 2577 VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6, 2578 VIR_DOMAIN_MEMORY_STAT_RSS = 7, 2579 VIR_DOMAIN_MEMORY_STAT_USABLE = 8, 2580 VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE = 9, 2581 VIR_DOMAIN_MEMORY_STAT_NR = 10, 2582 } 2583 int virNodeGetMemoryStats(virConnectPtr, int, virNodeMemoryStatsPtr, int*, uint, ); 2584 ulong virNodeGetFreeMemory(virConnectPtr, ); 2585 int virNodeGetSecurityModel(virConnectPtr, virSecurityModelPtr, ); 2586 int virNodeSuspendForDuration(virConnectPtr, uint, ulong, uint, ); 2587 int virNodeGetCellsFreeMemory(virConnectPtr, ulong*, int, int, ); 2588 int virConnectIsEncrypted(virConnectPtr, ); 2589 int virConnectIsSecure(virConnectPtr, ); 2590 int virConnectIsAlive(virConnectPtr, ); 2591 alias virCPUCompareResult = _Anonymous_101; 2592 enum _Anonymous_101 2593 { 2594 VIR_CPU_COMPARE_ERROR = -1, 2595 VIR_CPU_COMPARE_INCOMPATIBLE = 0, 2596 VIR_CPU_COMPARE_IDENTICAL = 1, 2597 VIR_CPU_COMPARE_SUPERSET = 2, 2598 } 2599 enum 2600 { 2601 VIR_CPU_COMPARE_ERROR = -1, 2602 VIR_CPU_COMPARE_INCOMPATIBLE = 0, 2603 VIR_CPU_COMPARE_IDENTICAL = 1, 2604 VIR_CPU_COMPARE_SUPERSET = 2, 2605 } 2606 alias virConnectCompareCPUFlags = _Anonymous_102; 2607 enum _Anonymous_102 2608 { 2609 VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = 1, 2610 } 2611 enum 2612 { 2613 VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = 1, 2614 } 2615 int virConnectCompareCPU(virConnectPtr, const(char)*, uint, ); 2616 alias virDomainMemoryStatStruct = struct__virDomainMemoryStat; 2617 struct struct__virDomainMemoryStat 2618 { 2619 int tag; 2620 ulong val; 2621 } 2622 int virConnectGetCPUModelNames(virConnectPtr, const(char)*, char***, uint, ); 2623 alias virDomainMemoryStatPtr = virDomainMemoryStatStruct*; 2624 alias virDomainCoreDumpFlags = _Anonymous_103; 2625 enum _Anonymous_103 2626 { 2627 VIR_DUMP_CRASH = 1, 2628 VIR_DUMP_LIVE = 2, 2629 VIR_DUMP_BYPASS_CACHE = 4, 2630 VIR_DUMP_RESET = 8, 2631 VIR_DUMP_MEMORY_ONLY = 16, 2632 } 2633 enum 2634 { 2635 VIR_DUMP_CRASH = 1, 2636 VIR_DUMP_LIVE = 2, 2637 VIR_DUMP_BYPASS_CACHE = 4, 2638 VIR_DUMP_RESET = 8, 2639 VIR_DUMP_MEMORY_ONLY = 16, 2640 } 2641 alias virConnectBaselineCPUFlags = _Anonymous_104; 2642 enum _Anonymous_104 2643 { 2644 VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = 1, 2645 VIR_CONNECT_BASELINE_CPU_MIGRATABLE = 2, 2646 } 2647 enum 2648 { 2649 VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = 1, 2650 VIR_CONNECT_BASELINE_CPU_MIGRATABLE = 2, 2651 } 2652 char* virConnectBaselineCPU(virConnectPtr, const(char)**, uint, uint, ); 2653 int virNodeGetFreePages(virConnectPtr, uint, uint*, int, uint, ulong*, uint, ); 2654 alias virDomainCoreDumpFormat = _Anonymous_105; 2655 enum _Anonymous_105 2656 { 2657 VIR_DOMAIN_CORE_DUMP_FORMAT_RAW = 0, 2658 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB = 1, 2659 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO = 2, 2660 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY = 3, 2661 } 2662 enum 2663 { 2664 VIR_DOMAIN_CORE_DUMP_FORMAT_RAW = 0, 2665 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB = 1, 2666 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO = 2, 2667 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY = 3, 2668 } 2669 enum _Anonymous_106 2670 { 2671 VIR_NODE_ALLOC_PAGES_ADD = 0, 2672 VIR_NODE_ALLOC_PAGES_SET = 1, 2673 } 2674 enum 2675 { 2676 VIR_NODE_ALLOC_PAGES_ADD = 0, 2677 VIR_NODE_ALLOC_PAGES_SET = 1, 2678 } 2679 alias virNodeAllocPagesFlags = _Anonymous_106; 2680 int virNodeAllocPages(virConnectPtr, uint, uint*, ulong*, int, uint, uint, ); 2681 enum _Anonymous_107 2682 { 2683 VIR_MIGRATE_LIVE = 1, 2684 VIR_MIGRATE_PEER2PEER = 2, 2685 VIR_MIGRATE_TUNNELLED = 4, 2686 VIR_MIGRATE_PERSIST_DEST = 8, 2687 VIR_MIGRATE_UNDEFINE_SOURCE = 16, 2688 VIR_MIGRATE_PAUSED = 32, 2689 VIR_MIGRATE_NON_SHARED_DISK = 64, 2690 VIR_MIGRATE_NON_SHARED_INC = 128, 2691 VIR_MIGRATE_CHANGE_PROTECTION = 256, 2692 VIR_MIGRATE_UNSAFE = 512, 2693 VIR_MIGRATE_OFFLINE = 1024, 2694 VIR_MIGRATE_COMPRESSED = 2048, 2695 VIR_MIGRATE_ABORT_ON_ERROR = 4096, 2696 VIR_MIGRATE_AUTO_CONVERGE = 8192, 2697 VIR_MIGRATE_RDMA_PIN_ALL = 16384, 2698 VIR_MIGRATE_POSTCOPY = 32768, 2699 VIR_MIGRATE_TLS = 65536, 2700 } 2701 enum 2702 { 2703 VIR_MIGRATE_LIVE = 1, 2704 VIR_MIGRATE_PEER2PEER = 2, 2705 VIR_MIGRATE_TUNNELLED = 4, 2706 VIR_MIGRATE_PERSIST_DEST = 8, 2707 VIR_MIGRATE_UNDEFINE_SOURCE = 16, 2708 VIR_MIGRATE_PAUSED = 32, 2709 VIR_MIGRATE_NON_SHARED_DISK = 64, 2710 VIR_MIGRATE_NON_SHARED_INC = 128, 2711 VIR_MIGRATE_CHANGE_PROTECTION = 256, 2712 VIR_MIGRATE_UNSAFE = 512, 2713 VIR_MIGRATE_OFFLINE = 1024, 2714 VIR_MIGRATE_COMPRESSED = 2048, 2715 VIR_MIGRATE_ABORT_ON_ERROR = 4096, 2716 VIR_MIGRATE_AUTO_CONVERGE = 8192, 2717 VIR_MIGRATE_RDMA_PIN_ALL = 16384, 2718 VIR_MIGRATE_POSTCOPY = 32768, 2719 VIR_MIGRATE_TLS = 65536, 2720 } 2721 alias virDomainMigrateFlags = _Anonymous_107; 2722 virDomainPtr virDomainMigrate(virDomainPtr, virConnectPtr, c_ulong, const(char)*, const(char)*, c_ulong, ); 2723 virDomainPtr virDomainMigrate2(virDomainPtr, virConnectPtr, const(char)*, c_ulong, const(char)*, const(char)*, c_ulong, ); 2724 virDomainPtr virDomainMigrate3(virDomainPtr, virConnectPtr, virTypedParameterPtr, uint, uint, ); 2725 int virDomainMigrateToURI(virDomainPtr, const(char)*, c_ulong, const(char)*, c_ulong, ); 2726 int virDomainMigrateToURI2(virDomainPtr, const(char)*, const(char)*, const(char)*, c_ulong, const(char)*, c_ulong, ); 2727 int virDomainMigrateToURI3(virDomainPtr, const(char)*, virTypedParameterPtr, uint, uint, ); 2728 int virDomainMigrateGetMaxDowntime(virDomainPtr, ulong*, uint, ); 2729 int virDomainMigrateSetMaxDowntime(virDomainPtr, ulong, uint, ); 2730 int virDomainMigrateGetCompressionCache(virDomainPtr, ulong*, uint, ); 2731 int virDomainMigrateSetCompressionCache(virDomainPtr, ulong, uint, ); 2732 int virDomainMigrateSetMaxSpeed(virDomainPtr, c_ulong, uint, ); 2733 int virDomainMigrateGetMaxSpeed(virDomainPtr, c_ulong*, uint, ); 2734 int virDomainMigrateStartPostCopy(virDomainPtr, uint, ); 2735 char* virConnectGetDomainCapabilities(virConnectPtr, const(char)*, const(char)*, const(char)*, const(char)*, uint, ); 2736 int virConnectListDomains(virConnectPtr, int*, int, ); 2737 int virConnectNumOfDomains(virConnectPtr, ); 2738 virConnectPtr virDomainGetConnect(virDomainPtr, ); 2739 virDomainPtr virDomainCreateXML(virConnectPtr, const(char)*, uint, ); 2740 virDomainPtr virDomainCreateXMLWithFiles(virConnectPtr, const(char)*, uint, int*, uint, ); 2741 virDomainPtr virDomainLookupByName(virConnectPtr, const(char)*, ); 2742 virDomainPtr virDomainLookupByID(virConnectPtr, int, ); 2743 virDomainPtr virDomainLookupByUUID(virConnectPtr, const(ubyte)*, ); 2744 virDomainPtr virDomainLookupByUUIDString(virConnectPtr, const(char)*, ); 2745 alias virDomainShutdownFlagValues = _Anonymous_108; 2746 enum _Anonymous_108 2747 { 2748 VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, 2749 VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = 1, 2750 VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = 2, 2751 VIR_DOMAIN_SHUTDOWN_INITCTL = 4, 2752 VIR_DOMAIN_SHUTDOWN_SIGNAL = 8, 2753 VIR_DOMAIN_SHUTDOWN_PARAVIRT = 16, 2754 } 2755 enum 2756 { 2757 VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, 2758 VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = 1, 2759 VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = 2, 2760 VIR_DOMAIN_SHUTDOWN_INITCTL = 4, 2761 VIR_DOMAIN_SHUTDOWN_SIGNAL = 8, 2762 VIR_DOMAIN_SHUTDOWN_PARAVIRT = 16, 2763 } 2764 int virDomainShutdown(virDomainPtr, ); 2765 int virDomainShutdownFlags(virDomainPtr, uint, ); 2766 alias virDomainRebootFlagValues = _Anonymous_109; 2767 enum _Anonymous_109 2768 { 2769 VIR_DOMAIN_REBOOT_DEFAULT = 0, 2770 VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = 1, 2771 VIR_DOMAIN_REBOOT_GUEST_AGENT = 2, 2772 VIR_DOMAIN_REBOOT_INITCTL = 4, 2773 VIR_DOMAIN_REBOOT_SIGNAL = 8, 2774 VIR_DOMAIN_REBOOT_PARAVIRT = 16, 2775 } 2776 enum 2777 { 2778 VIR_DOMAIN_REBOOT_DEFAULT = 0, 2779 VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = 1, 2780 VIR_DOMAIN_REBOOT_GUEST_AGENT = 2, 2781 VIR_DOMAIN_REBOOT_INITCTL = 4, 2782 VIR_DOMAIN_REBOOT_SIGNAL = 8, 2783 VIR_DOMAIN_REBOOT_PARAVIRT = 16, 2784 } 2785 int virDomainReboot(virDomainPtr, uint, ); 2786 int virDomainReset(virDomainPtr, uint, ); 2787 int virDomainDestroy(virDomainPtr, ); 2788 enum _Anonymous_110 2789 { 2790 VIR_DOMAIN_DESTROY_DEFAULT = 0, 2791 VIR_DOMAIN_DESTROY_GRACEFUL = 1, 2792 } 2793 enum 2794 { 2795 VIR_DOMAIN_DESTROY_DEFAULT = 0, 2796 VIR_DOMAIN_DESTROY_GRACEFUL = 1, 2797 } 2798 alias virDomainDestroyFlagsValues = _Anonymous_110; 2799 int virDomainDestroyFlags(virDomainPtr, uint, ); 2800 int virDomainRef(virDomainPtr, ); 2801 int virDomainFree(virDomainPtr, ); 2802 int virDomainSuspend(virDomainPtr, ); 2803 int virDomainResume(virDomainPtr, ); 2804 int virDomainPMSuspendForDuration(virDomainPtr, uint, ulong, uint, ); 2805 int virDomainPMWakeup(virDomainPtr, uint, ); 2806 enum _Anonymous_111 2807 { 2808 VIR_DOMAIN_SAVE_BYPASS_CACHE = 1, 2809 VIR_DOMAIN_SAVE_RUNNING = 2, 2810 VIR_DOMAIN_SAVE_PAUSED = 4, 2811 } 2812 enum 2813 { 2814 VIR_DOMAIN_SAVE_BYPASS_CACHE = 1, 2815 VIR_DOMAIN_SAVE_RUNNING = 2, 2816 VIR_DOMAIN_SAVE_PAUSED = 4, 2817 } 2818 alias virDomainSaveRestoreFlags = _Anonymous_111; 2819 int virDomainSave(virDomainPtr, const(char)*, ); 2820 int virDomainSaveFlags(virDomainPtr, const(char)*, const(char)*, uint, ); 2821 int virDomainRestore(virConnectPtr, const(char)*, ); 2822 int virDomainRestoreFlags(virConnectPtr, const(char)*, const(char)*, uint, ); 2823 char* virDomainSaveImageGetXMLDesc(virConnectPtr, const(char)*, uint, ); 2824 int virDomainSaveImageDefineXML(virConnectPtr, const(char)*, const(char)*, uint, ); 2825 int virDomainManagedSave(virDomainPtr, uint, ); 2826 int virDomainHasManagedSaveImage(virDomainPtr, uint, ); 2827 int virDomainManagedSaveRemove(virDomainPtr, uint, ); 2828 char* virDomainManagedSaveGetXMLDesc(virDomainPtr, uint, ); 2829 int virDomainManagedSaveDefineXML(virDomainPtr, const(char)*, uint, ); 2830 int virDomainCoreDump(virDomainPtr, const(char)*, uint, ); 2831 int virDomainCoreDumpWithFormat(virDomainPtr, const(char)*, uint, uint, ); 2832 char* virDomainScreenshot(virDomainPtr, virStreamPtr, uint, uint, ); 2833 int virDomainGetInfo(virDomainPtr, virDomainInfoPtr, ); 2834 int virDomainGetState(virDomainPtr, int*, int*, uint, ); 2835 int virDomainGetCPUStats(virDomainPtr, virTypedParameterPtr, uint, int, uint, uint, ); 2836 int virDomainGetControlInfo(virDomainPtr, virDomainControlInfoPtr, uint, ); 2837 char* virDomainGetSchedulerType(virDomainPtr, int*, ); 2838 int virDomainSetBlkioParameters(virDomainPtr, virTypedParameterPtr, int, uint, ); 2839 int virDomainGetBlkioParameters(virDomainPtr, virTypedParameterPtr, int*, uint, ); 2840 int virDomainSetMemoryParameters(virDomainPtr, virTypedParameterPtr, int, uint, ); 2841 int virDomainGetMemoryParameters(virDomainPtr, virTypedParameterPtr, int*, uint, ); 2842 alias virDomainMemoryModFlags = _Anonymous_112; 2843 enum _Anonymous_112 2844 { 2845 VIR_DOMAIN_MEM_CURRENT = 0, 2846 VIR_DOMAIN_MEM_LIVE = 1, 2847 VIR_DOMAIN_MEM_CONFIG = 2, 2848 VIR_DOMAIN_MEM_MAXIMUM = 4, 2849 } 2850 enum 2851 { 2852 VIR_DOMAIN_MEM_CURRENT = 0, 2853 VIR_DOMAIN_MEM_LIVE = 1, 2854 VIR_DOMAIN_MEM_CONFIG = 2, 2855 VIR_DOMAIN_MEM_MAXIMUM = 4, 2856 } 2857 alias virDomainNumatuneMemMode = _Anonymous_113; 2858 enum _Anonymous_113 2859 { 2860 VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, 2861 VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, 2862 VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, 2863 } 2864 enum 2865 { 2866 VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, 2867 VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, 2868 VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, 2869 } 2870 2871 2872 2873 2874 int virDomainSetNumaParameters(virDomainPtr, virTypedParameterPtr, int, uint, ); 2875 int virDomainGetNumaParameters(virDomainPtr, virTypedParameterPtr, int*, uint, ); 2876 const(char)* virDomainGetName(virDomainPtr, ); 2877 uint virDomainGetID(virDomainPtr, ); 2878 int virDomainGetUUID(virDomainPtr, ubyte*, ); 2879 int virDomainGetUUIDString(virDomainPtr, char*, ); 2880 char* virDomainGetOSType(virDomainPtr, ); 2881 c_ulong virDomainGetMaxMemory(virDomainPtr, ); 2882 int virDomainSetMaxMemory(virDomainPtr, c_ulong, ); 2883 int virDomainSetMemory(virDomainPtr, c_ulong, ); 2884 int virDomainSetMemoryFlags(virDomainPtr, c_ulong, uint, ); 2885 int virDomainSetMemoryStatsPeriod(virDomainPtr, int, uint, ); 2886 int virDomainGetMaxVcpus(virDomainPtr, ); 2887 int virDomainGetSecurityLabel(virDomainPtr, virSecurityLabelPtr, ); 2888 char* virDomainGetHostname(virDomainPtr, uint, ); 2889 int virDomainGetSecurityLabelList(virDomainPtr, virSecurityLabelPtr*, ); 2890 enum _Anonymous_114 2891 { 2892 VIR_DOMAIN_METADATA_DESCRIPTION = 0, 2893 VIR_DOMAIN_METADATA_TITLE = 1, 2894 VIR_DOMAIN_METADATA_ELEMENT = 2, 2895 } 2896 enum 2897 { 2898 VIR_DOMAIN_METADATA_DESCRIPTION = 0, 2899 VIR_DOMAIN_METADATA_TITLE = 1, 2900 VIR_DOMAIN_METADATA_ELEMENT = 2, 2901 } 2902 alias virDomainMetadataType = _Anonymous_114; 2903 int virDomainSetMetadata(virDomainPtr, int, const(char)*, const(char)*, const(char)*, uint, ); 2904 char* virDomainGetMetadata(virDomainPtr, int, const(char)*, uint, ); 2905 enum _Anonymous_115 2906 { 2907 VIR_DOMAIN_XML_SECURE = 1, 2908 VIR_DOMAIN_XML_INACTIVE = 2, 2909 VIR_DOMAIN_XML_UPDATE_CPU = 4, 2910 VIR_DOMAIN_XML_MIGRATABLE = 8, 2911 } 2912 enum 2913 { 2914 VIR_DOMAIN_XML_SECURE = 1, 2915 VIR_DOMAIN_XML_INACTIVE = 2, 2916 VIR_DOMAIN_XML_UPDATE_CPU = 4, 2917 VIR_DOMAIN_XML_MIGRATABLE = 8, 2918 } 2919 alias virDomainXMLFlags = _Anonymous_115; 2920 char* virDomainGetXMLDesc(virDomainPtr, uint, ); 2921 char* virConnectDomainXMLFromNative(virConnectPtr, const(char)*, const(char)*, uint, ); 2922 char* virConnectDomainXMLToNative(virConnectPtr, const(char)*, const(char)*, uint, ); 2923 int virDomainBlockStats(virDomainPtr, const(char)*, virDomainBlockStatsPtr, int, ); 2924 int virDomainBlockStatsFlags(virDomainPtr, const(char)*, virTypedParameterPtr, int*, uint, ); 2925 int virDomainInterfaceStats(virDomainPtr, const(char)*, virDomainInterfaceStatsPtr, int, ); 2926 int virDomainSetInterfaceParameters(virDomainPtr, const(char)*, virTypedParameterPtr, int, uint, ); 2927 int virDomainGetInterfaceParameters(virDomainPtr, const(char)*, virTypedParameterPtr, int*, uint, ); 2928 int virDomainBlockPeek(virDomainPtr, const(char)*, ulong, int, void*, uint, ); 2929 alias virDomainBlockResizeFlags = _Anonymous_116; 2930 enum _Anonymous_116 2931 { 2932 VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1, 2933 } 2934 enum 2935 { 2936 VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1, 2937 } 2938 int virDomainBlockResize(virDomainPtr, const(char)*, ulong, uint, ); 2939 alias virDomainBlockInfo = struct__virDomainBlockInfo; 2940 alias virDomainBlockInfoPtr = virDomainBlockInfo*; 2941 struct struct__virDomainBlockInfo 2942 { 2943 ulong capacity; 2944 ulong allocation; 2945 ulong physical; 2946 } 2947 int virDomainGetBlockInfo(virDomainPtr, const(char)*, virDomainBlockInfoPtr, uint, ); 2948 int virDomainMemoryStats(virDomainPtr, virDomainMemoryStatPtr, uint, uint, ); 2949 enum _Anonymous_117 2950 { 2951 VIR_MEMORY_VIRTUAL = 1, 2952 VIR_MEMORY_PHYSICAL = 2, 2953 } 2954 enum 2955 { 2956 VIR_MEMORY_VIRTUAL = 1, 2957 VIR_MEMORY_PHYSICAL = 2, 2958 } 2959 alias virDomainMemoryFlags = _Anonymous_117; 2960 int virDomainMemoryPeek(virDomainPtr, ulong, int, void*, uint, ); 2961 enum _Anonymous_118 2962 { 2963 VIR_DOMAIN_DEFINE_VALIDATE = 1, 2964 } 2965 enum 2966 { 2967 VIR_DOMAIN_DEFINE_VALIDATE = 1, 2968 } 2969 alias virDomainDefineFlags = _Anonymous_118; 2970 virDomainPtr virDomainDefineXML(virConnectPtr, const(char)*, ); 2971 virDomainPtr virDomainDefineXMLFlags(virConnectPtr, const(char)*, uint, ); 2972 int virDomainUndefine(virDomainPtr, ); 2973 alias virDomainUndefineFlagsValues = _Anonymous_119; 2974 enum _Anonymous_119 2975 { 2976 VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1, 2977 VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2, 2978 VIR_DOMAIN_UNDEFINE_NVRAM = 4, 2979 VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = 8, 2980 } 2981 enum 2982 { 2983 VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1, 2984 VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2, 2985 VIR_DOMAIN_UNDEFINE_NVRAM = 4, 2986 VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = 8, 2987 } 2988 int virDomainUndefineFlags(virDomainPtr, uint, ); 2989 int virConnectNumOfDefinedDomains(virConnectPtr, ); 2990 int virConnectListDefinedDomains(virConnectPtr, char**, int, ); 2991 alias virConnectListAllDomainsFlags = _Anonymous_120; 2992 enum _Anonymous_120 2993 { 2994 VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1, 2995 VIR_CONNECT_LIST_DOMAINS_INACTIVE = 2, 2996 VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 4, 2997 VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 8, 2998 VIR_CONNECT_LIST_DOMAINS_RUNNING = 16, 2999 VIR_CONNECT_LIST_DOMAINS_PAUSED = 32, 3000 VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 64, 3001 VIR_CONNECT_LIST_DOMAINS_OTHER = 128, 3002 VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 256, 3003 VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 512, 3004 VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1024, 3005 VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 2048, 3006 VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 4096, 3007 VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 8192, 3008 } 3009 enum 3010 { 3011 VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1, 3012 VIR_CONNECT_LIST_DOMAINS_INACTIVE = 2, 3013 VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 4, 3014 VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 8, 3015 VIR_CONNECT_LIST_DOMAINS_RUNNING = 16, 3016 VIR_CONNECT_LIST_DOMAINS_PAUSED = 32, 3017 VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 64, 3018 VIR_CONNECT_LIST_DOMAINS_OTHER = 128, 3019 VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 256, 3020 VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 512, 3021 VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1024, 3022 VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 2048, 3023 VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 4096, 3024 VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 8192, 3025 } 3026 int virConnectListAllDomains(virConnectPtr, virDomainPtr**, uint, ); 3027 int virDomainCreate(virDomainPtr, ); 3028 int virDomainCreateWithFlags(virDomainPtr, uint, ); 3029 int virDomainCreateWithFiles(virDomainPtr, uint, int*, uint, ); 3030 int virDomainGetAutostart(virDomainPtr, int*, ); 3031 int virDomainSetAutostart(virDomainPtr, int, ); 3032 alias virVcpuState = _Anonymous_121; 3033 enum _Anonymous_121 3034 { 3035 VIR_VCPU_OFFLINE = 0, 3036 VIR_VCPU_RUNNING = 1, 3037 VIR_VCPU_BLOCKED = 2, 3038 } 3039 enum 3040 { 3041 VIR_VCPU_OFFLINE = 0, 3042 VIR_VCPU_RUNNING = 1, 3043 VIR_VCPU_BLOCKED = 2, 3044 } 3045 alias virVcpuInfo = struct__virVcpuInfo; 3046 struct struct__virVcpuInfo 3047 { 3048 uint number; 3049 int state; 3050 ulong cpuTime; 3051 int cpu; 3052 } 3053 alias virVcpuInfoPtr = virVcpuInfo*; 3054 alias virDomainVcpuFlags = _Anonymous_122; 3055 enum _Anonymous_122 3056 { 3057 VIR_DOMAIN_VCPU_CURRENT = 0, 3058 VIR_DOMAIN_VCPU_LIVE = 1, 3059 VIR_DOMAIN_VCPU_CONFIG = 2, 3060 VIR_DOMAIN_VCPU_MAXIMUM = 4, 3061 VIR_DOMAIN_VCPU_GUEST = 8, 3062 VIR_DOMAIN_VCPU_HOTPLUGGABLE = 16, 3063 } 3064 enum 3065 { 3066 VIR_DOMAIN_VCPU_CURRENT = 0, 3067 VIR_DOMAIN_VCPU_LIVE = 1, 3068 VIR_DOMAIN_VCPU_CONFIG = 2, 3069 VIR_DOMAIN_VCPU_MAXIMUM = 4, 3070 VIR_DOMAIN_VCPU_GUEST = 8, 3071 VIR_DOMAIN_VCPU_HOTPLUGGABLE = 16, 3072 } 3073 int virDomainSetVcpus(virDomainPtr, uint, ); 3074 int virDomainSetVcpusFlags(virDomainPtr, uint, uint, ); 3075 int virDomainGetVcpusFlags(virDomainPtr, uint, ); 3076 int virDomainPinVcpu(virDomainPtr, uint, ubyte*, int, ); 3077 int virDomainPinVcpuFlags(virDomainPtr, uint, ubyte*, int, uint, ); 3078 int virDomainGetVcpuPinInfo(virDomainPtr, int, ubyte*, int, uint, ); 3079 int virDomainPinEmulator(virDomainPtr, ubyte*, int, uint, ); 3080 int virDomainGetEmulatorPinInfo(virDomainPtr, ubyte*, int, uint, ); 3081 alias virDomainIOThreadInfo = struct__virDomainIOThreadInfo; 3082 alias virDomainIOThreadInfoPtr = virDomainIOThreadInfo*; 3083 struct struct__virDomainIOThreadInfo 3084 { 3085 uint iothread_id; 3086 ubyte* cpumap; 3087 int cpumaplen; 3088 } 3089 void virDomainIOThreadInfoFree(virDomainIOThreadInfoPtr, ); 3090 int virDomainGetIOThreadInfo(virDomainPtr, virDomainIOThreadInfoPtr**, uint, ); 3091 int virDomainPinIOThread(virDomainPtr, uint, ubyte*, int, uint, ); 3092 int virDomainAddIOThread(virDomainPtr, uint, uint, ); 3093 int virDomainDelIOThread(virDomainPtr, uint, uint, ); 3094 int virDomainGetVcpus(virDomainPtr, virVcpuInfoPtr, int, ubyte*, int, ); 3095 alias virDomainDeviceModifyFlags = _Anonymous_123; 3096 enum _Anonymous_123 3097 { 3098 VIR_DOMAIN_DEVICE_MODIFY_CURRENT = 0, 3099 VIR_DOMAIN_DEVICE_MODIFY_LIVE = 1, 3100 VIR_DOMAIN_DEVICE_MODIFY_CONFIG = 2, 3101 VIR_DOMAIN_DEVICE_MODIFY_FORCE = 4, 3102 } 3103 enum 3104 { 3105 VIR_DOMAIN_DEVICE_MODIFY_CURRENT = 0, 3106 VIR_DOMAIN_DEVICE_MODIFY_LIVE = 1, 3107 VIR_DOMAIN_DEVICE_MODIFY_CONFIG = 2, 3108 VIR_DOMAIN_DEVICE_MODIFY_FORCE = 4, 3109 } 3110 int virDomainAttachDevice(virDomainPtr, const(char)*, ); 3111 int virDomainDetachDevice(virDomainPtr, const(char)*, ); 3112 int virDomainAttachDeviceFlags(virDomainPtr, const(char)*, uint, ); 3113 int virDomainDetachDeviceFlags(virDomainPtr, const(char)*, uint, ); 3114 int virDomainUpdateDeviceFlags(virDomainPtr, const(char)*, uint, ); 3115 alias virDomainStatsRecord = struct__virDomainStatsRecord; 3116 alias virDomainStatsRecordPtr = virDomainStatsRecord*; 3117 struct struct__virDomainStatsRecord 3118 { 3119 virDomainPtr dom; 3120 virTypedParameterPtr params; 3121 int nparams; 3122 } 3123 enum _Anonymous_124 3124 { 3125 VIR_DOMAIN_STATS_STATE = 1, 3126 VIR_DOMAIN_STATS_CPU_TOTAL = 2, 3127 VIR_DOMAIN_STATS_BALLOON = 4, 3128 VIR_DOMAIN_STATS_VCPU = 8, 3129 VIR_DOMAIN_STATS_INTERFACE = 16, 3130 VIR_DOMAIN_STATS_BLOCK = 32, 3131 VIR_DOMAIN_STATS_PERF = 64, 3132 } 3133 enum 3134 { 3135 VIR_DOMAIN_STATS_STATE = 1, 3136 VIR_DOMAIN_STATS_CPU_TOTAL = 2, 3137 VIR_DOMAIN_STATS_BALLOON = 4, 3138 VIR_DOMAIN_STATS_VCPU = 8, 3139 VIR_DOMAIN_STATS_INTERFACE = 16, 3140 VIR_DOMAIN_STATS_BLOCK = 32, 3141 VIR_DOMAIN_STATS_PERF = 64, 3142 } 3143 alias virDomainStatsTypes = _Anonymous_124; 3144 alias virConnectGetAllDomainStatsFlags = _Anonymous_125; 3145 enum _Anonymous_125 3146 { 3147 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE = 1, 3148 VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE = 2, 3149 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT = 4, 3150 VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = 8, 3151 VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = 16, 3152 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = 32, 3153 VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = 64, 3154 VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = 128, 3155 VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING = 1073741824, 3156 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = -2147483648, 3157 } 3158 enum 3159 { 3160 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE = 1, 3161 VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE = 2, 3162 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT = 4, 3163 VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = 8, 3164 VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = 16, 3165 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = 32, 3166 VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = 64, 3167 VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = 128, 3168 VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING = 1073741824, 3169 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = -2147483648, 3170 } 3171 int virConnectGetAllDomainStats(virConnectPtr, uint, virDomainStatsRecordPtr**, uint, ); 3172 int virDomainListGetStats(virDomainPtr*, uint, virDomainStatsRecordPtr**, uint, ); 3173 void virDomainStatsRecordListFree(virDomainStatsRecordPtr*, ); 3174 int virDomainGetPerfEvents(virDomainPtr, virTypedParameterPtr*, int*, uint, ); 3175 int virDomainSetPerfEvents(virDomainPtr, virTypedParameterPtr, int, uint, ); 3176 enum _Anonymous_126 3177 { 3178 VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0, 3179 VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1, 3180 VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2, 3181 VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3, 3182 VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4, 3183 } 3184 enum 3185 { 3186 VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0, 3187 VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1, 3188 VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2, 3189 VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3, 3190 VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4, 3191 } 3192 alias virDomainBlockJobType = _Anonymous_126; 3193 alias virDomainBlockJobAbortFlags = _Anonymous_127; 3194 enum _Anonymous_127 3195 { 3196 VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1, 3197 VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 2, 3198 } 3199 enum 3200 { 3201 VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1, 3202 VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 2, 3203 } 3204 int virDomainBlockJobAbort(virDomainPtr, const(char)*, uint, ); 3205 alias virDomainBlockJobInfoFlags = _Anonymous_128; 3206 enum _Anonymous_128 3207 { 3208 VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1, 3209 } 3210 enum 3211 { 3212 VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1, 3213 } 3214 alias virDomainBlockJobCursor = ulong; 3215 alias virDomainBlockJobInfo = struct__virDomainBlockJobInfo; 3216 struct struct__virDomainBlockJobInfo 3217 { 3218 int type; 3219 c_ulong bandwidth; 3220 virDomainBlockJobCursor cur; 3221 virDomainBlockJobCursor end; 3222 } 3223 alias virDomainBlockJobInfoPtr = virDomainBlockJobInfo*; 3224 int virDomainGetBlockJobInfo(virDomainPtr, const(char)*, virDomainBlockJobInfoPtr, uint, ); 3225 alias virDomainBlockJobSetSpeedFlags = _Anonymous_129; 3226 enum _Anonymous_129 3227 { 3228 VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1, 3229 } 3230 enum 3231 { 3232 VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1, 3233 } 3234 int virDomainBlockJobSetSpeed(virDomainPtr, const(char)*, c_ulong, uint, ); 3235 alias virDomainBlockPullFlags = _Anonymous_130; 3236 enum _Anonymous_130 3237 { 3238 VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 64, 3239 } 3240 enum 3241 { 3242 VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 64, 3243 } 3244 int virDomainBlockPull(virDomainPtr, const(char)*, c_ulong, uint, ); 3245 alias virDomainBlockRebaseFlags = _Anonymous_131; 3246 enum _Anonymous_131 3247 { 3248 VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1, 3249 VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 2, 3250 VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 4, 3251 VIR_DOMAIN_BLOCK_REBASE_COPY = 8, 3252 VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 16, 3253 VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 32, 3254 VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 64, 3255 } 3256 enum 3257 { 3258 VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1, 3259 VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 2, 3260 VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 4, 3261 VIR_DOMAIN_BLOCK_REBASE_COPY = 8, 3262 VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 16, 3263 VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 32, 3264 VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 64, 3265 } 3266 int virDomainBlockRebase(virDomainPtr, const(char)*, const(char)*, c_ulong, uint, ); 3267 alias virDomainBlockCopyFlags = _Anonymous_132; 3268 enum _Anonymous_132 3269 { 3270 VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1, 3271 VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 2, 3272 VIR_DOMAIN_BLOCK_COPY_TRANSIENT_JOB = 4, 3273 } 3274 enum 3275 { 3276 VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1, 3277 VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 2, 3278 VIR_DOMAIN_BLOCK_COPY_TRANSIENT_JOB = 4, 3279 } 3280 3281 3282 3283 3284 3285 3286 int virDomainBlockCopy(virDomainPtr, const(char)*, const(char)*, virTypedParameterPtr, int, uint, ); 3287 enum _Anonymous_133 3288 { 3289 VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1, 3290 VIR_DOMAIN_BLOCK_COMMIT_DELETE = 2, 3291 VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 4, 3292 VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 8, 3293 VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 16, 3294 } 3295 enum 3296 { 3297 VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1, 3298 VIR_DOMAIN_BLOCK_COMMIT_DELETE = 2, 3299 VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 4, 3300 VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 8, 3301 VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 16, 3302 } 3303 alias virDomainBlockCommitFlags = _Anonymous_133; 3304 int virDomainBlockCommit(virDomainPtr, const(char)*, const(char)*, const(char)*, c_ulong, uint, ); 3305 int virDomainSetBlockIoTune(virDomainPtr, const(char)*, virTypedParameterPtr, int, uint, ); 3306 int virDomainGetBlockIoTune(virDomainPtr, const(char)*, virTypedParameterPtr, int*, uint, ); 3307 alias virDomainDiskErrorCode = _Anonymous_134; 3308 enum _Anonymous_134 3309 { 3310 VIR_DOMAIN_DISK_ERROR_NONE = 0, 3311 VIR_DOMAIN_DISK_ERROR_UNSPEC = 1, 3312 VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2, 3313 } 3314 enum 3315 { 3316 VIR_DOMAIN_DISK_ERROR_NONE = 0, 3317 VIR_DOMAIN_DISK_ERROR_UNSPEC = 1, 3318 VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2, 3319 } 3320 alias virDomainDiskError = struct__virDomainDiskError; 3321 alias virDomainDiskErrorPtr = virDomainDiskError*; 3322 struct struct__virDomainDiskError 3323 { 3324 char* disk; 3325 int error; 3326 } 3327 int virDomainGetDiskErrors(virDomainPtr, virDomainDiskErrorPtr, uint, uint, ); 3328 alias virKeycodeSet = _Anonymous_135; 3329 enum _Anonymous_135 3330 { 3331 VIR_KEYCODE_SET_LINUX = 0, 3332 VIR_KEYCODE_SET_XT = 1, 3333 VIR_KEYCODE_SET_ATSET1 = 2, 3334 VIR_KEYCODE_SET_ATSET2 = 3, 3335 VIR_KEYCODE_SET_ATSET3 = 4, 3336 VIR_KEYCODE_SET_OSX = 5, 3337 VIR_KEYCODE_SET_XT_KBD = 6, 3338 VIR_KEYCODE_SET_USB = 7, 3339 VIR_KEYCODE_SET_WIN32 = 8, 3340 VIR_KEYCODE_SET_QNUM = 9, 3341 } 3342 enum 3343 { 3344 VIR_KEYCODE_SET_LINUX = 0, 3345 VIR_KEYCODE_SET_XT = 1, 3346 VIR_KEYCODE_SET_ATSET1 = 2, 3347 VIR_KEYCODE_SET_ATSET2 = 3, 3348 VIR_KEYCODE_SET_ATSET3 = 4, 3349 VIR_KEYCODE_SET_OSX = 5, 3350 VIR_KEYCODE_SET_XT_KBD = 6, 3351 VIR_KEYCODE_SET_USB = 7, 3352 VIR_KEYCODE_SET_WIN32 = 8, 3353 VIR_KEYCODE_SET_QNUM = 9, 3354 } 3355 3356 3357 3358 3359 int virDomainSendKey(virDomainPtr, uint, uint, uint*, int, uint, ); 3360 alias virDomainProcessSignal = _Anonymous_136; 3361 enum _Anonymous_136 3362 { 3363 VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0, 3364 VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1, 3365 VIR_DOMAIN_PROCESS_SIGNAL_INT = 2, 3366 VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3, 3367 VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4, 3368 VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5, 3369 VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6, 3370 VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7, 3371 VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8, 3372 VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9, 3373 VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10, 3374 VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11, 3375 VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12, 3376 VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13, 3377 VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14, 3378 VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15, 3379 VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16, 3380 VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17, 3381 VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18, 3382 VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19, 3383 VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20, 3384 VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21, 3385 VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22, 3386 VIR_DOMAIN_PROCESS_SIGNAL_URG = 23, 3387 VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24, 3388 VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25, 3389 VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26, 3390 VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27, 3391 VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28, 3392 VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29, 3393 VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30, 3394 VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31, 3395 VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32, 3396 VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33, 3397 VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34, 3398 VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35, 3399 VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36, 3400 VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37, 3401 VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38, 3402 VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39, 3403 VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40, 3404 VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41, 3405 VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42, 3406 VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43, 3407 VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44, 3408 VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45, 3409 VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46, 3410 VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47, 3411 VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48, 3412 VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49, 3413 VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50, 3414 VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51, 3415 VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52, 3416 VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53, 3417 VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54, 3418 VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55, 3419 VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56, 3420 VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57, 3421 VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58, 3422 VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59, 3423 VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60, 3424 VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61, 3425 VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62, 3426 VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63, 3427 VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64, 3428 } 3429 enum 3430 { 3431 VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0, 3432 VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1, 3433 VIR_DOMAIN_PROCESS_SIGNAL_INT = 2, 3434 VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3, 3435 VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4, 3436 VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5, 3437 VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6, 3438 VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7, 3439 VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8, 3440 VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9, 3441 VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10, 3442 VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11, 3443 VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12, 3444 VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13, 3445 VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14, 3446 VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15, 3447 VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16, 3448 VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17, 3449 VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18, 3450 VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19, 3451 VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20, 3452 VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21, 3453 VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22, 3454 VIR_DOMAIN_PROCESS_SIGNAL_URG = 23, 3455 VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24, 3456 VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25, 3457 VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26, 3458 VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27, 3459 VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28, 3460 VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29, 3461 VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30, 3462 VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31, 3463 VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32, 3464 VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33, 3465 VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34, 3466 VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35, 3467 VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36, 3468 VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37, 3469 VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38, 3470 VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39, 3471 VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40, 3472 VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41, 3473 VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42, 3474 VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43, 3475 VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44, 3476 VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45, 3477 VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46, 3478 VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47, 3479 VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48, 3480 VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49, 3481 VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50, 3482 VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51, 3483 VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52, 3484 VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53, 3485 VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54, 3486 VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55, 3487 VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56, 3488 VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57, 3489 VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58, 3490 VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59, 3491 VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60, 3492 VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61, 3493 VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62, 3494 VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63, 3495 VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64, 3496 } 3497 int virDomainSendProcessSignal(virDomainPtr, long, uint, uint, ); 3498 virDomainPtr virDomainCreateLinux(virConnectPtr, const(char)*, uint, ); 3499 alias virDomainEventType = _Anonymous_137; 3500 enum _Anonymous_137 3501 { 3502 VIR_DOMAIN_EVENT_DEFINED = 0, 3503 VIR_DOMAIN_EVENT_UNDEFINED = 1, 3504 VIR_DOMAIN_EVENT_STARTED = 2, 3505 VIR_DOMAIN_EVENT_SUSPENDED = 3, 3506 VIR_DOMAIN_EVENT_RESUMED = 4, 3507 VIR_DOMAIN_EVENT_STOPPED = 5, 3508 VIR_DOMAIN_EVENT_SHUTDOWN = 6, 3509 VIR_DOMAIN_EVENT_PMSUSPENDED = 7, 3510 VIR_DOMAIN_EVENT_CRASHED = 8, 3511 } 3512 enum 3513 { 3514 VIR_DOMAIN_EVENT_DEFINED = 0, 3515 VIR_DOMAIN_EVENT_UNDEFINED = 1, 3516 VIR_DOMAIN_EVENT_STARTED = 2, 3517 VIR_DOMAIN_EVENT_SUSPENDED = 3, 3518 VIR_DOMAIN_EVENT_RESUMED = 4, 3519 VIR_DOMAIN_EVENT_STOPPED = 5, 3520 VIR_DOMAIN_EVENT_SHUTDOWN = 6, 3521 VIR_DOMAIN_EVENT_PMSUSPENDED = 7, 3522 VIR_DOMAIN_EVENT_CRASHED = 8, 3523 } 3524 alias virDomainEventDefinedDetailType = _Anonymous_138; 3525 enum _Anonymous_138 3526 { 3527 VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, 3528 VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, 3529 VIR_DOMAIN_EVENT_DEFINED_RENAMED = 2, 3530 VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT = 3, 3531 } 3532 enum 3533 { 3534 VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, 3535 VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, 3536 VIR_DOMAIN_EVENT_DEFINED_RENAMED = 2, 3537 VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT = 3, 3538 } 3539 alias virDomainEventUndefinedDetailType = _Anonymous_139; 3540 enum _Anonymous_139 3541 { 3542 VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, 3543 VIR_DOMAIN_EVENT_UNDEFINED_RENAMED = 1, 3544 } 3545 enum 3546 { 3547 VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, 3548 VIR_DOMAIN_EVENT_UNDEFINED_RENAMED = 1, 3549 } 3550 alias virDomainEventStartedDetailType = _Anonymous_140; 3551 enum _Anonymous_140 3552 { 3553 VIR_DOMAIN_EVENT_STARTED_BOOTED = 0, 3554 VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1, 3555 VIR_DOMAIN_EVENT_STARTED_RESTORED = 2, 3556 VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3, 3557 VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4, 3558 } 3559 enum 3560 { 3561 VIR_DOMAIN_EVENT_STARTED_BOOTED = 0, 3562 VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1, 3563 VIR_DOMAIN_EVENT_STARTED_RESTORED = 2, 3564 VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3, 3565 VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4, 3566 } 3567 alias virDomainEventSuspendedDetailType = _Anonymous_141; 3568 enum _Anonymous_141 3569 { 3570 VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0, 3571 VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1, 3572 VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2, 3573 VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3, 3574 VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4, 3575 VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5, 3576 VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6, 3577 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY = 7, 3578 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED = 8, 3579 } 3580 enum 3581 { 3582 VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0, 3583 VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1, 3584 VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2, 3585 VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3, 3586 VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4, 3587 VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5, 3588 VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6, 3589 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY = 7, 3590 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED = 8, 3591 } 3592 alias virDomainEventResumedDetailType = _Anonymous_142; 3593 enum _Anonymous_142 3594 { 3595 VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0, 3596 VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1, 3597 VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2, 3598 VIR_DOMAIN_EVENT_RESUMED_POSTCOPY = 3, 3599 } 3600 enum 3601 { 3602 VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0, 3603 VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1, 3604 VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2, 3605 VIR_DOMAIN_EVENT_RESUMED_POSTCOPY = 3, 3606 } 3607 alias virDomainEventStoppedDetailType = _Anonymous_143; 3608 enum _Anonymous_143 3609 { 3610 VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0, 3611 VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1, 3612 VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2, 3613 VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3, 3614 VIR_DOMAIN_EVENT_STOPPED_SAVED = 4, 3615 VIR_DOMAIN_EVENT_STOPPED_FAILED = 5, 3616 VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6, 3617 } 3618 enum 3619 { 3620 VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0, 3621 VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1, 3622 VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2, 3623 VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3, 3624 VIR_DOMAIN_EVENT_STOPPED_SAVED = 4, 3625 VIR_DOMAIN_EVENT_STOPPED_FAILED = 5, 3626 VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6, 3627 } 3628 alias virDomainEventShutdownDetailType = _Anonymous_144; 3629 enum _Anonymous_144 3630 { 3631 VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, 3632 VIR_DOMAIN_EVENT_SHUTDOWN_GUEST = 1, 3633 VIR_DOMAIN_EVENT_SHUTDOWN_HOST = 2, 3634 } 3635 enum 3636 { 3637 VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, 3638 VIR_DOMAIN_EVENT_SHUTDOWN_GUEST = 1, 3639 VIR_DOMAIN_EVENT_SHUTDOWN_HOST = 2, 3640 } 3641 alias virDomainEventPMSuspendedDetailType = _Anonymous_145; 3642 enum _Anonymous_145 3643 { 3644 VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, 3645 VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, 3646 } 3647 enum 3648 { 3649 VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, 3650 VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, 3651 } 3652 alias virDomainEventCrashedDetailType = _Anonymous_146; 3653 enum _Anonymous_146 3654 { 3655 VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, 3656 } 3657 enum 3658 { 3659 VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, 3660 } 3661 alias virConnectDomainEventCallback = int function(virConnectPtr conn, 3662 virDomainPtr dom, 3663 int event, 3664 int detail, 3665 void *opaque); 3666 int virConnectDomainEventRegister(virConnectPtr, virConnectDomainEventCallback, void*, virFreeCallback, ); 3667 int virConnectDomainEventDeregister(virConnectPtr, virConnectDomainEventCallback, ); 3668 int virDomainIsActive(virDomainPtr, ); 3669 int virDomainIsPersistent(virDomainPtr, ); 3670 int virDomainIsUpdated(virDomainPtr, ); 3671 alias virDomainJobType = _Anonymous_147; 3672 enum _Anonymous_147 3673 { 3674 VIR_DOMAIN_JOB_NONE = 0, 3675 VIR_DOMAIN_JOB_BOUNDED = 1, 3676 VIR_DOMAIN_JOB_UNBOUNDED = 2, 3677 VIR_DOMAIN_JOB_COMPLETED = 3, 3678 VIR_DOMAIN_JOB_FAILED = 4, 3679 VIR_DOMAIN_JOB_CANCELLED = 5, 3680 } 3681 enum 3682 { 3683 VIR_DOMAIN_JOB_NONE = 0, 3684 VIR_DOMAIN_JOB_BOUNDED = 1, 3685 VIR_DOMAIN_JOB_UNBOUNDED = 2, 3686 VIR_DOMAIN_JOB_COMPLETED = 3, 3687 VIR_DOMAIN_JOB_FAILED = 4, 3688 VIR_DOMAIN_JOB_CANCELLED = 5, 3689 } 3690 alias virDomainJobInfo = struct__virDomainJobInfo; 3691 alias virDomainJobInfoPtr = virDomainJobInfo*; 3692 struct struct__virDomainJobInfo 3693 { 3694 int type; 3695 ulong timeElapsed; 3696 ulong timeRemaining; 3697 ulong dataTotal; 3698 ulong dataProcessed; 3699 ulong dataRemaining; 3700 ulong memTotal; 3701 ulong memProcessed; 3702 ulong memRemaining; 3703 ulong fileTotal; 3704 ulong fileProcessed; 3705 ulong fileRemaining; 3706 } 3707 alias virDomainGetJobStatsFlags = _Anonymous_148; 3708 enum _Anonymous_148 3709 { 3710 VIR_DOMAIN_JOB_STATS_COMPLETED = 1, 3711 } 3712 enum 3713 { 3714 VIR_DOMAIN_JOB_STATS_COMPLETED = 1, 3715 } 3716 int virDomainGetJobInfo(virDomainPtr, virDomainJobInfoPtr, ); 3717 int virDomainGetJobStats(virDomainPtr, int*, virTypedParameterPtr*, int*, uint, ); 3718 int virDomainAbortJob(virDomainPtr, ); 3719 alias virDomainJobOperation = _Anonymous_149; 3720 enum _Anonymous_149 3721 { 3722 VIR_DOMAIN_JOB_OPERATION_UNKNOWN = 0, 3723 VIR_DOMAIN_JOB_OPERATION_START = 1, 3724 VIR_DOMAIN_JOB_OPERATION_SAVE = 2, 3725 VIR_DOMAIN_JOB_OPERATION_RESTORE = 3, 3726 VIR_DOMAIN_JOB_OPERATION_MIGRATION_IN = 4, 3727 VIR_DOMAIN_JOB_OPERATION_MIGRATION_OUT = 5, 3728 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT = 6, 3729 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT = 7, 3730 VIR_DOMAIN_JOB_OPERATION_DUMP = 8, 3731 } 3732 enum 3733 { 3734 VIR_DOMAIN_JOB_OPERATION_UNKNOWN = 0, 3735 VIR_DOMAIN_JOB_OPERATION_START = 1, 3736 VIR_DOMAIN_JOB_OPERATION_SAVE = 2, 3737 VIR_DOMAIN_JOB_OPERATION_RESTORE = 3, 3738 VIR_DOMAIN_JOB_OPERATION_MIGRATION_IN = 4, 3739 VIR_DOMAIN_JOB_OPERATION_MIGRATION_OUT = 5, 3740 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT = 6, 3741 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT = 7, 3742 VIR_DOMAIN_JOB_OPERATION_DUMP = 8, 3743 } 3744 alias virConnectDomainEventGenericCallback = void* function(virConnectPtr conn, 3745 virDomainPtr dom, 3746 void *opaque); 3747 alias virConnectDomainEventRTCChangeCallback = void* function(virConnectPtr conn, 3748 virDomainPtr dom, 3749 long utcoffset, 3750 void *opaque); 3751 3752 3753 alias virDomainEventWatchdogAction = _Anonymous_150; 3754 enum _Anonymous_150 3755 { 3756 VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, 3757 VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = 1, 3758 VIR_DOMAIN_EVENT_WATCHDOG_RESET = 2, 3759 VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = 3, 3760 VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = 4, 3761 VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = 5, 3762 VIR_DOMAIN_EVENT_WATCHDOG_INJECTNMI = 6, 3763 } 3764 enum 3765 { 3766 VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, 3767 VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = 1, 3768 VIR_DOMAIN_EVENT_WATCHDOG_RESET = 2, 3769 VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = 3, 3770 VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = 4, 3771 VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = 5, 3772 VIR_DOMAIN_EVENT_WATCHDOG_INJECTNMI = 6, 3773 } 3774 alias virConnectDomainEventWatchdogCallback = void* function(virConnectPtr conn, 3775 virDomainPtr dom, 3776 int action, 3777 void *opaque); 3778 3779 alias virDomainEventIOErrorAction = _Anonymous_151; 3780 enum _Anonymous_151 3781 { 3782 VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, 3783 VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = 1, 3784 VIR_DOMAIN_EVENT_IO_ERROR_REPORT = 2, 3785 } 3786 enum 3787 { 3788 VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, 3789 VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = 1, 3790 VIR_DOMAIN_EVENT_IO_ERROR_REPORT = 2, 3791 } 3792 alias virConnectDomainEventIOErrorCallback = void* function(virConnectPtr conn, 3793 virDomainPtr dom, 3794 const char *srcPath, 3795 const char *devAlias, 3796 int action, 3797 void *opaque); 3798 3799 alias virConnectDomainEventIOErrorReasonCallback = void* function(virConnectPtr conn, 3800 virDomainPtr dom, 3801 const char *srcPath, 3802 const char *devAlias, 3803 int action, 3804 const char *reason, 3805 void *opaque); 3806 3807 3808 alias virDomainEventGraphicsPhase = _Anonymous_152; 3809 enum _Anonymous_152 3810 { 3811 VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, 3812 VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = 1, 3813 VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = 2, 3814 } 3815 enum 3816 { 3817 VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, 3818 VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = 1, 3819 VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = 2, 3820 } 3821 alias virDomainEventGraphicsAddressType = _Anonymous_153; 3822 enum _Anonymous_153 3823 { 3824 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = 0, 3825 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = 1, 3826 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = 2, 3827 } 3828 enum 3829 { 3830 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = 0, 3831 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = 1, 3832 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = 2, 3833 } 3834 struct struct__virDomainEventGraphicsAddress 3835 { 3836 int family; 3837 char* node; 3838 char* service; 3839 } 3840 alias virDomainEventGraphicsAddress = struct__virDomainEventGraphicsAddress; 3841 alias virDomainEventGraphicsAddressPtr = virDomainEventGraphicsAddress*; 3842 struct struct__virDomainEventGraphicsSubjectIdentity 3843 { 3844 char* type; 3845 char* name; 3846 } 3847 alias virDomainEventGraphicsSubjectIdentity = struct__virDomainEventGraphicsSubjectIdentity; 3848 alias virDomainEventGraphicsSubjectIdentityPtr = virDomainEventGraphicsSubjectIdentity*; 3849 struct struct__virDomainEventGraphicsSubject 3850 { 3851 int nidentity; 3852 virDomainEventGraphicsSubjectIdentityPtr identities; 3853 } 3854 alias virDomainEventGraphicsSubject = struct__virDomainEventGraphicsSubject; 3855 alias virDomainEventGraphicsSubjectPtr = virDomainEventGraphicsSubject*; 3856 alias virConnectDomainEventGraphicsCallback = void* function(virConnectPtr conn, 3857 virDomainPtr dom, 3858 int phase, 3859 const virDomainEventGraphicsAddress *local, 3860 const virDomainEventGraphicsAddress *remote, 3861 const char *authScheme, 3862 const virDomainEventGraphicsSubject *subject, 3863 void *opaque); 3864 3865 3866 alias virConnectDomainEventBlockJobStatus = _Anonymous_154; 3867 enum _Anonymous_154 3868 { 3869 VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, 3870 VIR_DOMAIN_BLOCK_JOB_FAILED = 1, 3871 VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, 3872 VIR_DOMAIN_BLOCK_JOB_READY = 3, 3873 } 3874 enum 3875 { 3876 VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, 3877 VIR_DOMAIN_BLOCK_JOB_FAILED = 1, 3878 VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, 3879 VIR_DOMAIN_BLOCK_JOB_READY = 3, 3880 } 3881 alias virConnectDomainEventBlockJobCallback = void* function(virConnectPtr conn, 3882 virDomainPtr dom, 3883 const char *disk, 3884 int type, 3885 int status, 3886 void *opaque); 3887 3888 alias virConnectDomainEventDiskChangeReason = _Anonymous_155; 3889 enum _Anonymous_155 3890 { 3891 VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, 3892 VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, 3893 } 3894 enum 3895 { 3896 VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, 3897 VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, 3898 } 3899 alias virConnectDomainEventDiskChangeCallback = void* function(virConnectPtr conn, 3900 virDomainPtr dom, 3901 const char *oldSrcPath, 3902 const char *newSrcPath, 3903 const char *devAlias, 3904 int reason, 3905 void *opaque); 3906 3907 alias virDomainEventTrayChangeReason = _Anonymous_156; 3908 enum _Anonymous_156 3909 { 3910 VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, 3911 VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE = 1, 3912 } 3913 enum 3914 { 3915 VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, 3916 VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE = 1, 3917 } 3918 alias virConnectDomainEventTrayChangeCallback = void* function(virConnectPtr conn, 3919 virDomainPtr dom, 3920 const char *devAlias, 3921 int reason, 3922 void *opaque); 3923 alias virConnectDomainEventPMWakeupCallback = void* function(virConnectPtr conn, 3924 virDomainPtr dom, 3925 int reason, 3926 void *opaque); 3927 alias virConnectDomainEventPMSuspendCallback = void* function(virConnectPtr conn, 3928 virDomainPtr dom, 3929 int reason, 3930 void *opaque); 3931 alias virConnectDomainEventBalloonChangeCallback = void* function(virConnectPtr conn, 3932 virDomainPtr dom, 3933 ulong actual, 3934 void *opaque); 3935 alias virConnectDomainEventPMSuspendDiskCallback = void* function(virConnectPtr conn, 3936 virDomainPtr dom, 3937 int reason, 3938 void *opaque); 3939 alias virConnectDomainEventDeviceRemovedCallback = void* function(virConnectPtr conn, 3940 virDomainPtr dom, 3941 const char *devAlias, 3942 void *opaque); 3943 alias virConnectDomainEventDeviceAddedCallback = void* function(virConnectPtr conn, 3944 virDomainPtr dom, 3945 const char *devAlias, 3946 void *opaque); 3947 alias virConnectDomainEventDeviceRemovalFailedCallback = void* function(virConnectPtr conn, 3948 virDomainPtr dom, 3949 const char *devAlias, 3950 void *opaque); 3951 alias virConnectDomainEventMetadataChangeCallback =void* function(virConnectPtr conn, 3952 virDomainPtr dom, 3953 int type, 3954 const char *nsuri, 3955 void *opaque); 3956 alias virConnectDomainEventMigrationIterationCallback = void* function(virConnectPtr conn, 3957 virDomainPtr dom, 3958 int iteration, 3959 void *opaque); 3960 alias virConnectDomainEventJobCompletedCallback = void* function(virConnectPtr conn, 3961 virDomainPtr dom, 3962 virTypedParameterPtr params, 3963 int nparams, 3964 void *opaque); 3965 alias virConnectDomainEventTunableCallback = void* function(virConnectPtr conn, 3966 virDomainPtr dom, 3967 virTypedParameterPtr params, 3968 int nparams, 3969 void *opaque); 3970 3971 3972 alias virConnectDomainEventAgentLifecycleState = _Anonymous_157; 3973 enum _Anonymous_157 3974 { 3975 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_CONNECTED = 1, 3976 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_DISCONNECTED = 2, 3977 } 3978 enum 3979 { 3980 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_CONNECTED = 1, 3981 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_DISCONNECTED = 2, 3982 } 3983 alias virConnectDomainEventAgentLifecycleReason = _Anonymous_158; 3984 enum _Anonymous_158 3985 { 3986 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_UNKNOWN = 0, 3987 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED = 1, 3988 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL = 2, 3989 } 3990 enum 3991 { 3992 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_UNKNOWN = 0, 3993 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED = 1, 3994 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL = 2, 3995 } 3996 alias virConnectDomainEventAgentLifecycleCallback = void* function(virConnectPtr conn, 3997 virDomainPtr dom, 3998 int state, 3999 int reason, 4000 void *opaque); 4001 4002 alias virConnectDomainEventBlockThresholdCallback = void* function(virConnectPtr conn, 4003 virDomainPtr dom, 4004 const char *dev, 4005 const char *path, 4006 ulong threshold, 4007 ulong excess, 4008 void *opaque); 4009 4010 4011 alias virDomainEventID = _Anonymous_159; 4012 enum _Anonymous_159 4013 { 4014 VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, 4015 VIR_DOMAIN_EVENT_ID_REBOOT = 1, 4016 VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2, 4017 VIR_DOMAIN_EVENT_ID_WATCHDOG = 3, 4018 VIR_DOMAIN_EVENT_ID_IO_ERROR = 4, 4019 VIR_DOMAIN_EVENT_ID_GRAPHICS = 5, 4020 VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6, 4021 VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7, 4022 VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8, 4023 VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9, 4024 VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10, 4025 VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11, 4026 VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12, 4027 VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13, 4028 VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14, 4029 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15, 4030 VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16, 4031 VIR_DOMAIN_EVENT_ID_TUNABLE = 17, 4032 VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18, 4033 VIR_DOMAIN_EVENT_ID_DEVICE_ADDED = 19, 4034 VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20, 4035 VIR_DOMAIN_EVENT_ID_JOB_COMPLETED = 21, 4036 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED = 22, 4037 VIR_DOMAIN_EVENT_ID_METADATA_CHANGE = 23, 4038 VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD = 24, 4039 } 4040 enum 4041 { 4042 VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, 4043 VIR_DOMAIN_EVENT_ID_REBOOT = 1, 4044 VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2, 4045 VIR_DOMAIN_EVENT_ID_WATCHDOG = 3, 4046 VIR_DOMAIN_EVENT_ID_IO_ERROR = 4, 4047 VIR_DOMAIN_EVENT_ID_GRAPHICS = 5, 4048 VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6, 4049 VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7, 4050 VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8, 4051 VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9, 4052 VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10, 4053 VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11, 4054 VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12, 4055 VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13, 4056 VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14, 4057 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15, 4058 VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16, 4059 VIR_DOMAIN_EVENT_ID_TUNABLE = 17, 4060 VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18, 4061 VIR_DOMAIN_EVENT_ID_DEVICE_ADDED = 19, 4062 VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20, 4063 VIR_DOMAIN_EVENT_ID_JOB_COMPLETED = 21, 4064 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED = 22, 4065 VIR_DOMAIN_EVENT_ID_METADATA_CHANGE = 23, 4066 VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD = 24, 4067 } 4068 int virConnectDomainEventRegisterAny(virConnectPtr, virDomainPtr, int, virConnectDomainEventGenericCallback, void*, virFreeCallback, ); 4069 int virConnectDomainEventDeregisterAny(virConnectPtr, int, ); 4070 alias virDomainConsoleFlags = _Anonymous_160; 4071 enum _Anonymous_160 4072 { 4073 VIR_DOMAIN_CONSOLE_FORCE = 1, 4074 VIR_DOMAIN_CONSOLE_SAFE = 2, 4075 } 4076 enum 4077 { 4078 VIR_DOMAIN_CONSOLE_FORCE = 1, 4079 VIR_DOMAIN_CONSOLE_SAFE = 2, 4080 } 4081 int virDomainOpenConsole(virDomainPtr, const(char)*, virStreamPtr, uint, ); 4082 alias virDomainChannelFlags = _Anonymous_161; 4083 enum _Anonymous_161 4084 { 4085 VIR_DOMAIN_CHANNEL_FORCE = 1, 4086 } 4087 enum 4088 { 4089 VIR_DOMAIN_CHANNEL_FORCE = 1, 4090 } 4091 int virDomainOpenChannel(virDomainPtr, const(char)*, virStreamPtr, uint, ); 4092 alias virDomainOpenGraphicsFlags = _Anonymous_162; 4093 enum _Anonymous_162 4094 { 4095 VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = 1, 4096 } 4097 enum 4098 { 4099 VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = 1, 4100 } 4101 int virDomainOpenGraphics(virDomainPtr, uint, int, uint, ); 4102 int virDomainOpenGraphicsFD(virDomainPtr, uint, uint, ); 4103 int virDomainInjectNMI(virDomainPtr, uint, ); 4104 int virDomainFSTrim(virDomainPtr, const(char)*, ulong, uint, ); 4105 int virDomainFSFreeze(virDomainPtr, const(char)**, uint, uint, ); 4106 int virDomainFSThaw(virDomainPtr, const(char)**, uint, uint, ); 4107 alias virDomainFSInfo = struct__virDomainFSInfo; 4108 alias virDomainFSInfoPtr = virDomainFSInfo*; 4109 struct struct__virDomainFSInfo 4110 { 4111 char* mountpoint; 4112 char* name; 4113 char* fstype; 4114 int ndevAlias; 4115 char** devAlias; 4116 } 4117 void virDomainFSInfoFree(virDomainFSInfoPtr, ); 4118 int virDomainGetFSInfo(virDomainPtr, virDomainFSInfoPtr**, uint, ); 4119 int virDomainGetTime(virDomainPtr, long*, uint*, uint, ); 4120 alias virDomainSetTimeFlags = _Anonymous_163; 4121 enum _Anonymous_163 4122 { 4123 VIR_DOMAIN_TIME_SYNC = 1, 4124 } 4125 enum 4126 { 4127 VIR_DOMAIN_TIME_SYNC = 1, 4128 } 4129 int virDomainSetTime(virDomainPtr, long, uint, uint, ); 4130 alias virSchedParameterType = _Anonymous_164; 4131 enum _Anonymous_164 4132 { 4133 VIR_DOMAIN_SCHED_FIELD_INT = 1, 4134 VIR_DOMAIN_SCHED_FIELD_UINT = 2, 4135 VIR_DOMAIN_SCHED_FIELD_LLONG = 3, 4136 VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, 4137 VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, 4138 VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6, 4139 } 4140 enum 4141 { 4142 VIR_DOMAIN_SCHED_FIELD_INT = 1, 4143 VIR_DOMAIN_SCHED_FIELD_UINT = 2, 4144 VIR_DOMAIN_SCHED_FIELD_LLONG = 3, 4145 VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, 4146 VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, 4147 VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6, 4148 } 4149 4150 4151 4152 4153 alias virSchedParameter = struct__virTypedParameter; 4154 alias virSchedParameterPtr = virSchedParameter*; 4155 alias virBlkioParameterType = _Anonymous_165; 4156 enum _Anonymous_165 4157 { 4158 VIR_DOMAIN_BLKIO_PARAM_INT = 1, 4159 VIR_DOMAIN_BLKIO_PARAM_UINT = 2, 4160 VIR_DOMAIN_BLKIO_PARAM_LLONG = 3, 4161 VIR_DOMAIN_BLKIO_PARAM_ULLONG = 4, 4162 VIR_DOMAIN_BLKIO_PARAM_DOUBLE = 5, 4163 VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = 6, 4164 } 4165 enum 4166 { 4167 VIR_DOMAIN_BLKIO_PARAM_INT = 1, 4168 VIR_DOMAIN_BLKIO_PARAM_UINT = 2, 4169 VIR_DOMAIN_BLKIO_PARAM_LLONG = 3, 4170 VIR_DOMAIN_BLKIO_PARAM_ULLONG = 4, 4171 VIR_DOMAIN_BLKIO_PARAM_DOUBLE = 5, 4172 VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = 6, 4173 } 4174 4175 4176 4177 4178 alias virBlkioParameter = struct__virTypedParameter; 4179 alias virBlkioParameterPtr = virBlkioParameter*; 4180 alias virMemoryParameterType = _Anonymous_166; 4181 enum _Anonymous_166 4182 { 4183 VIR_DOMAIN_MEMORY_PARAM_INT = 1, 4184 VIR_DOMAIN_MEMORY_PARAM_UINT = 2, 4185 VIR_DOMAIN_MEMORY_PARAM_LLONG = 3, 4186 VIR_DOMAIN_MEMORY_PARAM_ULLONG = 4, 4187 VIR_DOMAIN_MEMORY_PARAM_DOUBLE = 5, 4188 VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = 6, 4189 } 4190 enum 4191 { 4192 VIR_DOMAIN_MEMORY_PARAM_INT = 1, 4193 VIR_DOMAIN_MEMORY_PARAM_UINT = 2, 4194 VIR_DOMAIN_MEMORY_PARAM_LLONG = 3, 4195 VIR_DOMAIN_MEMORY_PARAM_ULLONG = 4, 4196 VIR_DOMAIN_MEMORY_PARAM_DOUBLE = 5, 4197 VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = 6, 4198 } 4199 4200 4201 4202 4203 alias virMemoryParameter = struct__virTypedParameter; 4204 alias virMemoryParameterPtr = virMemoryParameter*; 4205 alias virDomainInterfaceAddressesSource = _Anonymous_167; 4206 enum _Anonymous_167 4207 { 4208 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0, 4209 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1, 4210 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP = 2, 4211 } 4212 enum 4213 { 4214 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0, 4215 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1, 4216 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP = 2, 4217 } 4218 alias virDomainIPAddress = struct__virDomainInterfaceIPAddress; 4219 alias virDomainIPAddressPtr = virDomainIPAddress*; 4220 struct struct__virDomainInterfaceIPAddress 4221 { 4222 int type; 4223 char* addr; 4224 uint prefix; 4225 } 4226 alias virDomainInterface = struct__virDomainInterface; 4227 alias virDomainInterfacePtr = virDomainInterface*; 4228 struct struct__virDomainInterface 4229 { 4230 char* name; 4231 char* hwaddr; 4232 uint naddrs; 4233 virDomainIPAddressPtr addrs; 4234 } 4235 int virDomainInterfaceAddresses(virDomainPtr, virDomainInterfacePtr**, uint, uint, ); 4236 void virDomainInterfaceFree(virDomainInterfacePtr, ); 4237 enum _Anonymous_168 4238 { 4239 VIR_DOMAIN_PASSWORD_ENCRYPTED = 1, 4240 } 4241 enum 4242 { 4243 VIR_DOMAIN_PASSWORD_ENCRYPTED = 1, 4244 } 4245 alias virDomainSetUserPasswordFlags = _Anonymous_168; 4246 int virDomainSetUserPassword(virDomainPtr, const(char)*, const(char)*, uint, ); 4247 int virDomainRename(virDomainPtr, const(char)*, uint, ); 4248 int virDomainGetGuestVcpus(virDomainPtr, virTypedParameterPtr*, uint*, uint, ); 4249 int virDomainSetGuestVcpus(virDomainPtr, const(char)*, int, uint, ); 4250 int virDomainSetVcpu(virDomainPtr, const(char)*, int, uint, ); 4251 int virDomainSetBlockThreshold(virDomainPtr, const(char)*, ulong, uint, ); 4252 alias virDomainLifecycle = _Anonymous_169; 4253 enum _Anonymous_169 4254 { 4255 VIR_DOMAIN_LIFECYCLE_POWEROFF = 0, 4256 VIR_DOMAIN_LIFECYCLE_REBOOT = 1, 4257 VIR_DOMAIN_LIFECYCLE_CRASH = 2, 4258 } 4259 enum 4260 { 4261 VIR_DOMAIN_LIFECYCLE_POWEROFF = 0, 4262 VIR_DOMAIN_LIFECYCLE_REBOOT = 1, 4263 VIR_DOMAIN_LIFECYCLE_CRASH = 2, 4264 } 4265 alias virDomainLifecycleAction = _Anonymous_170; 4266 enum _Anonymous_170 4267 { 4268 VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY = 0, 4269 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART = 1, 4270 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME = 2, 4271 VIR_DOMAIN_LIFECYCLE_ACTION_PRESERVE = 3, 4272 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY = 4, 4273 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART = 5, 4274 } 4275 enum 4276 { 4277 VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY = 0, 4278 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART = 1, 4279 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME = 2, 4280 VIR_DOMAIN_LIFECYCLE_ACTION_PRESERVE = 3, 4281 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY = 4, 4282 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART = 5, 4283 } 4284 int virDomainSetLifecycleAction(virDomainPtr, uint, uint, uint, ); 4285 } 4286 4287 extern(C) { 4288 struct _Anonymous_171 4289 { 4290 c_ulong[16] __val; 4291 } 4292 4293 4294 enum _Anonymous_172 4295 { 4296 VIR_NETWORK_XML_INACTIVE = 1, 4297 } 4298 union _Anonymous_173 4299 { 4300 char[4] __size; 4301 int __align; 4302 } 4303 enum _Anonymous_174 4304 { 4305 VIR_STREAM_NONBLOCK = 1, 4306 } 4307 enum _Anonymous_175 4308 { 4309 VIR_EVENT_HANDLE_READABLE = 1, 4310 VIR_EVENT_HANDLE_WRITABLE = 2, 4311 VIR_EVENT_HANDLE_ERROR = 4, 4312 VIR_EVENT_HANDLE_HANGUP = 8, 4313 } 4314 alias virErrorLevel = _Anonymous_176; 4315 enum _Anonymous_176 4316 { 4317 VIR_ERR_NONE = 0, 4318 VIR_ERR_WARNING = 1, 4319 VIR_ERR_ERROR = 2, 4320 } 4321 enum 4322 { 4323 VIR_ERR_NONE = 0, 4324 VIR_ERR_WARNING = 1, 4325 VIR_ERR_ERROR = 2, 4326 } 4327 enum _Anonymous_177 4328 { 4329 VIR_SECRET_USAGE_TYPE_NONE = 0, 4330 VIR_SECRET_USAGE_TYPE_VOLUME = 1, 4331 VIR_SECRET_USAGE_TYPE_CEPH = 2, 4332 VIR_SECRET_USAGE_TYPE_ISCSI = 3, 4333 VIR_SECRET_USAGE_TYPE_TLS = 4, 4334 } 4335 union _Anonymous_178 4336 { 4337 char[4] __size; 4338 int __align; 4339 } 4340 enum _Anonymous_179 4341 { 4342 VIR_STREAM_RECV_STOP_AT_HOLE = 1, 4343 } 4344 enum _Anonymous_180 4345 { 4346 VIR_STORAGE_POOL_INACTIVE = 0, 4347 VIR_STORAGE_POOL_BUILDING = 1, 4348 VIR_STORAGE_POOL_RUNNING = 2, 4349 VIR_STORAGE_POOL_DEGRADED = 3, 4350 VIR_STORAGE_POOL_INACCESSIBLE = 4, 4351 } 4352 enum _Anonymous_181 4353 { 4354 VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = 1, 4355 VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = 2, 4356 VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = 4, 4357 VIR_DOMAIN_SNAPSHOT_CREATE_HALT = 8, 4358 VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = 16, 4359 VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = 32, 4360 VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = 64, 4361 VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = 128, 4362 VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = 256, 4363 } 4364 enum _Anonymous_182 4365 { 4366 VIR_DOMAIN_NOSTATE = 0, 4367 VIR_DOMAIN_RUNNING = 1, 4368 VIR_DOMAIN_BLOCKED = 2, 4369 VIR_DOMAIN_PAUSED = 3, 4370 VIR_DOMAIN_SHUTDOWN = 4, 4371 VIR_DOMAIN_SHUTOFF = 5, 4372 VIR_DOMAIN_CRASHED = 6, 4373 VIR_DOMAIN_PMSUSPENDED = 7, 4374 } 4375 enum _Anonymous_183 4376 { 4377 VIR_FROM_NONE = 0, 4378 VIR_FROM_XEN = 1, 4379 VIR_FROM_XEND = 2, 4380 VIR_FROM_XENSTORE = 3, 4381 VIR_FROM_SEXPR = 4, 4382 VIR_FROM_XML = 5, 4383 VIR_FROM_DOM = 6, 4384 VIR_FROM_RPC = 7, 4385 VIR_FROM_PROXY = 8, 4386 VIR_FROM_CONF = 9, 4387 VIR_FROM_QEMU = 10, 4388 VIR_FROM_NET = 11, 4389 VIR_FROM_TEST = 12, 4390 VIR_FROM_REMOTE = 13, 4391 VIR_FROM_OPENVZ = 14, 4392 VIR_FROM_XENXM = 15, 4393 VIR_FROM_STATS_LINUX = 16, 4394 VIR_FROM_LXC = 17, 4395 VIR_FROM_STORAGE = 18, 4396 VIR_FROM_NETWORK = 19, 4397 VIR_FROM_DOMAIN = 20, 4398 VIR_FROM_UML = 21, 4399 VIR_FROM_NODEDEV = 22, 4400 VIR_FROM_XEN_INOTIFY = 23, 4401 VIR_FROM_SECURITY = 24, 4402 VIR_FROM_VBOX = 25, 4403 VIR_FROM_INTERFACE = 26, 4404 VIR_FROM_ONE = 27, 4405 VIR_FROM_ESX = 28, 4406 VIR_FROM_PHYP = 29, 4407 VIR_FROM_SECRET = 30, 4408 VIR_FROM_CPU = 31, 4409 VIR_FROM_XENAPI = 32, 4410 VIR_FROM_NWFILTER = 33, 4411 VIR_FROM_HOOK = 34, 4412 VIR_FROM_DOMAIN_SNAPSHOT = 35, 4413 VIR_FROM_AUDIT = 36, 4414 VIR_FROM_SYSINFO = 37, 4415 VIR_FROM_STREAMS = 38, 4416 VIR_FROM_VMWARE = 39, 4417 VIR_FROM_EVENT = 40, 4418 VIR_FROM_LIBXL = 41, 4419 VIR_FROM_LOCKING = 42, 4420 VIR_FROM_HYPERV = 43, 4421 VIR_FROM_CAPABILITIES = 44, 4422 VIR_FROM_URI = 45, 4423 VIR_FROM_AUTH = 46, 4424 VIR_FROM_DBUS = 47, 4425 VIR_FROM_PARALLELS = 48, 4426 VIR_FROM_DEVICE = 49, 4427 VIR_FROM_SSH = 50, 4428 VIR_FROM_LOCKSPACE = 51, 4429 VIR_FROM_INITCTL = 52, 4430 VIR_FROM_IDENTITY = 53, 4431 VIR_FROM_CGROUP = 54, 4432 VIR_FROM_ACCESS = 55, 4433 VIR_FROM_SYSTEMD = 56, 4434 VIR_FROM_BHYVE = 57, 4435 VIR_FROM_CRYPTO = 58, 4436 VIR_FROM_FIREWALL = 59, 4437 VIR_FROM_POLKIT = 60, 4438 VIR_FROM_THREAD = 61, 4439 VIR_FROM_ADMIN = 62, 4440 VIR_FROM_LOGGING = 63, 4441 VIR_FROM_XENXL = 64, 4442 VIR_FROM_PERF = 65, 4443 VIR_FROM_LIBSSH = 66, 4444 VIR_FROM_RESCTRL = 67, 4445 } 4446 enum 4447 { 4448 VIR_FROM_NONE = 0, 4449 VIR_FROM_XEN = 1, 4450 VIR_FROM_XEND = 2, 4451 VIR_FROM_XENSTORE = 3, 4452 VIR_FROM_SEXPR = 4, 4453 VIR_FROM_XML = 5, 4454 VIR_FROM_DOM = 6, 4455 VIR_FROM_RPC = 7, 4456 VIR_FROM_PROXY = 8, 4457 VIR_FROM_CONF = 9, 4458 VIR_FROM_QEMU = 10, 4459 VIR_FROM_NET = 11, 4460 VIR_FROM_TEST = 12, 4461 VIR_FROM_REMOTE = 13, 4462 VIR_FROM_OPENVZ = 14, 4463 VIR_FROM_XENXM = 15, 4464 VIR_FROM_STATS_LINUX = 16, 4465 VIR_FROM_LXC = 17, 4466 VIR_FROM_STORAGE = 18, 4467 VIR_FROM_NETWORK = 19, 4468 VIR_FROM_DOMAIN = 20, 4469 VIR_FROM_UML = 21, 4470 VIR_FROM_NODEDEV = 22, 4471 VIR_FROM_XEN_INOTIFY = 23, 4472 VIR_FROM_SECURITY = 24, 4473 VIR_FROM_VBOX = 25, 4474 VIR_FROM_INTERFACE = 26, 4475 VIR_FROM_ONE = 27, 4476 VIR_FROM_ESX = 28, 4477 VIR_FROM_PHYP = 29, 4478 VIR_FROM_SECRET = 30, 4479 VIR_FROM_CPU = 31, 4480 VIR_FROM_XENAPI = 32, 4481 VIR_FROM_NWFILTER = 33, 4482 VIR_FROM_HOOK = 34, 4483 VIR_FROM_DOMAIN_SNAPSHOT = 35, 4484 VIR_FROM_AUDIT = 36, 4485 VIR_FROM_SYSINFO = 37, 4486 VIR_FROM_STREAMS = 38, 4487 VIR_FROM_VMWARE = 39, 4488 VIR_FROM_EVENT = 40, 4489 VIR_FROM_LIBXL = 41, 4490 VIR_FROM_LOCKING = 42, 4491 VIR_FROM_HYPERV = 43, 4492 VIR_FROM_CAPABILITIES = 44, 4493 VIR_FROM_URI = 45, 4494 VIR_FROM_AUTH = 46, 4495 VIR_FROM_DBUS = 47, 4496 VIR_FROM_PARALLELS = 48, 4497 VIR_FROM_DEVICE = 49, 4498 VIR_FROM_SSH = 50, 4499 VIR_FROM_LOCKSPACE = 51, 4500 VIR_FROM_INITCTL = 52, 4501 VIR_FROM_IDENTITY = 53, 4502 VIR_FROM_CGROUP = 54, 4503 VIR_FROM_ACCESS = 55, 4504 VIR_FROM_SYSTEMD = 56, 4505 VIR_FROM_BHYVE = 57, 4506 VIR_FROM_CRYPTO = 58, 4507 VIR_FROM_FIREWALL = 59, 4508 VIR_FROM_POLKIT = 60, 4509 VIR_FROM_THREAD = 61, 4510 VIR_FROM_ADMIN = 62, 4511 VIR_FROM_LOGGING = 63, 4512 VIR_FROM_XENXL = 64, 4513 VIR_FROM_PERF = 65, 4514 VIR_FROM_LIBSSH = 66, 4515 VIR_FROM_RESCTRL = 67, 4516 } 4517 alias virErrorDomain = _Anonymous_183; 4518 enum _Anonymous_184 4519 { 4520 VIR_NODE_SUSPEND_TARGET_MEM = 0, 4521 VIR_NODE_SUSPEND_TARGET_DISK = 1, 4522 VIR_NODE_SUSPEND_TARGET_HYBRID = 2, 4523 } 4524 struct _Anonymous_185 4525 { 4526 __fd_mask[16] __fds_bits; 4527 } 4528 enum _Anonymous_186 4529 { 4530 VIR_STORAGE_POOL_BUILD_NEW = 0, 4531 VIR_STORAGE_POOL_BUILD_REPAIR = 1, 4532 VIR_STORAGE_POOL_BUILD_RESIZE = 2, 4533 VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = 4, 4534 VIR_STORAGE_POOL_BUILD_OVERWRITE = 8, 4535 } 4536 enum _Anonymous_187 4537 { 4538 VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1, 4539 VIR_CONNECT_LIST_INTERFACES_ACTIVE = 2, 4540 } 4541 union _Anonymous_188 4542 { 4543 struct___pthread_mutex_s __data; 4544 char[40] __size; 4545 c_long __align; 4546 } 4547 enum _Anonymous_189 4548 { 4549 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1, 4550 VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 2, 4551 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 4, 4552 VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 8, 4553 VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 16, 4554 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 32, 4555 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 64, 4556 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 128, 4557 VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 256, 4558 VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 512, 4559 VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1024, 4560 VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 2048, 4561 VIR_CONNECT_LIST_NODE_DEVICES_CAP_DRM = 4096, 4562 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV_TYPES = 8192, 4563 VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV = 16384, 4564 VIR_CONNECT_LIST_NODE_DEVICES_CAP_CCW_DEV = 32768, 4565 } 4566 enum _Anonymous_190 4567 { 4568 VIR_STORAGE_POOL_DELETE_NORMAL = 0, 4569 VIR_STORAGE_POOL_DELETE_ZEROED = 1, 4570 } 4571 enum _Anonymous_191 4572 { 4573 VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1, 4574 VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 2, 4575 VIR_CONNECT_LIST_SECRETS_PRIVATE = 4, 4576 VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 8, 4577 } 4578 enum _Anonymous_192 4579 { 4580 VIR_DOMAIN_NOSTATE_UNKNOWN = 0, 4581 } 4582 enum _Anonymous_193 4583 { 4584 VIR_STORAGE_POOL_CREATE_NORMAL = 0, 4585 VIR_STORAGE_POOL_CREATE_WITH_BUILD = 1, 4586 VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE = 2, 4587 VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE = 4, 4588 } 4589 union _Anonymous_194 4590 { 4591 struct___pthread_cond_s __data; 4592 char[48] __size; 4593 long __align; 4594 } 4595 enum _Anonymous_195 4596 { 4597 VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1, 4598 VIR_CONNECT_LIST_NETWORKS_ACTIVE = 2, 4599 VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 4, 4600 VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 8, 4601 VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 16, 4602 VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 32, 4603 } 4604 enum _Anonymous_196 4605 { 4606 VIR_INTERFACE_XML_INACTIVE = 1, 4607 } 4608 enum _Anonymous_197 4609 { 4610 VIR_DOMAIN_RUNNING_UNKNOWN = 0, 4611 VIR_DOMAIN_RUNNING_BOOTED = 1, 4612 VIR_DOMAIN_RUNNING_MIGRATED = 2, 4613 VIR_DOMAIN_RUNNING_RESTORED = 3, 4614 VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4, 4615 VIR_DOMAIN_RUNNING_UNPAUSED = 5, 4616 VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6, 4617 VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7, 4618 VIR_DOMAIN_RUNNING_WAKEUP = 8, 4619 VIR_DOMAIN_RUNNING_CRASHED = 9, 4620 VIR_DOMAIN_RUNNING_POSTCOPY = 10, 4621 } 4622 union _Anonymous_198 4623 { 4624 struct___pthread_rwlock_arch_t __data; 4625 char[56] __size; 4626 c_long __align; 4627 } 4628 union _Anonymous_199 4629 { 4630 char[8] __size; 4631 c_long __align; 4632 } 4633 enum _Anonymous_200 4634 { 4635 VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = 1, 4636 VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = 1, 4637 VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = 4, 4638 VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = 8, 4639 VIR_DOMAIN_SNAPSHOT_LIST_METADATA = 2, 4640 VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = 16, 4641 VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = 32, 4642 VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = 64, 4643 VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = 128, 4644 VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = 256, 4645 VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = 512, 4646 } 4647 enum _Anonymous_201 4648 { 4649 VIR_DOMAIN_BLOCKED_UNKNOWN = 0, 4650 } 4651 enum _Anonymous_202 4652 { 4653 VIR_DOMAIN_PAUSED_UNKNOWN = 0, 4654 VIR_DOMAIN_PAUSED_USER = 1, 4655 VIR_DOMAIN_PAUSED_MIGRATION = 2, 4656 VIR_DOMAIN_PAUSED_SAVE = 3, 4657 VIR_DOMAIN_PAUSED_DUMP = 4, 4658 VIR_DOMAIN_PAUSED_IOERROR = 5, 4659 VIR_DOMAIN_PAUSED_WATCHDOG = 6, 4660 VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7, 4661 VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8, 4662 VIR_DOMAIN_PAUSED_SNAPSHOT = 9, 4663 VIR_DOMAIN_PAUSED_CRASHED = 10, 4664 VIR_DOMAIN_PAUSED_STARTING_UP = 11, 4665 VIR_DOMAIN_PAUSED_POSTCOPY = 12, 4666 VIR_DOMAIN_PAUSED_POSTCOPY_FAILED = 13, 4667 } 4668 union _Anonymous_203 4669 { 4670 char[32] __size; 4671 c_long __align; 4672 } 4673 enum _Anonymous_204 4674 { 4675 VIR_CONNECT_CLOSE_REASON_ERROR = 0, 4676 VIR_CONNECT_CLOSE_REASON_EOF = 1, 4677 VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2, 4678 VIR_CONNECT_CLOSE_REASON_CLIENT = 3, 4679 } 4680 union _Anonymous_205 4681 { 4682 char[4] __size; 4683 int __align; 4684 } 4685 enum _Anonymous_206 4686 { 4687 VIR_STORAGE_VOL_FILE = 0, 4688 VIR_STORAGE_VOL_BLOCK = 1, 4689 VIR_STORAGE_VOL_DIR = 2, 4690 VIR_STORAGE_VOL_NETWORK = 3, 4691 VIR_STORAGE_VOL_NETDIR = 4, 4692 VIR_STORAGE_VOL_PLOOP = 5, 4693 } 4694 enum _Anonymous_207 4695 { 4696 VIR_NETWORK_UPDATE_COMMAND_NONE = 0, 4697 VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1, 4698 VIR_NETWORK_UPDATE_COMMAND_DELETE = 2, 4699 VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3, 4700 VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4, 4701 } 4702 enum _Anonymous_208 4703 { 4704 VIR_TYPED_PARAM_INT = 1, 4705 VIR_TYPED_PARAM_UINT = 2, 4706 VIR_TYPED_PARAM_LLONG = 3, 4707 VIR_TYPED_PARAM_ULLONG = 4, 4708 VIR_TYPED_PARAM_DOUBLE = 5, 4709 VIR_TYPED_PARAM_BOOLEAN = 6, 4710 VIR_TYPED_PARAM_STRING = 7, 4711 } 4712 enum _Anonymous_209 4713 { 4714 VIR_SECRET_EVENT_ID_LIFECYCLE = 0, 4715 VIR_SECRET_EVENT_ID_VALUE_CHANGED = 1, 4716 } 4717 enum _Anonymous_210 4718 { 4719 VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, 4720 VIR_DOMAIN_SHUTDOWN_USER = 1, 4721 } 4722 enum _Anonymous_211 4723 { 4724 VIR_STORAGE_VOL_DELETE_NORMAL = 0, 4725 VIR_STORAGE_VOL_DELETE_ZEROED = 1, 4726 VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS = 2, 4727 } 4728 enum _Anonymous_212 4729 { 4730 VIR_DOMAIN_SHUTOFF_UNKNOWN = 0, 4731 VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1, 4732 VIR_DOMAIN_SHUTOFF_DESTROYED = 2, 4733 VIR_DOMAIN_SHUTOFF_CRASHED = 3, 4734 VIR_DOMAIN_SHUTOFF_MIGRATED = 4, 4735 VIR_DOMAIN_SHUTOFF_SAVED = 5, 4736 VIR_DOMAIN_SHUTOFF_FAILED = 6, 4737 VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7, 4738 } 4739 enum _Anonymous_213 4740 { 4741 VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0, 4742 VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1, 4743 VIR_STORAGE_VOL_WIPE_ALG_DOD = 2, 4744 VIR_STORAGE_VOL_WIPE_ALG_BSI = 3, 4745 VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4, 4746 VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5, 4747 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6, 4748 VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7, 4749 VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8, 4750 VIR_STORAGE_VOL_WIPE_ALG_TRIM = 9, 4751 } 4752 struct _Anonymous_214 4753 { 4754 int[2] __val; 4755 } 4756 enum _Anonymous_215 4757 { 4758 VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE = 0, 4759 VIR_NODE_DEVICE_EVENT_ID_UPDATE = 1, 4760 } 4761 enum _Anonymous_216 4762 { 4763 VIR_NETWORK_SECTION_NONE = 0, 4764 VIR_NETWORK_SECTION_BRIDGE = 1, 4765 VIR_NETWORK_SECTION_DOMAIN = 2, 4766 VIR_NETWORK_SECTION_IP = 3, 4767 VIR_NETWORK_SECTION_IP_DHCP_HOST = 4, 4768 VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5, 4769 VIR_NETWORK_SECTION_FORWARD = 6, 4770 VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7, 4771 VIR_NETWORK_SECTION_FORWARD_PF = 8, 4772 VIR_NETWORK_SECTION_PORTGROUP = 9, 4773 VIR_NETWORK_SECTION_DNS_HOST = 10, 4774 VIR_NETWORK_SECTION_DNS_TXT = 11, 4775 VIR_NETWORK_SECTION_DNS_SRV = 12, 4776 } 4777 enum _Anonymous_217 4778 { 4779 VIR_TYPED_PARAM_STRING_OKAY = 4, 4780 } 4781 enum _Anonymous_218 4782 { 4783 VIR_DOMAIN_CRASHED_UNKNOWN = 0, 4784 VIR_DOMAIN_CRASHED_PANICKED = 1, 4785 } 4786 alias virError = struct__virError; 4787 alias virErrorPtr = virError*; 4788 struct struct__virError 4789 { 4790 int code; 4791 int domain; 4792 char* message; 4793 virErrorLevel level; 4794 virConnectPtr conn; 4795 virDomainPtr dom; 4796 char* str1; 4797 char* str2; 4798 char* str3; 4799 int int1; 4800 int int2; 4801 virNetworkPtr net; 4802 } 4803 enum _Anonymous_219 4804 { 4805 VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, 4806 } 4807 enum _Anonymous_220 4808 { 4809 VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0, 4810 VIR_NETWORK_UPDATE_AFFECT_LIVE = 1, 4811 VIR_NETWORK_UPDATE_AFFECT_CONFIG = 2, 4812 } 4813 enum _Anonymous_221 4814 { 4815 VIR_STORAGE_VOL_USE_ALLOCATION = 0, 4816 VIR_STORAGE_VOL_GET_PHYSICAL = 1, 4817 } 4818 enum _Anonymous_222 4819 { 4820 VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, 4821 } 4822 enum _Anonymous_223 4823 { 4824 VIR_SECRET_EVENT_DEFINED = 0, 4825 VIR_SECRET_EVENT_UNDEFINED = 1, 4826 } 4827 enum _Anonymous_224 4828 { 4829 VIR_DOMAIN_CONTROL_OK = 0, 4830 VIR_DOMAIN_CONTROL_JOB = 1, 4831 VIR_DOMAIN_CONTROL_OCCUPIED = 2, 4832 VIR_DOMAIN_CONTROL_ERROR = 3, 4833 } 4834 enum _Anonymous_225 4835 { 4836 VIR_NODE_CPU_STATS_ALL_CPUS = -1, 4837 } 4838 enum _Anonymous_226 4839 { 4840 VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1, 4841 VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 2, 4842 VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 4, 4843 } 4844 enum _Anonymous_227 4845 { 4846 VIR_STORAGE_XML_INACTIVE = 1, 4847 } 4848 enum _Anonymous_228 4849 { 4850 VIR_NODE_DEVICE_EVENT_CREATED = 0, 4851 VIR_NODE_DEVICE_EVENT_DELETED = 1, 4852 } 4853 enum _Anonymous_229 4854 { 4855 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = 1, 4856 VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = 2, 4857 VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = 4, 4858 } 4859 enum _Anonymous_230 4860 { 4861 VIR_DOMAIN_CONTROL_ERROR_REASON_NONE = 0, 4862 VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN = 1, 4863 VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR = 2, 4864 VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL = 3, 4865 } 4866 enum _Anonymous_231 4867 { 4868 VIR_ERR_OK = 0, 4869 VIR_ERR_INTERNAL_ERROR = 1, 4870 VIR_ERR_NO_MEMORY = 2, 4871 VIR_ERR_NO_SUPPORT = 3, 4872 VIR_ERR_UNKNOWN_HOST = 4, 4873 VIR_ERR_NO_CONNECT = 5, 4874 VIR_ERR_INVALID_CONN = 6, 4875 VIR_ERR_INVALID_DOMAIN = 7, 4876 VIR_ERR_INVALID_ARG = 8, 4877 VIR_ERR_OPERATION_FAILED = 9, 4878 VIR_ERR_GET_FAILED = 10, 4879 VIR_ERR_POST_FAILED = 11, 4880 VIR_ERR_HTTP_ERROR = 12, 4881 VIR_ERR_SEXPR_SERIAL = 13, 4882 VIR_ERR_NO_XEN = 14, 4883 VIR_ERR_XEN_CALL = 15, 4884 VIR_ERR_OS_TYPE = 16, 4885 VIR_ERR_NO_KERNEL = 17, 4886 VIR_ERR_NO_ROOT = 18, 4887 VIR_ERR_NO_SOURCE = 19, 4888 VIR_ERR_NO_TARGET = 20, 4889 VIR_ERR_NO_NAME = 21, 4890 VIR_ERR_NO_OS = 22, 4891 VIR_ERR_NO_DEVICE = 23, 4892 VIR_ERR_NO_XENSTORE = 24, 4893 VIR_ERR_DRIVER_FULL = 25, 4894 VIR_ERR_CALL_FAILED = 26, 4895 VIR_ERR_XML_ERROR = 27, 4896 VIR_ERR_DOM_EXIST = 28, 4897 VIR_ERR_OPERATION_DENIED = 29, 4898 VIR_ERR_OPEN_FAILED = 30, 4899 VIR_ERR_READ_FAILED = 31, 4900 VIR_ERR_PARSE_FAILED = 32, 4901 VIR_ERR_CONF_SYNTAX = 33, 4902 VIR_ERR_WRITE_FAILED = 34, 4903 VIR_ERR_XML_DETAIL = 35, 4904 VIR_ERR_INVALID_NETWORK = 36, 4905 VIR_ERR_NETWORK_EXIST = 37, 4906 VIR_ERR_SYSTEM_ERROR = 38, 4907 VIR_ERR_RPC = 39, 4908 VIR_ERR_GNUTLS_ERROR = 40, 4909 VIR_WAR_NO_NETWORK = 41, 4910 VIR_ERR_NO_DOMAIN = 42, 4911 VIR_ERR_NO_NETWORK = 43, 4912 VIR_ERR_INVALID_MAC = 44, 4913 VIR_ERR_AUTH_FAILED = 45, 4914 VIR_ERR_INVALID_STORAGE_POOL = 46, 4915 VIR_ERR_INVALID_STORAGE_VOL = 47, 4916 VIR_WAR_NO_STORAGE = 48, 4917 VIR_ERR_NO_STORAGE_POOL = 49, 4918 VIR_ERR_NO_STORAGE_VOL = 50, 4919 VIR_WAR_NO_NODE = 51, 4920 VIR_ERR_INVALID_NODE_DEVICE = 52, 4921 VIR_ERR_NO_NODE_DEVICE = 53, 4922 VIR_ERR_NO_SECURITY_MODEL = 54, 4923 VIR_ERR_OPERATION_INVALID = 55, 4924 VIR_WAR_NO_INTERFACE = 56, 4925 VIR_ERR_NO_INTERFACE = 57, 4926 VIR_ERR_INVALID_INTERFACE = 58, 4927 VIR_ERR_MULTIPLE_INTERFACES = 59, 4928 VIR_WAR_NO_NWFILTER = 60, 4929 VIR_ERR_INVALID_NWFILTER = 61, 4930 VIR_ERR_NO_NWFILTER = 62, 4931 VIR_ERR_BUILD_FIREWALL = 63, 4932 VIR_WAR_NO_SECRET = 64, 4933 VIR_ERR_INVALID_SECRET = 65, 4934 VIR_ERR_NO_SECRET = 66, 4935 VIR_ERR_CONFIG_UNSUPPORTED = 67, 4936 VIR_ERR_OPERATION_TIMEOUT = 68, 4937 VIR_ERR_MIGRATE_PERSIST_FAILED = 69, 4938 VIR_ERR_HOOK_SCRIPT_FAILED = 70, 4939 VIR_ERR_INVALID_DOMAIN_SNAPSHOT = 71, 4940 VIR_ERR_NO_DOMAIN_SNAPSHOT = 72, 4941 VIR_ERR_INVALID_STREAM = 73, 4942 VIR_ERR_ARGUMENT_UNSUPPORTED = 74, 4943 VIR_ERR_STORAGE_PROBE_FAILED = 75, 4944 VIR_ERR_STORAGE_POOL_BUILT = 76, 4945 VIR_ERR_SNAPSHOT_REVERT_RISKY = 77, 4946 VIR_ERR_OPERATION_ABORTED = 78, 4947 VIR_ERR_AUTH_CANCELLED = 79, 4948 VIR_ERR_NO_DOMAIN_METADATA = 80, 4949 VIR_ERR_MIGRATE_UNSAFE = 81, 4950 VIR_ERR_OVERFLOW = 82, 4951 VIR_ERR_BLOCK_COPY_ACTIVE = 83, 4952 VIR_ERR_OPERATION_UNSUPPORTED = 84, 4953 VIR_ERR_SSH = 85, 4954 VIR_ERR_AGENT_UNRESPONSIVE = 86, 4955 VIR_ERR_RESOURCE_BUSY = 87, 4956 VIR_ERR_ACCESS_DENIED = 88, 4957 VIR_ERR_DBUS_SERVICE = 89, 4958 VIR_ERR_STORAGE_VOL_EXIST = 90, 4959 VIR_ERR_CPU_INCOMPATIBLE = 91, 4960 VIR_ERR_XML_INVALID_SCHEMA = 92, 4961 VIR_ERR_MIGRATE_FINISH_OK = 93, 4962 VIR_ERR_AUTH_UNAVAILABLE = 94, 4963 VIR_ERR_NO_SERVER = 95, 4964 VIR_ERR_NO_CLIENT = 96, 4965 VIR_ERR_AGENT_UNSYNCED = 97, 4966 VIR_ERR_LIBSSH = 98, 4967 VIR_ERR_DEVICE_MISSING = 99, 4968 } 4969 enum 4970 { 4971 VIR_ERR_OK = 0, 4972 VIR_ERR_INTERNAL_ERROR = 1, 4973 VIR_ERR_NO_MEMORY = 2, 4974 VIR_ERR_NO_SUPPORT = 3, 4975 VIR_ERR_UNKNOWN_HOST = 4, 4976 VIR_ERR_NO_CONNECT = 5, 4977 VIR_ERR_INVALID_CONN = 6, 4978 VIR_ERR_INVALID_DOMAIN = 7, 4979 VIR_ERR_INVALID_ARG = 8, 4980 VIR_ERR_OPERATION_FAILED = 9, 4981 VIR_ERR_GET_FAILED = 10, 4982 VIR_ERR_POST_FAILED = 11, 4983 VIR_ERR_HTTP_ERROR = 12, 4984 VIR_ERR_SEXPR_SERIAL = 13, 4985 VIR_ERR_NO_XEN = 14, 4986 VIR_ERR_XEN_CALL = 15, 4987 VIR_ERR_OS_TYPE = 16, 4988 VIR_ERR_NO_KERNEL = 17, 4989 VIR_ERR_NO_ROOT = 18, 4990 VIR_ERR_NO_SOURCE = 19, 4991 VIR_ERR_NO_TARGET = 20, 4992 VIR_ERR_NO_NAME = 21, 4993 VIR_ERR_NO_OS = 22, 4994 VIR_ERR_NO_DEVICE = 23, 4995 VIR_ERR_NO_XENSTORE = 24, 4996 VIR_ERR_DRIVER_FULL = 25, 4997 VIR_ERR_CALL_FAILED = 26, 4998 VIR_ERR_XML_ERROR = 27, 4999 VIR_ERR_DOM_EXIST = 28, 5000 VIR_ERR_OPERATION_DENIED = 29, 5001 VIR_ERR_OPEN_FAILED = 30, 5002 VIR_ERR_READ_FAILED = 31, 5003 VIR_ERR_PARSE_FAILED = 32, 5004 VIR_ERR_CONF_SYNTAX = 33, 5005 VIR_ERR_WRITE_FAILED = 34, 5006 VIR_ERR_XML_DETAIL = 35, 5007 VIR_ERR_INVALID_NETWORK = 36, 5008 VIR_ERR_NETWORK_EXIST = 37, 5009 VIR_ERR_SYSTEM_ERROR = 38, 5010 VIR_ERR_RPC = 39, 5011 VIR_ERR_GNUTLS_ERROR = 40, 5012 VIR_WAR_NO_NETWORK = 41, 5013 VIR_ERR_NO_DOMAIN = 42, 5014 VIR_ERR_NO_NETWORK = 43, 5015 VIR_ERR_INVALID_MAC = 44, 5016 VIR_ERR_AUTH_FAILED = 45, 5017 VIR_ERR_INVALID_STORAGE_POOL = 46, 5018 VIR_ERR_INVALID_STORAGE_VOL = 47, 5019 VIR_WAR_NO_STORAGE = 48, 5020 VIR_ERR_NO_STORAGE_POOL = 49, 5021 VIR_ERR_NO_STORAGE_VOL = 50, 5022 VIR_WAR_NO_NODE = 51, 5023 VIR_ERR_INVALID_NODE_DEVICE = 52, 5024 VIR_ERR_NO_NODE_DEVICE = 53, 5025 VIR_ERR_NO_SECURITY_MODEL = 54, 5026 VIR_ERR_OPERATION_INVALID = 55, 5027 VIR_WAR_NO_INTERFACE = 56, 5028 VIR_ERR_NO_INTERFACE = 57, 5029 VIR_ERR_INVALID_INTERFACE = 58, 5030 VIR_ERR_MULTIPLE_INTERFACES = 59, 5031 VIR_WAR_NO_NWFILTER = 60, 5032 VIR_ERR_INVALID_NWFILTER = 61, 5033 VIR_ERR_NO_NWFILTER = 62, 5034 VIR_ERR_BUILD_FIREWALL = 63, 5035 VIR_WAR_NO_SECRET = 64, 5036 VIR_ERR_INVALID_SECRET = 65, 5037 VIR_ERR_NO_SECRET = 66, 5038 VIR_ERR_CONFIG_UNSUPPORTED = 67, 5039 VIR_ERR_OPERATION_TIMEOUT = 68, 5040 VIR_ERR_MIGRATE_PERSIST_FAILED = 69, 5041 VIR_ERR_HOOK_SCRIPT_FAILED = 70, 5042 VIR_ERR_INVALID_DOMAIN_SNAPSHOT = 71, 5043 VIR_ERR_NO_DOMAIN_SNAPSHOT = 72, 5044 VIR_ERR_INVALID_STREAM = 73, 5045 VIR_ERR_ARGUMENT_UNSUPPORTED = 74, 5046 VIR_ERR_STORAGE_PROBE_FAILED = 75, 5047 VIR_ERR_STORAGE_POOL_BUILT = 76, 5048 VIR_ERR_SNAPSHOT_REVERT_RISKY = 77, 5049 VIR_ERR_OPERATION_ABORTED = 78, 5050 VIR_ERR_AUTH_CANCELLED = 79, 5051 VIR_ERR_NO_DOMAIN_METADATA = 80, 5052 VIR_ERR_MIGRATE_UNSAFE = 81, 5053 VIR_ERR_OVERFLOW = 82, 5054 VIR_ERR_BLOCK_COPY_ACTIVE = 83, 5055 VIR_ERR_OPERATION_UNSUPPORTED = 84, 5056 VIR_ERR_SSH = 85, 5057 VIR_ERR_AGENT_UNRESPONSIVE = 86, 5058 VIR_ERR_RESOURCE_BUSY = 87, 5059 VIR_ERR_ACCESS_DENIED = 88, 5060 VIR_ERR_DBUS_SERVICE = 89, 5061 VIR_ERR_STORAGE_VOL_EXIST = 90, 5062 VIR_ERR_CPU_INCOMPATIBLE = 91, 5063 VIR_ERR_XML_INVALID_SCHEMA = 92, 5064 VIR_ERR_MIGRATE_FINISH_OK = 93, 5065 VIR_ERR_AUTH_UNAVAILABLE = 94, 5066 VIR_ERR_NO_SERVER = 95, 5067 VIR_ERR_NO_CLIENT = 96, 5068 VIR_ERR_AGENT_UNSYNCED = 97, 5069 VIR_ERR_LIBSSH = 98, 5070 VIR_ERR_DEVICE_MISSING = 99, 5071 } 5072 alias virErrorNumber = _Anonymous_231; 5073 enum _Anonymous_232 5074 { 5075 VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1, 5076 VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 2, 5077 VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 4, 5078 VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 8, 5079 VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 16, 5080 VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 32, 5081 VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 64, 5082 VIR_CONNECT_LIST_STORAGE_POOLS_FS = 128, 5083 VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 256, 5084 VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 512, 5085 VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1024, 5086 VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 2048, 5087 VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 4096, 5088 VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 8192, 5089 VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 16384, 5090 VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 32768, 5091 VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 65536, 5092 VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 131072, 5093 VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE = 262144, 5094 } 5095 enum _Anonymous_233 5096 { 5097 VIR_NETWORK_EVENT_DEFINED = 0, 5098 VIR_NETWORK_EVENT_UNDEFINED = 1, 5099 VIR_NETWORK_EVENT_STARTED = 2, 5100 VIR_NETWORK_EVENT_STOPPED = 3, 5101 } 5102 enum _Anonymous_234 5103 { 5104 VIR_STREAM_EVENT_READABLE = 1, 5105 VIR_STREAM_EVENT_WRITABLE = 2, 5106 VIR_STREAM_EVENT_ERROR = 4, 5107 VIR_STREAM_EVENT_HANGUP = 8, 5108 } 5109 enum _Anonymous_235 5110 { 5111 VIR_DOMAIN_AFFECT_CURRENT = 0, 5112 VIR_DOMAIN_AFFECT_LIVE = 1, 5113 VIR_DOMAIN_AFFECT_CONFIG = 2, 5114 } 5115 enum _Anonymous_236 5116 { 5117 VIR_NODE_MEMORY_STATS_ALL_CELLS = -1, 5118 } 5119 enum _Anonymous_237 5120 { 5121 VIR_NETWORK_EVENT_ID_LIFECYCLE = 0, 5122 } 5123 enum _Anonymous_238 5124 { 5125 VIR_IP_ADDR_TYPE_IPV4 = 0, 5126 VIR_IP_ADDR_TYPE_IPV6 = 1, 5127 } 5128 enum _Anonymous_239 5129 { 5130 VIR_DOMAIN_NONE = 0, 5131 VIR_DOMAIN_START_PAUSED = 1, 5132 VIR_DOMAIN_START_AUTODESTROY = 2, 5133 VIR_DOMAIN_START_BYPASS_CACHE = 4, 5134 VIR_DOMAIN_START_FORCE_BOOT = 8, 5135 VIR_DOMAIN_START_VALIDATE = 16, 5136 } 5137 alias virErrorFunc = void function(void *userdata, virErrorPtr err); 5138 enum _Anonymous_240 5139 { 5140 VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1, 5141 VIR_STORAGE_VOL_CREATE_REFLINK = 2, 5142 } 5143 virErrorPtr virGetLastError(); 5144 virErrorPtr virSaveLastError(); 5145 void virResetLastError(); 5146 void virResetError(virErrorPtr, ); 5147 void virFreeError(virErrorPtr, ); 5148 const(char)* virGetLastErrorMessage(); 5149 virErrorPtr virConnGetLastError(virConnectPtr, ); 5150 void virConnResetLastError(virConnectPtr, ); 5151 int virCopyLastError(virErrorPtr, ); 5152 enum _Anonymous_241 5153 { 5154 VIR_STORAGE_VOL_DOWNLOAD_SPARSE_STREAM = 1, 5155 } 5156 void virDefaultErrorFunc(virErrorPtr, ); 5157 void virSetErrorFunc(void*, virErrorFunc, ); 5158 void virConnSetErrorFunc(virConnectPtr, void*, virErrorFunc, ); 5159 int virConnCopyLastError(virConnectPtr, virErrorPtr, ); 5160 enum _Anonymous_242 5161 { 5162 VIR_STORAGE_VOL_UPLOAD_SPARSE_STREAM = 1, 5163 } 5164 enum _Anonymous_243 5165 { 5166 VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1, 5167 VIR_STORAGE_VOL_RESIZE_DELTA = 2, 5168 VIR_STORAGE_VOL_RESIZE_SHRINK = 4, 5169 } 5170 enum _Anonymous_244 5171 { 5172 VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE = 0, 5173 VIR_STORAGE_POOL_EVENT_ID_REFRESH = 1, 5174 } 5175 enum _Anonymous_245 5176 { 5177 VIR_CONNECT_RO = 1, 5178 VIR_CONNECT_NO_ALIASES = 2, 5179 } 5180 enum _Anonymous_246 5181 { 5182 VIR_CRED_USERNAME = 1, 5183 VIR_CRED_AUTHNAME = 2, 5184 VIR_CRED_LANGUAGE = 3, 5185 VIR_CRED_CNONCE = 4, 5186 VIR_CRED_PASSPHRASE = 5, 5187 VIR_CRED_ECHOPROMPT = 6, 5188 VIR_CRED_NOECHOPROMPT = 7, 5189 VIR_CRED_REALM = 8, 5190 VIR_CRED_EXTERNAL = 9, 5191 } 5192 enum _Anonymous_247 5193 { 5194 VIR_STORAGE_POOL_EVENT_DEFINED = 0, 5195 VIR_STORAGE_POOL_EVENT_UNDEFINED = 1, 5196 VIR_STORAGE_POOL_EVENT_STARTED = 2, 5197 VIR_STORAGE_POOL_EVENT_STOPPED = 3, 5198 VIR_STORAGE_POOL_EVENT_CREATED = 4, 5199 VIR_STORAGE_POOL_EVENT_DELETED = 5, 5200 } 5201 enum _Anonymous_248 5202 { 5203 VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0, 5204 VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1, 5205 VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2, 5206 VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3, 5207 VIR_DOMAIN_MEMORY_STAT_UNUSED = 4, 5208 VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5, 5209 VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6, 5210 VIR_DOMAIN_MEMORY_STAT_RSS = 7, 5211 VIR_DOMAIN_MEMORY_STAT_USABLE = 8, 5212 VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE = 9, 5213 VIR_DOMAIN_MEMORY_STAT_NR = 10, 5214 } 5215 enum _Anonymous_249 5216 { 5217 VIR_CPU_COMPARE_ERROR = -1, 5218 VIR_CPU_COMPARE_INCOMPATIBLE = 0, 5219 VIR_CPU_COMPARE_IDENTICAL = 1, 5220 VIR_CPU_COMPARE_SUPERSET = 2, 5221 } 5222 enum _Anonymous_250 5223 { 5224 VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = 1, 5225 } 5226 enum _Anonymous_251 5227 { 5228 VIR_DUMP_CRASH = 1, 5229 VIR_DUMP_LIVE = 2, 5230 VIR_DUMP_BYPASS_CACHE = 4, 5231 VIR_DUMP_RESET = 8, 5232 VIR_DUMP_MEMORY_ONLY = 16, 5233 } 5234 enum _Anonymous_252 5235 { 5236 VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = 1, 5237 VIR_CONNECT_BASELINE_CPU_MIGRATABLE = 2, 5238 } 5239 enum _Anonymous_253 5240 { 5241 VIR_DOMAIN_CORE_DUMP_FORMAT_RAW = 0, 5242 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB = 1, 5243 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO = 2, 5244 VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY = 3, 5245 } 5246 enum _Anonymous_254 5247 { 5248 VIR_NODE_ALLOC_PAGES_ADD = 0, 5249 VIR_NODE_ALLOC_PAGES_SET = 1, 5250 } 5251 enum _Anonymous_255 5252 { 5253 VIR_MIGRATE_LIVE = 1, 5254 VIR_MIGRATE_PEER2PEER = 2, 5255 VIR_MIGRATE_TUNNELLED = 4, 5256 VIR_MIGRATE_PERSIST_DEST = 8, 5257 VIR_MIGRATE_UNDEFINE_SOURCE = 16, 5258 VIR_MIGRATE_PAUSED = 32, 5259 VIR_MIGRATE_NON_SHARED_DISK = 64, 5260 VIR_MIGRATE_NON_SHARED_INC = 128, 5261 VIR_MIGRATE_CHANGE_PROTECTION = 256, 5262 VIR_MIGRATE_UNSAFE = 512, 5263 VIR_MIGRATE_OFFLINE = 1024, 5264 VIR_MIGRATE_COMPRESSED = 2048, 5265 VIR_MIGRATE_ABORT_ON_ERROR = 4096, 5266 VIR_MIGRATE_AUTO_CONVERGE = 8192, 5267 VIR_MIGRATE_RDMA_PIN_ALL = 16384, 5268 VIR_MIGRATE_POSTCOPY = 32768, 5269 VIR_MIGRATE_TLS = 65536, 5270 } 5271 enum _Anonymous_256 5272 { 5273 VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, 5274 VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = 1, 5275 VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = 2, 5276 VIR_DOMAIN_SHUTDOWN_INITCTL = 4, 5277 VIR_DOMAIN_SHUTDOWN_SIGNAL = 8, 5278 VIR_DOMAIN_SHUTDOWN_PARAVIRT = 16, 5279 } 5280 enum _Anonymous_257 5281 { 5282 VIR_DOMAIN_REBOOT_DEFAULT = 0, 5283 VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = 1, 5284 VIR_DOMAIN_REBOOT_GUEST_AGENT = 2, 5285 VIR_DOMAIN_REBOOT_INITCTL = 4, 5286 VIR_DOMAIN_REBOOT_SIGNAL = 8, 5287 VIR_DOMAIN_REBOOT_PARAVIRT = 16, 5288 } 5289 enum _Anonymous_258 5290 { 5291 VIR_DOMAIN_DESTROY_DEFAULT = 0, 5292 VIR_DOMAIN_DESTROY_GRACEFUL = 1, 5293 } 5294 enum _Anonymous_259 5295 { 5296 VIR_DOMAIN_SAVE_BYPASS_CACHE = 1, 5297 VIR_DOMAIN_SAVE_RUNNING = 2, 5298 VIR_DOMAIN_SAVE_PAUSED = 4, 5299 } 5300 enum _Anonymous_260 5301 { 5302 VIR_DOMAIN_MEM_CURRENT = 0, 5303 VIR_DOMAIN_MEM_LIVE = 1, 5304 VIR_DOMAIN_MEM_CONFIG = 2, 5305 VIR_DOMAIN_MEM_MAXIMUM = 4, 5306 } 5307 enum VirDomainNumaTuneMem 5308 { 5309 VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, 5310 VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, 5311 VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, 5312 } 5313 enum _Anonymous_263 5314 { 5315 VIR_DOMAIN_XML_SECURE = 1, 5316 VIR_DOMAIN_XML_INACTIVE = 2, 5317 VIR_DOMAIN_XML_UPDATE_CPU = 4, 5318 VIR_DOMAIN_XML_MIGRATABLE = 8, 5319 } 5320 enum _Anonymous_264 5321 { 5322 VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1, 5323 } 5324 enum _Anonymous_265 5325 { 5326 VIR_MEMORY_VIRTUAL = 1, 5327 VIR_MEMORY_PHYSICAL = 2, 5328 } 5329 enum _Anonymous_266 5330 { 5331 VIR_DOMAIN_DEFINE_VALIDATE = 1, 5332 } 5333 enum _Anonymous_267 5334 { 5335 VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1, 5336 VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2, 5337 VIR_DOMAIN_UNDEFINE_NVRAM = 4, 5338 VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = 8, 5339 } 5340 enum _Anonymous_268 5341 { 5342 VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1, 5343 VIR_CONNECT_LIST_DOMAINS_INACTIVE = 2, 5344 VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 4, 5345 VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 8, 5346 VIR_CONNECT_LIST_DOMAINS_RUNNING = 16, 5347 VIR_CONNECT_LIST_DOMAINS_PAUSED = 32, 5348 VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 64, 5349 VIR_CONNECT_LIST_DOMAINS_OTHER = 128, 5350 VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 256, 5351 VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 512, 5352 VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1024, 5353 VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 2048, 5354 VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 4096, 5355 VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 8192, 5356 } 5357 enum _Anonymous_269 5358 { 5359 VIR_VCPU_OFFLINE = 0, 5360 VIR_VCPU_RUNNING = 1, 5361 VIR_VCPU_BLOCKED = 2, 5362 } 5363 enum _Anonymous_270 5364 { 5365 VIR_DOMAIN_VCPU_CURRENT = 0, 5366 VIR_DOMAIN_VCPU_LIVE = 1, 5367 VIR_DOMAIN_VCPU_CONFIG = 2, 5368 VIR_DOMAIN_VCPU_MAXIMUM = 4, 5369 VIR_DOMAIN_VCPU_GUEST = 8, 5370 VIR_DOMAIN_VCPU_HOTPLUGGABLE = 16, 5371 } 5372 enum _Anonymous_271 5373 { 5374 VIR_DOMAIN_DEVICE_MODIFY_CURRENT = 0, 5375 VIR_DOMAIN_DEVICE_MODIFY_LIVE = 1, 5376 VIR_DOMAIN_DEVICE_MODIFY_CONFIG = 2, 5377 VIR_DOMAIN_DEVICE_MODIFY_FORCE = 4, 5378 } 5379 enum _Anonymous_272 5380 { 5381 VIR_DOMAIN_STATS_STATE = 1, 5382 VIR_DOMAIN_STATS_CPU_TOTAL = 2, 5383 VIR_DOMAIN_STATS_BALLOON = 4, 5384 VIR_DOMAIN_STATS_VCPU = 8, 5385 VIR_DOMAIN_STATS_INTERFACE = 16, 5386 VIR_DOMAIN_STATS_BLOCK = 32, 5387 VIR_DOMAIN_STATS_PERF = 64, 5388 } 5389 enum _Anonymous_273 5390 { 5391 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE = 1, 5392 VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE = 2, 5393 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT = 4, 5394 VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = 8, 5395 VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = 16, 5396 VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = 32, 5397 VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = 64, 5398 VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = 128, 5399 VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING = 1073741824, 5400 VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = -2147483648, 5401 } 5402 enum _Anonymous_274 5403 { 5404 VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0, 5405 VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1, 5406 VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2, 5407 VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3, 5408 VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4, 5409 } 5410 enum _Anonymous_275 5411 { 5412 VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1, 5413 VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 2, 5414 } 5415 enum _Anonymous_276 5416 { 5417 VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1, 5418 } 5419 enum _Anonymous_277 5420 { 5421 VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1, 5422 } 5423 enum _Anonymous_278 5424 { 5425 VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 64, 5426 } 5427 enum _Anonymous_279 5428 { 5429 VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1, 5430 VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 2, 5431 VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 4, 5432 VIR_DOMAIN_BLOCK_REBASE_COPY = 8, 5433 VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 16, 5434 VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 32, 5435 VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 64, 5436 } 5437 enum _Anonymous_280 5438 { 5439 VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1, 5440 VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 2, 5441 VIR_DOMAIN_BLOCK_COPY_TRANSIENT_JOB = 4, 5442 } 5443 enum _Anonymous_281 5444 { 5445 VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1, 5446 VIR_DOMAIN_BLOCK_COMMIT_DELETE = 2, 5447 VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 4, 5448 VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 8, 5449 VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 16, 5450 } 5451 enum _Anonymous_282 5452 { 5453 VIR_DOMAIN_DISK_ERROR_NONE = 0, 5454 VIR_DOMAIN_DISK_ERROR_UNSPEC = 1, 5455 VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2, 5456 } 5457 enum _Anonymous_283 5458 { 5459 VIR_KEYCODE_SET_LINUX = 0, 5460 VIR_KEYCODE_SET_XT = 1, 5461 VIR_KEYCODE_SET_ATSET1 = 2, 5462 VIR_KEYCODE_SET_ATSET2 = 3, 5463 VIR_KEYCODE_SET_ATSET3 = 4, 5464 VIR_KEYCODE_SET_OSX = 5, 5465 VIR_KEYCODE_SET_XT_KBD = 6, 5466 VIR_KEYCODE_SET_USB = 7, 5467 VIR_KEYCODE_SET_WIN32 = 8, 5468 VIR_KEYCODE_SET_QNUM = 9, 5469 } 5470 enum _Anonymous_284 5471 { 5472 VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0, 5473 VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1, 5474 VIR_DOMAIN_PROCESS_SIGNAL_INT = 2, 5475 VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3, 5476 VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4, 5477 VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5, 5478 VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6, 5479 VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7, 5480 VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8, 5481 VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9, 5482 VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10, 5483 VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11, 5484 VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12, 5485 VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13, 5486 VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14, 5487 VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15, 5488 VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16, 5489 VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17, 5490 VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18, 5491 VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19, 5492 VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20, 5493 VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21, 5494 VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22, 5495 VIR_DOMAIN_PROCESS_SIGNAL_URG = 23, 5496 VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24, 5497 VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25, 5498 VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26, 5499 VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27, 5500 VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28, 5501 VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29, 5502 VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30, 5503 VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31, 5504 VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32, 5505 VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33, 5506 VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34, 5507 VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35, 5508 VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36, 5509 VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37, 5510 VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38, 5511 VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39, 5512 VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40, 5513 VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41, 5514 VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42, 5515 VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43, 5516 VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44, 5517 VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45, 5518 VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46, 5519 VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47, 5520 VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48, 5521 VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49, 5522 VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50, 5523 VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51, 5524 VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52, 5525 VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53, 5526 VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54, 5527 VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55, 5528 VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56, 5529 VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57, 5530 VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58, 5531 VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59, 5532 VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60, 5533 VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61, 5534 VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62, 5535 VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63, 5536 VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64, 5537 } 5538 enum _Anonymous_285 5539 { 5540 VIR_DOMAIN_EVENT_DEFINED = 0, 5541 VIR_DOMAIN_EVENT_UNDEFINED = 1, 5542 VIR_DOMAIN_EVENT_STARTED = 2, 5543 VIR_DOMAIN_EVENT_SUSPENDED = 3, 5544 VIR_DOMAIN_EVENT_RESUMED = 4, 5545 VIR_DOMAIN_EVENT_STOPPED = 5, 5546 VIR_DOMAIN_EVENT_SHUTDOWN = 6, 5547 VIR_DOMAIN_EVENT_PMSUSPENDED = 7, 5548 VIR_DOMAIN_EVENT_CRASHED = 8, 5549 } 5550 enum _Anonymous_286 5551 { 5552 VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, 5553 VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, 5554 VIR_DOMAIN_EVENT_DEFINED_RENAMED = 2, 5555 VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT = 3, 5556 } 5557 enum _Anonymous_287 5558 { 5559 VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, 5560 VIR_DOMAIN_EVENT_UNDEFINED_RENAMED = 1, 5561 } 5562 enum _Anonymous_288 5563 { 5564 VIR_DOMAIN_EVENT_STARTED_BOOTED = 0, 5565 VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1, 5566 VIR_DOMAIN_EVENT_STARTED_RESTORED = 2, 5567 VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3, 5568 VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4, 5569 } 5570 enum _Anonymous_289 5571 { 5572 VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0, 5573 VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1, 5574 VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2, 5575 VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3, 5576 VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4, 5577 VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5, 5578 VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6, 5579 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY = 7, 5580 VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED = 8, 5581 } 5582 enum _Anonymous_290 5583 { 5584 VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0, 5585 VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1, 5586 VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2, 5587 VIR_DOMAIN_EVENT_RESUMED_POSTCOPY = 3, 5588 } 5589 enum _Anonymous_291 5590 { 5591 VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0, 5592 VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1, 5593 VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2, 5594 VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3, 5595 VIR_DOMAIN_EVENT_STOPPED_SAVED = 4, 5596 VIR_DOMAIN_EVENT_STOPPED_FAILED = 5, 5597 VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6, 5598 } 5599 enum _Anonymous_292 5600 { 5601 VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, 5602 VIR_DOMAIN_EVENT_SHUTDOWN_GUEST = 1, 5603 VIR_DOMAIN_EVENT_SHUTDOWN_HOST = 2, 5604 } 5605 enum _Anonymous_293 5606 { 5607 VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, 5608 VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, 5609 } 5610 enum _Anonymous_294 5611 { 5612 VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, 5613 } 5614 enum _Anonymous_295 5615 { 5616 VIR_DOMAIN_JOB_NONE = 0, 5617 VIR_DOMAIN_JOB_BOUNDED = 1, 5618 VIR_DOMAIN_JOB_UNBOUNDED = 2, 5619 VIR_DOMAIN_JOB_COMPLETED = 3, 5620 VIR_DOMAIN_JOB_FAILED = 4, 5621 VIR_DOMAIN_JOB_CANCELLED = 5, 5622 } 5623 enum _Anonymous_296 5624 { 5625 VIR_DOMAIN_JOB_STATS_COMPLETED = 1, 5626 } 5627 enum _Anonymous_297 5628 { 5629 VIR_DOMAIN_JOB_OPERATION_UNKNOWN = 0, 5630 VIR_DOMAIN_JOB_OPERATION_START = 1, 5631 VIR_DOMAIN_JOB_OPERATION_SAVE = 2, 5632 VIR_DOMAIN_JOB_OPERATION_RESTORE = 3, 5633 VIR_DOMAIN_JOB_OPERATION_MIGRATION_IN = 4, 5634 VIR_DOMAIN_JOB_OPERATION_MIGRATION_OUT = 5, 5635 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT = 6, 5636 VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT = 7, 5637 VIR_DOMAIN_JOB_OPERATION_DUMP = 8, 5638 } 5639 enum _Anonymous_298 5640 { 5641 VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, 5642 VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = 1, 5643 VIR_DOMAIN_EVENT_WATCHDOG_RESET = 2, 5644 VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = 3, 5645 VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = 4, 5646 VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = 5, 5647 VIR_DOMAIN_EVENT_WATCHDOG_INJECTNMI = 6, 5648 } 5649 enum _Anonymous_299 5650 { 5651 VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, 5652 VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = 1, 5653 VIR_DOMAIN_EVENT_IO_ERROR_REPORT = 2, 5654 } 5655 enum _Anonymous_300 5656 { 5657 VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, 5658 VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = 1, 5659 VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = 2, 5660 } 5661 enum _Anonymous_301 5662 { 5663 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = 0, 5664 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = 1, 5665 VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = 2, 5666 } 5667 enum _Anonymous_302 5668 { 5669 VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, 5670 VIR_DOMAIN_BLOCK_JOB_FAILED = 1, 5671 VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, 5672 VIR_DOMAIN_BLOCK_JOB_READY = 3, 5673 } 5674 enum _Anonymous_303 5675 { 5676 VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, 5677 VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, 5678 } 5679 enum _Anonymous_304 5680 { 5681 VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, 5682 VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE = 1, 5683 } 5684 enum _Anonymous_305 5685 { 5686 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_CONNECTED = 1, 5687 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_DISCONNECTED = 2, 5688 } 5689 enum _Anonymous_306 5690 { 5691 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_UNKNOWN = 0, 5692 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED = 1, 5693 VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL = 2, 5694 } 5695 enum _Anonymous_307 5696 { 5697 VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, 5698 VIR_DOMAIN_EVENT_ID_REBOOT = 1, 5699 VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2, 5700 VIR_DOMAIN_EVENT_ID_WATCHDOG = 3, 5701 VIR_DOMAIN_EVENT_ID_IO_ERROR = 4, 5702 VIR_DOMAIN_EVENT_ID_GRAPHICS = 5, 5703 VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6, 5704 VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7, 5705 VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8, 5706 VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9, 5707 VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10, 5708 VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11, 5709 VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12, 5710 VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13, 5711 VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14, 5712 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15, 5713 VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16, 5714 VIR_DOMAIN_EVENT_ID_TUNABLE = 17, 5715 VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18, 5716 VIR_DOMAIN_EVENT_ID_DEVICE_ADDED = 19, 5717 VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20, 5718 VIR_DOMAIN_EVENT_ID_JOB_COMPLETED = 21, 5719 VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED = 22, 5720 VIR_DOMAIN_EVENT_ID_METADATA_CHANGE = 23, 5721 VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD = 24, 5722 } 5723 enum _Anonymous_308 5724 { 5725 VIR_DOMAIN_CONSOLE_FORCE = 1, 5726 VIR_DOMAIN_CONSOLE_SAFE = 2, 5727 } 5728 enum _Anonymous_309 5729 { 5730 VIR_DOMAIN_CHANNEL_FORCE = 1, 5731 } 5732 enum _Anonymous_310 5733 { 5734 VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = 1, 5735 } 5736 enum _Anonymous_311 5737 { 5738 VIR_DOMAIN_TIME_SYNC = 1, 5739 } 5740 enum _Anonymous_312 5741 { 5742 VIR_DOMAIN_SCHED_FIELD_INT = 1, 5743 VIR_DOMAIN_SCHED_FIELD_UINT = 2, 5744 VIR_DOMAIN_SCHED_FIELD_LLONG = 3, 5745 VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, 5746 VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, 5747 VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6, 5748 } 5749 enum _Anonymous_313 5750 { 5751 VIR_DOMAIN_BLKIO_PARAM_INT = 1, 5752 VIR_DOMAIN_BLKIO_PARAM_UINT = 2, 5753 VIR_DOMAIN_BLKIO_PARAM_LLONG = 3, 5754 VIR_DOMAIN_BLKIO_PARAM_ULLONG = 4, 5755 VIR_DOMAIN_BLKIO_PARAM_DOUBLE = 5, 5756 VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = 6, 5757 } 5758 enum _Anonymous_314 5759 { 5760 VIR_DOMAIN_MEMORY_PARAM_INT = 1, 5761 VIR_DOMAIN_MEMORY_PARAM_UINT = 2, 5762 VIR_DOMAIN_MEMORY_PARAM_LLONG = 3, 5763 VIR_DOMAIN_MEMORY_PARAM_ULLONG = 4, 5764 VIR_DOMAIN_MEMORY_PARAM_DOUBLE = 5, 5765 VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = 6, 5766 } 5767 enum _Anonymous_315 5768 { 5769 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0, 5770 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1, 5771 VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP = 2, 5772 } 5773 enum _Anonymous_316 5774 { 5775 VIR_DOMAIN_PASSWORD_ENCRYPTED = 1, 5776 } 5777 enum _Anonymous_317 5778 { 5779 VIR_DOMAIN_LIFECYCLE_POWEROFF = 0, 5780 VIR_DOMAIN_LIFECYCLE_REBOOT = 1, 5781 VIR_DOMAIN_LIFECYCLE_CRASH = 2, 5782 } 5783 enum _Anonymous_318 5784 { 5785 VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY = 0, 5786 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART = 1, 5787 VIR_DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME = 2, 5788 VIR_DOMAIN_LIFECYCLE_ACTION_PRESERVE = 3, 5789 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY = 4, 5790 VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART = 5, 5791 } 5792 } 5793 5794