├── .gitignore ├── LICENSE ├── domain.lua ├── hostconnection.lua ├── libvirt-domain-snapshot.lua ├── libvirt-domain.lua ├── libvirt-event.lua ├── libvirt-host.lua ├── libvirt-interface.lua ├── libvirt-network.lua ├── libvirt-nodedev.lua ├── libvirt-nwfilter.lua ├── libvirt-secret.lua ├── libvirt-storage.lua ├── libvirt-stream.lua ├── libvirt.lua ├── testy ├── get_domain_status.lua ├── test_hostconnection.lua ├── test_libvirt.lua └── test_reboot.lua └── virterror.lua /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Lua sources 2 | luac.out 3 | 4 | # luarocks build files 5 | *.src.rock 6 | *.zip 7 | *.tar.gz 8 | 9 | # Object files 10 | *.o 11 | *.os 12 | *.ko 13 | *.obj 14 | *.elf 15 | 16 | # Precompiled Headers 17 | *.gch 18 | *.pch 19 | 20 | # Libraries 21 | *.lib 22 | *.a 23 | *.la 24 | *.lo 25 | *.def 26 | *.exp 27 | 28 | # Shared objects (inc. Windows DLLs) 29 | *.dll 30 | *.so 31 | *.so.* 32 | *.dylib 33 | 34 | # Executables 35 | *.exe 36 | *.out 37 | *.app 38 | *.i*86 39 | *.x86_64 40 | *.hex 41 | 42 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 William Adams 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /domain.lua: -------------------------------------------------------------------------------- 1 | -- domain.lua 2 | local ffi = require("ffi") 3 | local bit = require("bit") 4 | local bor = bit.bor; 5 | local band = bit.band; 6 | 7 | local libvirt, err = require("libvirt") 8 | 9 | 10 | local Domain = {} 11 | setmetatable(Domain, { 12 | __call = function(self, ...) 13 | return self:open(...) 14 | end, 15 | }) 16 | 17 | local Domain_mt = { 18 | __index = Domain 19 | } 20 | 21 | -- for destructor 22 | -- virDomainFree 23 | -- 24 | 25 | 26 | 27 | function Domain.init(self, rawhandle) 28 | local obj = { 29 | Handle = rawhandle -- should be stored in a smart pointer 30 | } 31 | setmetatable(obj, Domain_mt) 32 | 33 | obj:getName(); 34 | 35 | return obj; 36 | end 37 | 38 | 39 | function Domain.open(self, connPtr, identifier) 40 | -- lookup a domain based on the identifier type 41 | local domPtr = nil; 42 | 43 | if (type(identifier) == 'number') then 44 | domPtr = libvirt.Lib.virDomainLookupByID(connPtr,identifier); 45 | elseif (type(identifier) == "string") then 46 | domPtr = libvirt.Lib.virDomainLookupByName(connPtr,identifier); 47 | end 48 | 49 | if domPtr ~= nil then 50 | return Domain:init(domPtr); 51 | end 52 | 53 | return nil; 54 | end 55 | 56 | 57 | --[[ 58 | Informatics 59 | --]] 60 | function Domain.getCPUState(self, cpuNum) 61 | --[[ 62 | local err = libvirt.Lib.virDomainGetCPUStats(self.Handle, 63 | virTypedParameterPtr params, 64 | unsigned int nparams, 65 | int start_cpu, 66 | unsigned int ncpus, 67 | unsigned int flags); 68 | --]] 69 | end 70 | 71 | -- 72 | -- iterator over cpu states for all cpus in the domain 73 | -- 74 | function Domain.cpuStates(self) 75 | local info = self:getInfo(); 76 | local idx = -1; 77 | 78 | local function closure() 79 | idx = idx+1; 80 | if not info or idx >= info.nrVirtCpu then 81 | return nil; 82 | end 83 | 84 | return self:getCPUState(idx) 85 | end 86 | 87 | return closure 88 | end 89 | 90 | function Domain.getHostName(self, flags) 91 | if self.hostName then 92 | return self.hostName 93 | end 94 | 95 | flags = flags or 0 96 | local localvalue = libvirt.Lib.virDomainGetHostname(self.Handle, flags); 97 | if localvalue ~= nil then 98 | self.hostName = ffi.string(localvalue) 99 | end 100 | 101 | return self.hostName; 102 | end 103 | 104 | function Domain.getInfo(self) 105 | local info = ffi.new("virDomainInfo") 106 | local err = libvirt.Lib.virDomainGetInfo(self.Handle, info) 107 | if err < 0 then 108 | return nil 109 | end 110 | 111 | return { 112 | state = info.state; 113 | maxMem = info.maxMem; 114 | memory = info.memory; 115 | nrVirtCpu = info.nrVirtCpu; 116 | cpuTime = info.cpuTime; 117 | } 118 | end 119 | 120 | --[[ 121 | one of 122 | virDomainState 123 | --]] 124 | function Domain.getState(self, flags) 125 | flags = flags or 0 126 | local state = ffi.new("int[1]") 127 | local reason = ffi.new("int[1]") 128 | 129 | local err = libvirt.Lib.virDomainGetState(self.Handle,state,reason,flags); 130 | 131 | if err ~= 0 then 132 | return false 133 | end 134 | 135 | return state[0], reason[0]; 136 | end 137 | 138 | function Domain.getName(self) 139 | if self.name then 140 | return self.name 141 | end 142 | 143 | local localname = libvirt.Lib.virDomainGetName(self.Handle); 144 | if localname ~= nil then 145 | self.name = ffi.string(localname) 146 | end 147 | 148 | return self.name; 149 | end 150 | 151 | function Domain.getOSType(self) 152 | if self.osType then 153 | return self.osType 154 | end 155 | 156 | local localvalue = libvirt.Lib.virDomainGetOSType(self.Handle); 157 | if localvalue ~= nil then 158 | self.osType = ffi.string(localvalue) 159 | end 160 | 161 | return self.osType; 162 | end 163 | 164 | function Domain.getUUIDString(self) 165 | if self.uuidString then 166 | return self.uuidString 167 | end 168 | 169 | local buff = ffi.new("char[256]") 170 | local err = libvirt.Lib.virDomainGetUUIDString(self.Handle, buff); 171 | if err ~= 0 then 172 | return false; 173 | end 174 | self.uuidString = ffi.string(buff) 175 | 176 | return self.uuidString; 177 | end 178 | 179 | function Domain.getXMLDesc(self, flags) 180 | 181 | if self.xmlDesc then 182 | return self.xmlDesc 183 | end 184 | 185 | flags = flags or 0 186 | local localvalue = libvirt.Lib.virDomainGetXMLDesc(self.Handle, flags); 187 | if localvalue ~= nil then 188 | self.xmlDesc = ffi.string(localvalue) 189 | end 190 | 191 | return self.xmlDesc; 192 | end 193 | 194 | 195 | --[[ 196 | unsigned int virDomainGetID (virDomainPtr domain); 197 | int virDomainGetUUID (virDomainPtr domain, 198 | unsigned char *uuid); 199 | unsigned long virDomainGetMaxMemory (virDomainPtr domain); 200 | int virDomainSetMaxMemory (virDomainPtr domain, 201 | unsigned long memory); 202 | int virDomainSetMemory (virDomainPtr domain, 203 | unsigned long memory); 204 | int virDomainSetMemoryFlags (virDomainPtr domain, 205 | unsigned long memory, 206 | unsigned int flags); 207 | int virDomainSetMemoryStatsPeriod (virDomainPtr domain, 208 | int period, 209 | unsigned int flags); 210 | int virDomainGetMaxVcpus (virDomainPtr domain); 211 | int virDomainGetSecurityLabel (virDomainPtr domain, 212 | virSecurityLabelPtr seclabel); 213 | char * virDomainGetHostname (virDomainPtr domain, 214 | unsigned int flags); 215 | int virDomainGetSecurityLabelList (virDomainPtr domain, 216 | virSecurityLabelPtr* seclabels); 217 | --]] 218 | --[[ 219 | stats: virDomainStatsTypes 220 | flags: virConnectGetAllDomainStatsFlags 221 | 222 | Returns: count of staistics structures on success, -1 on error 223 | 224 | 225 | struct _virTypedParameter { 226 | char field[VIR_TYPED_PARAM_FIELD_LENGTH]; /* parameter name */ 227 | int type; /* parameter type, virTypedParameterType */ 228 | union { 229 | int i; /* type is INT */ 230 | unsigned int ui; /* type is UINT */ 231 | long long int l; /* type is LLONG */ 232 | unsigned long long int ul; /* type is ULLONG */ 233 | double d; /* type is DOUBLE */ 234 | char b; /* type is BOOLEAN */ 235 | char *s; /* type is STRING, may not be NULL */ 236 | } value; /* parameter value */ 237 | }; 238 | 239 | typedef enum { 240 | VIR_TYPED_PARAM_INT = 1, /* integer case */ 241 | VIR_TYPED_PARAM_UINT = 2, /* unsigned integer case */ 242 | VIR_TYPED_PARAM_LLONG = 3, /* long long case */ 243 | VIR_TYPED_PARAM_ULLONG = 4, /* unsigned long long case */ 244 | VIR_TYPED_PARAM_DOUBLE = 5, /* double case */ 245 | VIR_TYPED_PARAM_BOOLEAN = 6, /* boolean(character) case */ 246 | VIR_TYPED_PARAM_STRING = 7, /* string case */ 247 | 248 | VIR_TYPED_PARAM_LAST 249 | } virTypedParameterType; 250 | 251 | --]] 252 | local function valueFromParameter(param) 253 | if param.type == ffi.C.VIR_TYPED_PARAM_INT then 254 | return param.value.i; 255 | elseif param.type == ffi.C.VIR_TYPED_PARAM_UINT then 256 | return param.value.ui; 257 | elseif param.type == ffi.C.VIR_TYPED_PARAM_LLONG then 258 | return param.value.l; 259 | elseif param.type == ffi.C.VIR_TYPED_PARAM_ULLONG then 260 | return param.value.ul; 261 | elseif param.type == ffi.C.VIR_TYPED_PARAM_DOUBLE then 262 | return param.value.d; 263 | elseif param.type == ffi.C.VIR_TYPED_PARAM_BOOLEAN then 264 | return param.value.b ~= 0; 265 | elseif param.type == ffi.C.VIR_TYPED_PARAM_STRING then 266 | return ffi.string(param.value.s); 267 | end 268 | 269 | return nil 270 | end 271 | 272 | local function typedParameterPtrToTable(nparams, params) 273 | local res = {} 274 | 275 | for idx=0, nparams-1 do 276 | local item = { 277 | [ffi.string(params[idx].field)] = valueFromParameter(params[idx]); 278 | } 279 | 280 | table.insert(res, item) 281 | end 282 | 283 | return res; 284 | end 285 | 286 | function Domain.stats(self, whichstats, flags) 287 | --flags = flags or ffi.C.VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER; 288 | flags = flags or 0 289 | 290 | whichstats = whichstats or bor( 291 | ffi.C.VIR_DOMAIN_STATS_STATE, 292 | ffi.C.VIR_DOMAIN_STATS_CPU_TOTAL, 293 | ffi.C.VIR_DOMAIN_STATS_BALLOON, 294 | ffi.C.VIR_DOMAIN_STATS_VCPU, 295 | ffi.C.VIR_DOMAIN_STATS_INTERFACE, 296 | ffi.C.VIR_DOMAIN_STATS_BLOCK 297 | ); 298 | 299 | -- a list of a single domain 300 | local doms = ffi.new("virDomainPtr[2]"); 301 | doms[0] = self.Handle; 302 | doms[1] = nil; 303 | local retStats = ffi.new("virDomainStatsRecordPtr *[1]") 304 | local numStats = libvirt.Lib.virDomainListGetStats(doms, 305 | whichstats, 306 | retStats, 307 | flags); 308 | 309 | local idx = -1; 310 | local function closure() 311 | idx = idx + 1; 312 | if idx >= numStats then 313 | return nil; 314 | end 315 | 316 | -- get out the stats 317 | -- turn them into a table 318 | -- return to the caller 319 | return typedParameterPtrToTable(retStats[0][idx].nparams, retStats[0][idx].params); 320 | end 321 | 322 | return closure 323 | end 324 | 325 | 326 | --[[ 327 | Domain management operations 328 | --]] 329 | function Domain.destroy(self) 330 | local err = libvirt.Lib.virDomainDestroy(self.Handle); 331 | 332 | return err; 333 | end 334 | 335 | 336 | function Domain.reboot(self, flags) 337 | flags = flags or 0 338 | local err = libvirt.Lib.virDomainReboot(self.Handle,flags); 339 | 340 | return err; 341 | end 342 | 343 | -- do a hard reset, like pressing the hardware reset 344 | -- button on a physical machine 345 | function Domain.reset(self, flags) 346 | flags = flags or 0 347 | local err = libvirt.Lib.virDomainReset(self.Handle, flags) 348 | end 349 | 350 | -- shutdown : Will shutdown the domain by sending RST signal 351 | -- to processes. 352 | function Domain.shutdown(self, flags) 353 | flags = flags or 0 354 | local err = libvirt.Lib.virDomainShutdown(self.Handle) 355 | --local err = libvirt.Lib.virDomainShutdownFlags(self.Handle, flags) 356 | 357 | return err; 358 | end 359 | 360 | function Domain.suspend(self) 361 | local err = libvirt.Lib.virDomainSuspend(self.Handle); 362 | 363 | return err; 364 | end 365 | 366 | function Domain.resume(self) 367 | local err = libvirt.Lib.virDomainResume(self.Handle); 368 | 369 | return err; 370 | end 371 | 372 | -- will save the memory state of a domain to a specified 373 | -- file. It will appear as 'not running' 374 | -- MUST use restore() to get it running again 375 | function Domain.save(self, tofilename, flags) 376 | flags = flags or 0 377 | local err = libvirt.Lib.virDomainSaveFlags(self.Handle,tofilename, nil, flags); 378 | 379 | return image; 380 | end 381 | 382 | function Domain.restore(self, fromfilename) 383 | local err = libvirt.Lib.virDomainRestore(self.Handle,fromimage); 384 | return err; 385 | end 386 | 387 | --[[ 388 | 389 | 390 | 391 | int virDomainRestoreFlags (virConnectPtr conn, 392 | const char *from, 393 | const char *dxml, 394 | unsigned int flags); 395 | char * virDomainScreenshot (virDomainPtr domain, 396 | virStreamPtr stream, 397 | unsigned int screen, 398 | unsigned int flags); 399 | 400 | int virDomainGetCPUStats(virDomainPtr domain, 401 | virTypedParameterPtr params, 402 | unsigned int nparams, 403 | int start_cpu, 404 | unsigned int ncpus, 405 | unsigned int flags); 406 | 407 | int virDomainGetControlInfo (virDomainPtr domain, 408 | virDomainControlInfoPtr info, 409 | unsigned int flags); 410 | 411 | 412 | char * virDomainGetSchedulerType(virDomainPtr domain, 413 | int *nparams); 414 | 415 | --]] 416 | 417 | return Domain 418 | -------------------------------------------------------------------------------- /hostconnection.lua: -------------------------------------------------------------------------------- 1 | -- hostconnection.lua 2 | local ffi = require("ffi") 3 | local libvirt, err = require("libvirt") 4 | 5 | 6 | if (not libvirt) then 7 | print(err); 8 | return nil; 9 | end 10 | 11 | 12 | local Connection = {} 13 | setmetatable(Connection, { 14 | __call = function(self, ...) 15 | return self:create(...) 16 | end, 17 | }) 18 | 19 | local Connection_mt = { 20 | __index = Connection 21 | } 22 | 23 | function Connection.init(self, rawhandle) 24 | local obj = { 25 | Handle = rawhandle -- should be stored in a smart pointer 26 | } 27 | setmetatable(obj, Connection_mt) 28 | 29 | obj:getHostName(); 30 | obj:getURI(); 31 | 32 | return obj; 33 | end 34 | 35 | 36 | function Connection.create(self, driveruri) 37 | print("Connection.create: ", driveruri) 38 | 39 | driveruri = driveruri or "test:///default"; 40 | 41 | --local conn = libvirt.Lib.virConnectOpenReadOnly(driveruri); 42 | local conn = libvirt.Lib.virConnectOpen(driveruri); 43 | if not conn == nil then 44 | return nil 45 | end 46 | 47 | return Connection:init(conn) 48 | end 49 | 50 | 51 | --[[ 52 | Attributes of the connection 53 | --]] 54 | function Connection.getHostName(self) 55 | return ffi.string(libvirt.Lib.virConnectGetHostname(self.Handle)); 56 | end 57 | 58 | 59 | 60 | function Connection.getCapabilities(self) 61 | local capsPtr = libvirt.Lib.virConnectGetCapabilities (self.Handle); 62 | local capsStr = nil; 63 | 64 | if capsPtr ~= nil then 65 | capsStr = ffi.string(capsPtr); 66 | --free(caps); 67 | end 68 | 69 | return capsStr; 70 | end 71 | 72 | function Connection.getLibraryVersion(self) 73 | if self.libraryVersion then 74 | return self.libraryVersion 75 | end 76 | 77 | local libVer = ffi.new("unsigned long[1]"); 78 | local err = libvirt.Lib.virConnectGetLibVersion(self.Handle, libVer) 79 | if err ~= 0 then 80 | return false, err 81 | end 82 | 83 | local major = tonumber(libVer[0] / 1000000); 84 | local minor = tonumber((libVer[0]-(major*1000000))/1000); 85 | local release = tonumber(libVer[0]-(major*1000000)-(minor*1000)); 86 | 87 | self.libraryVersion = {major=major, minor=minor, release=release} 88 | 89 | return self.libraryVersion 90 | end 91 | 92 | 93 | function Connection.getURI(self) 94 | if self.uri then 95 | return self.uri 96 | end 97 | 98 | local localvalue = libvirt.Lib.virConnectGetURI(self.Handle); 99 | if localvalue ~= nil then 100 | self.uri = ffi.string(localvalue) 101 | end 102 | 103 | return self.uri; 104 | end 105 | 106 | function Connection.getNumberOfDomains(self) 107 | return libvirt.Lib.virConnectNumOfDomains(self.Handle); 108 | end 109 | 110 | function Connection.isAlive(self) 111 | return libvirt.Lib.virConnectIsAlive(self.Handle) == 1; 112 | end 113 | 114 | function Connection.isSecure(self) 115 | return libvirt.Lib.virConnectIsSecure(self.Handle) == 1; 116 | end 117 | 118 | function Connection.isEncrypted(self) 119 | return libvirt.Lib.virConnectIsEncrypted(self.Handle) == 1; 120 | end 121 | 122 | --[[ 123 | Iterators 124 | --]] 125 | -- an iterator of cpu models for the architecture 126 | function Connection.cpuModelNames(self, arch) 127 | arch = arch or "x86_64" 128 | 129 | local modelsArray = ffi.new(ffi.typeof("char **[1]")) 130 | local nModels = libvirt.Lib.virConnectGetCPUModelNames(self.Handle,arch,modelsArray,0); 131 | 132 | local idx = -1; 133 | local function closure() 134 | idx = idx + 1; 135 | if idx >= nModels then 136 | return nil; 137 | end 138 | 139 | return ffi.string(modelsArray[0][idx]) 140 | end 141 | 142 | return closure; 143 | end 144 | 145 | function Connection.domainIds(self) 146 | local maxids = 256 147 | local ids = ffi.new('int[256]'); 148 | local numIds = libvirt.Lib.virConnectListDomains(self.Handle, 149 | ids, 150 | maxids); 151 | 152 | print("Connection.domainIds: ", numIds) 153 | local idx = -1; 154 | local function closure() 155 | idx = idx + 1; 156 | if idx >= numIds then 157 | return nil; 158 | end 159 | 160 | return ids[idx]; 161 | end 162 | 163 | return closure 164 | end 165 | 166 | --[[ 167 | Domain management 168 | --]] 169 | 170 | function Connection.getDomain(self, identifier) 171 | local domPtr = libvirt.Lib.virDomainLookupByID(self.Handle,domid); 172 | 173 | -- really we want to return a domain object 174 | return domPtr; 175 | end 176 | 177 | 178 | --[[ 179 | int virNodeGetMemoryParameters(virConnectPtr conn, 180 | int virNodeSetMemoryParameters(virConnectPtr conn, 181 | int virNodeGetCPUMap(virConnectPtr conn, 182 | 183 | int virConnectRef (virConnectPtr conn); 184 | int virConnectClose (virConnectPtr conn); 185 | const char * virConnectGetType (virConnectPtr conn); 186 | int virConnectGetVersion (virConnectPtr conn, 187 | unsigned long *hvVer); 188 | char * virConnectGetSysinfo (virConnectPtr conn, 189 | unsigned int flags); 190 | 191 | int virConnectSetKeepAlive(virConnectPtr conn, 192 | int interval, 193 | unsigned int count); 194 | int virConnectRegisterCloseCallback(virConnectPtr conn, 195 | virConnectCloseFunc cb, 196 | void *opaque, 197 | virFreeCallback freecb); 198 | int virConnectUnregisterCloseCallback(virConnectPtr conn, 199 | virConnectCloseFunc cb); 200 | int virConnectGetMaxVcpus (virConnectPtr conn, 201 | const char *type); 202 | char * virConnectGetCapabilities (virConnectPtr conn); 203 | 204 | 205 | int virConnectCompareCPU(virConnectPtr conn, 206 | const char *xmlDesc, 207 | unsigned int flags); 208 | 209 | int virNodeGetFreePages(virConnectPtr conn, 210 | unsigned int npages, 211 | unsigned int *pages, 212 | int startcell, 213 | unsigned int cellcount, 214 | unsigned long long *counts, 215 | unsigned int flags); 216 | 217 | int virNodeAllocPages(virConnectPtr conn, 218 | unsigned int npages, 219 | unsigned int *pageSizes, 220 | unsigned long long *pageCounts, 221 | int startCell, 222 | unsigned int cellCount, 223 | unsigned int flags); 224 | 225 | 226 | 227 | int virNodeGetInfo (virConnectPtr conn, 228 | virNodeInfoPtr info); 229 | --]] 230 | 231 | 232 | return Connection 233 | -------------------------------------------------------------------------------- /libvirt-domain-snapshot.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | local bit = require("bit") 3 | 4 | local exports = {} 5 | 6 | ffi.cdef[[ 7 | 8 | typedef struct _virDomainSnapshot virDomainSnapshot; 9 | typedef virDomainSnapshot *virDomainSnapshotPtr; 10 | 11 | const char *virDomainSnapshotGetName(virDomainSnapshotPtr snapshot); 12 | virDomainPtr virDomainSnapshotGetDomain(virDomainSnapshotPtr snapshot); 13 | virConnectPtr virDomainSnapshotGetConnect(virDomainSnapshotPtr snapshot); 14 | 15 | typedef enum { 16 | VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = (1 << 0), /* Restore or alter 17 | metadata */ 18 | VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = (1 << 1), /* With redefine, make 19 | snapshot current */ 20 | VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = (1 << 2), /* Make snapshot without 21 | remembering it */ 22 | VIR_DOMAIN_SNAPSHOT_CREATE_HALT = (1 << 3), /* Stop running guest 23 | after snapshot */ 24 | VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = (1 << 4), /* disk snapshot, not 25 | system checkpoint */ 26 | VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = (1 << 5), /* reuse any existing 27 | external files */ 28 | VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = (1 << 6), /* use guest agent to 29 | quiesce all mounted 30 | file systems within 31 | the domain */ 32 | VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = (1 << 7), /* atomically avoid 33 | partial changes */ 34 | VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = (1 << 8), /* create the snapshot 35 | while the guest is 36 | running */ 37 | } virDomainSnapshotCreateFlags; 38 | 39 | /* Take a snapshot of the current VM state */ 40 | virDomainSnapshotPtr virDomainSnapshotCreateXML(virDomainPtr domain, 41 | const char *xmlDesc, 42 | unsigned int flags); 43 | 44 | /* Dump the XML of a snapshot */ 45 | char *virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot, 46 | unsigned int flags); 47 | ]] 48 | 49 | ffi.cdef[[ 50 | typedef enum { 51 | VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = (1 << 0), /* Filter by snapshots 52 | with no parents, when 53 | listing a domain */ 54 | VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = (1 << 0), /* List all descendants, 55 | not just children, when 56 | listing a snapshot */ 57 | 58 | /* For historical reasons, groups do not use contiguous bits. */ 59 | 60 | VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = (1 << 2), /* Filter by snapshots 61 | with no children */ 62 | VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = (1 << 3), /* Filter by snapshots 63 | that have children */ 64 | 65 | VIR_DOMAIN_SNAPSHOT_LIST_METADATA = (1 << 1), /* Filter by snapshots 66 | which have metadata */ 67 | VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = (1 << 4), /* Filter by snapshots 68 | with no metadata */ 69 | 70 | VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = (1 << 5), /* Filter by snapshots 71 | taken while guest was 72 | shut off */ 73 | VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = (1 << 6), /* Filter by snapshots 74 | taken while guest was 75 | active, and with 76 | memory state */ 77 | VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = (1 << 7), /* Filter by snapshots 78 | taken while guest was 79 | active, but without 80 | memory state */ 81 | 82 | VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = (1 << 8), /* Filter by snapshots 83 | stored internal to 84 | disk images */ 85 | VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = (1 << 9), /* Filter by snapshots 86 | that use files external 87 | to disk images */ 88 | } virDomainSnapshotListFlags; 89 | ]] 90 | 91 | ffi.cdef[[ 92 | /* Return the number of snapshots for this domain */ 93 | int virDomainSnapshotNum(virDomainPtr domain, unsigned int flags); 94 | 95 | /* Get the names of all snapshots for this domain */ 96 | int virDomainSnapshotListNames(virDomainPtr domain, char **names, int nameslen, 97 | unsigned int flags); 98 | 99 | /* Get all snapshot objects for this domain */ 100 | int virDomainListAllSnapshots(virDomainPtr domain, 101 | virDomainSnapshotPtr **snaps, 102 | unsigned int flags); 103 | 104 | /* Return the number of child snapshots for this snapshot */ 105 | int virDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot, 106 | unsigned int flags); 107 | 108 | /* Get the names of all child snapshots for this snapshot */ 109 | int virDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot, 110 | char **names, int nameslen, 111 | unsigned int flags); 112 | 113 | /* Get all snapshot object children for this snapshot */ 114 | int virDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot, 115 | virDomainSnapshotPtr **snaps, 116 | unsigned int flags); 117 | 118 | /* Get a handle to a named snapshot */ 119 | virDomainSnapshotPtr virDomainSnapshotLookupByName(virDomainPtr domain, 120 | const char *name, 121 | unsigned int flags); 122 | 123 | /* Check whether a domain has a snapshot which is currently used */ 124 | int virDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags); 125 | 126 | /* Get a handle to the current snapshot */ 127 | virDomainSnapshotPtr virDomainSnapshotCurrent(virDomainPtr domain, 128 | unsigned int flags); 129 | 130 | /* Get a handle to the parent snapshot, if one exists */ 131 | virDomainSnapshotPtr virDomainSnapshotGetParent(virDomainSnapshotPtr snapshot, 132 | unsigned int flags); 133 | 134 | /* Determine if a snapshot is the current snapshot of its domain. */ 135 | int virDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, 136 | unsigned int flags); 137 | 138 | /* Determine if a snapshot has associated libvirt metadata that would 139 | * prevent the deletion of its domain. */ 140 | int virDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot, 141 | unsigned int flags); 142 | ]] 143 | 144 | ffi.cdef[[ 145 | typedef enum { 146 | VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1 << 0, /* Run after revert */ 147 | VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 1 << 1, /* Pause after revert */ 148 | VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 1 << 2, /* Allow risky reverts */ 149 | } virDomainSnapshotRevertFlags; 150 | 151 | /* Revert the domain to a point-in-time snapshot. The 152 | * state of the guest after this call will be the state 153 | * of the guest when the snapshot in question was taken 154 | */ 155 | int virDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, 156 | unsigned int flags); 157 | 158 | /* Delete a snapshot */ 159 | typedef enum { 160 | VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = (1 << 0), /* Also delete children */ 161 | VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = (1 << 1), /* Delete just metadata */ 162 | VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = (1 << 2), /* Delete just children */ 163 | } virDomainSnapshotDeleteFlags; 164 | 165 | int virDomainSnapshotDelete(virDomainSnapshotPtr snapshot, 166 | unsigned int flags); 167 | 168 | int virDomainSnapshotRef(virDomainSnapshotPtr snapshot); 169 | int virDomainSnapshotFree(virDomainSnapshotPtr snapshot); 170 | ]] 171 | 172 | return exports; 173 | -------------------------------------------------------------------------------- /libvirt-domain.lua: -------------------------------------------------------------------------------- 1 | --[[ 2 | /* 3 | * libvirt-domain.h 4 | * Summary: APIs for management of domains 5 | * Description: Provides APIs for the management of domains 6 | * Author: Daniel Veillard 7 | * 8 | * Copyright (C) 2006-2015 Red Hat, Inc. 9 | * 10 | * This library is free software; you can redistribute it and/or 11 | * modify it under the terms of the GNU Lesser General Public 12 | * License as published by the Free Software Foundation; either 13 | * version 2.1 of the License, or (at your option) any later version. 14 | * 15 | * This library is distributed in the hope that it will be useful, 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 | * Lesser General Public License for more details. 19 | * 20 | * You should have received a copy of the GNU Lesser General Public 21 | * License along with this library. If not, see 22 | * . 23 | */ 24 | --]] 25 | 26 | local ffi = require("ffi") 27 | local bit = require("bit") 28 | local band = bit.band 29 | local bor = bit.bor 30 | local bnot = bit.bnot 31 | 32 | 33 | local export = {} 34 | 35 | 36 | ffi.cdef[[ 37 | 38 | typedef struct _virDomain virDomain; 39 | 40 | typedef virDomain *virDomainPtr; 41 | 42 | 43 | typedef enum { 44 | VIR_DOMAIN_NOSTATE = 0, /* no state */ 45 | VIR_DOMAIN_RUNNING = 1, /* the domain is running */ 46 | VIR_DOMAIN_BLOCKED = 2, /* the domain is blocked on resource */ 47 | VIR_DOMAIN_PAUSED = 3, /* the domain is paused by user */ 48 | VIR_DOMAIN_SHUTDOWN= 4, /* the domain is being shut down */ 49 | VIR_DOMAIN_SHUTOFF = 5, /* the domain is shut off */ 50 | VIR_DOMAIN_CRASHED = 6, /* the domain is crashed */ 51 | VIR_DOMAIN_PMSUSPENDED = 7, /* the domain is suspended by guest 52 | power management */ 53 | 54 | 55 | VIR_DOMAIN_LAST 56 | 57 | } virDomainState; 58 | 59 | typedef enum { 60 | VIR_DOMAIN_NOSTATE_UNKNOWN = 0, 61 | 62 | VIR_DOMAIN_NOSTATE_LAST 63 | 64 | } virDomainNostateReason; 65 | 66 | typedef enum { 67 | VIR_DOMAIN_RUNNING_UNKNOWN = 0, 68 | VIR_DOMAIN_RUNNING_BOOTED = 1, /* normal startup from boot */ 69 | VIR_DOMAIN_RUNNING_MIGRATED = 2, /* migrated from another host */ 70 | VIR_DOMAIN_RUNNING_RESTORED = 3, /* restored from a state file */ 71 | VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4, /* restored from snapshot */ 72 | VIR_DOMAIN_RUNNING_UNPAUSED = 5, /* returned from paused state */ 73 | VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6, /* returned from migration */ 74 | VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7, /* returned from failed save process */ 75 | VIR_DOMAIN_RUNNING_WAKEUP = 8, /* returned from pmsuspended due to 76 | wakeup event */ 77 | VIR_DOMAIN_RUNNING_CRASHED = 9, /* resumed from crashed */ 78 | 79 | VIR_DOMAIN_RUNNING_LAST 80 | } virDomainRunningReason; 81 | 82 | typedef enum { 83 | VIR_DOMAIN_BLOCKED_UNKNOWN = 0, /* the reason is unknown */ 84 | 85 | VIR_DOMAIN_BLOCKED_LAST 86 | } virDomainBlockedReason; 87 | 88 | typedef enum { 89 | VIR_DOMAIN_PAUSED_UNKNOWN = 0, /* the reason is unknown */ 90 | VIR_DOMAIN_PAUSED_USER = 1, /* paused on user request */ 91 | VIR_DOMAIN_PAUSED_MIGRATION = 2, /* paused for offline migration */ 92 | VIR_DOMAIN_PAUSED_SAVE = 3, /* paused for save */ 93 | VIR_DOMAIN_PAUSED_DUMP = 4, /* paused for offline core dump */ 94 | VIR_DOMAIN_PAUSED_IOERROR = 5, /* paused due to a disk I/O error */ 95 | VIR_DOMAIN_PAUSED_WATCHDOG = 6, /* paused due to a watchdog event */ 96 | VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7, /* paused after restoring from snapshot */ 97 | VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8, /* paused during shutdown process */ 98 | VIR_DOMAIN_PAUSED_SNAPSHOT = 9, /* paused while creating a snapshot */ 99 | VIR_DOMAIN_PAUSED_CRASHED = 10, /* paused due to a guest crash */ 100 | VIR_DOMAIN_PAUSED_STARTING_UP = 11, /* the domain is being started */ 101 | 102 | VIR_DOMAIN_PAUSED_LAST 103 | } virDomainPausedReason; 104 | 105 | typedef enum { 106 | VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, /* the reason is unknown */ 107 | VIR_DOMAIN_SHUTDOWN_USER = 1, /* shutting down on user request */ 108 | 109 | VIR_DOMAIN_SHUTDOWN_LAST 110 | } virDomainShutdownReason; 111 | 112 | typedef enum { 113 | VIR_DOMAIN_SHUTOFF_UNKNOWN = 0, /* the reason is unknown */ 114 | VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1, /* normal shutdown */ 115 | VIR_DOMAIN_SHUTOFF_DESTROYED = 2, /* forced poweroff */ 116 | VIR_DOMAIN_SHUTOFF_CRASHED = 3, /* domain crashed */ 117 | VIR_DOMAIN_SHUTOFF_MIGRATED = 4, /* migrated to another host */ 118 | VIR_DOMAIN_SHUTOFF_SAVED = 5, /* saved to a file */ 119 | VIR_DOMAIN_SHUTOFF_FAILED = 6, /* domain failed to start */ 120 | VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7, /* restored from a snapshot which was 121 | * taken while domain was shutoff */ 122 | VIR_DOMAIN_SHUTOFF_LAST 123 | } virDomainShutoffReason; 124 | 125 | typedef enum { 126 | VIR_DOMAIN_CRASHED_UNKNOWN = 0, /* crashed for unknown reason */ 127 | VIR_DOMAIN_CRASHED_PANICKED = 1, /* domain panicked */ 128 | 129 | VIR_DOMAIN_CRASHED_LAST 130 | } virDomainCrashedReason; 131 | 132 | typedef enum { 133 | VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, 134 | 135 | VIR_DOMAIN_PMSUSPENDED_LAST 136 | } virDomainPMSuspendedReason; 137 | 138 | typedef enum { 139 | VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, 140 | 141 | VIR_DOMAIN_PMSUSPENDED_DISK_LAST 142 | } virDomainPMSuspendedDiskReason; 143 | 144 | 145 | typedef enum { 146 | VIR_DOMAIN_CONTROL_OK = 0, /* operational, ready to accept commands */ 147 | VIR_DOMAIN_CONTROL_JOB = 1, /* background job is running (can be 148 | monitored by virDomainGetJobInfo); only 149 | limited set of commands may be allowed */ 150 | VIR_DOMAIN_CONTROL_OCCUPIED = 2, /* occupied by a running command */ 151 | VIR_DOMAIN_CONTROL_ERROR = 3, /* unusable, domain cannot be fully 152 | operated, possible reason is provided 153 | in the details field */ 154 | 155 | VIR_DOMAIN_CONTROL_LAST 156 | } virDomainControlState; 157 | 158 | typedef enum { 159 | VIR_DOMAIN_CONTROL_ERROR_REASON_NONE = 0, /* server didn't provide a 160 | reason */ 161 | VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN = 1, /* unknown reason for the 162 | error */ 163 | VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR = 2, /* monitor connection is 164 | broken */ 165 | VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL = 3, /* error caused due to 166 | internal failure in libvirt 167 | */ 168 | VIR_DOMAIN_CONTROL_ERROR_REASON_LAST 169 | } virDomainControlErrorReason; 170 | ]] 171 | 172 | ffi.cdef[[ 173 | typedef struct _virDomainControlInfo virDomainControlInfo; 174 | struct _virDomainControlInfo { 175 | unsigned int state; /* control state, one of virDomainControlState */ 176 | unsigned int details; /* state details, currently 0 except for ERROR 177 | state (one of virDomainControlErrorReason) */ 178 | unsigned long long stateTime; /* for how long (in msec) control interface 179 | has been in current state (except for OK 180 | and ERROR states) */ 181 | }; 182 | 183 | 184 | typedef virDomainControlInfo *virDomainControlInfoPtr; 185 | 186 | 187 | typedef enum { 188 | VIR_DOMAIN_AFFECT_CURRENT = 0, /* Affect current domain state. */ 189 | VIR_DOMAIN_AFFECT_LIVE = 1 << 0, /* Affect running domain state. */ 190 | VIR_DOMAIN_AFFECT_CONFIG = 1 << 1, /* Affect persistent domain state. */ 191 | /* 1 << 2 is reserved for virTypedParameterFlags */ 192 | } virDomainModificationImpact; 193 | 194 | 195 | 196 | typedef struct _virDomainInfo virDomainInfo; 197 | 198 | struct _virDomainInfo { 199 | unsigned char state; /* the running state, one of virDomainState */ 200 | unsigned long maxMem; /* the maximum memory in KBytes allowed */ 201 | unsigned long memory; /* the memory in KBytes used by the domain */ 202 | unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ 203 | unsigned long long cpuTime; /* the CPU time used in nanoseconds */ 204 | }; 205 | 206 | 207 | 208 | typedef virDomainInfo *virDomainInfoPtr; 209 | 210 | 211 | typedef enum { 212 | VIR_DOMAIN_NONE = 0, /* Default behavior */ 213 | VIR_DOMAIN_START_PAUSED = 1 << 0, /* Launch guest in paused state */ 214 | VIR_DOMAIN_START_AUTODESTROY = 1 << 1, /* Automatically kill guest when virConnectPtr is closed */ 215 | VIR_DOMAIN_START_BYPASS_CACHE = 1 << 2, /* Avoid file system cache pollution */ 216 | VIR_DOMAIN_START_FORCE_BOOT = 1 << 3, /* Boot, discarding any managed save */ 217 | VIR_DOMAIN_START_VALIDATE = 1 << 4, /* Validate the XML document against schema */ 218 | } virDomainCreateFlags; 219 | ]] 220 | 221 | 222 | 223 | export.VIR_DOMAIN_SCHEDULER_CPU_SHARES ="cpu_shares" 224 | export.VIR_DOMAIN_SCHEDULER_VCPU_PERIOD ="vcpu_period" 225 | export.VIR_DOMAIN_SCHEDULER_VCPU_QUOTA ="vcpu_quota" 226 | export.VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD ="emulator_period" 227 | export.VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA ="emulator_quota" 228 | export.VIR_DOMAIN_SCHEDULER_WEIGHT ="weight" 229 | export.VIR_DOMAIN_SCHEDULER_CAP ="cap" 230 | export.VIR_DOMAIN_SCHEDULER_RESERVATION ="reservation" 231 | export.VIR_DOMAIN_SCHEDULER_LIMIT ="limit" 232 | export.VIR_DOMAIN_SCHEDULER_SHARES ="shares" 233 | 234 | 235 | 236 | ffi.cdef[[ 237 | int virDomainGetSchedulerParameters (virDomainPtr domain, 238 | virTypedParameterPtr params, 239 | int *nparams); 240 | int virDomainGetSchedulerParametersFlags (virDomainPtr domain, 241 | virTypedParameterPtr params, 242 | int *nparams, 243 | unsigned int flags); 244 | 245 | /* 246 | * Change scheduler parameters 247 | */ 248 | int virDomainSetSchedulerParameters (virDomainPtr domain, 249 | virTypedParameterPtr params, 250 | int nparams); 251 | int virDomainSetSchedulerParametersFlags (virDomainPtr domain, 252 | virTypedParameterPtr params, 253 | int nparams, 254 | unsigned int flags); 255 | 256 | /** 257 | * virDomainBlockStats: 258 | * 259 | * Block device stats for virDomainBlockStats. 260 | * 261 | * Hypervisors may return a field set to ((long long)-1) which indicates 262 | * that the hypervisor does not support that statistic. 263 | * 264 | * NB. Here 'long long' means 64 bit integer. 265 | */ 266 | typedef struct _virDomainBlockStats virDomainBlockStatsStruct; 267 | 268 | struct _virDomainBlockStats { 269 | long long rd_req; /* number of read requests */ 270 | long long rd_bytes; /* number of read bytes */ 271 | long long wr_req; /* number of write requests */ 272 | long long wr_bytes; /* number of written bytes */ 273 | long long errs; /* In Xen this returns the mysterious 'oo_req'. */ 274 | }; 275 | 276 | 277 | typedef virDomainBlockStatsStruct *virDomainBlockStatsPtr; 278 | 279 | 280 | static const int VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH = VIR_TYPED_PARAM_FIELD_LENGTH; 281 | ]] 282 | 283 | export.VIR_DOMAIN_BLOCK_STATS_READ_BYTES ="rd_bytes"; 284 | export.VIR_DOMAIN_BLOCK_STATS_READ_REQ ="rd_operations"; 285 | export.VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES ="rd_total_times"; 286 | export.VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES ="wr_bytes"; 287 | export.VIR_DOMAIN_BLOCK_STATS_WRITE_REQ ="wr_operations"; 288 | export.VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES ="wr_total_times"; 289 | export.VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ ="flush_operations"; 290 | export.VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES ="flush_total_times"; 291 | export.VIR_DOMAIN_BLOCK_STATS_ERRS ="errs"; 292 | 293 | 294 | 295 | ffi.cdef[[ 296 | typedef struct _virDomainInterfaceStats virDomainInterfaceStatsStruct; 297 | 298 | struct _virDomainInterfaceStats { 299 | long long rx_bytes; 300 | long long rx_packets; 301 | long long rx_errs; 302 | long long rx_drop; 303 | long long tx_bytes; 304 | long long tx_packets; 305 | long long tx_errs; 306 | long long tx_drop; 307 | }; 308 | 309 | 310 | typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr; 311 | 312 | 313 | typedef enum { 314 | /* The total amount of data read from swap space (in kB). */ 315 | VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0, 316 | /* The total amount of memory written out to swap space (in kB). */ 317 | VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1, 318 | 319 | /* 320 | * Page faults occur when a process makes a valid access to virtual memory 321 | * that is not available. When servicing the page fault, if disk IO is 322 | * required, it is considered a major fault. If not, it is a minor fault. 323 | * These are expressed as the number of faults that have occurred. 324 | */ 325 | VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2, 326 | VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3, 327 | 328 | /* 329 | * The amount of memory left completely unused by the system. Memory that 330 | * is available but used for reclaimable caches should NOT be reported as 331 | * free. This value is expressed in kB. 332 | */ 333 | VIR_DOMAIN_MEMORY_STAT_UNUSED = 4, 334 | 335 | /* 336 | * The total amount of usable memory as seen by the domain. This value 337 | * may be less than the amount of memory assigned to the domain if a 338 | * balloon driver is in use or if the guest OS does not initialize all 339 | * assigned pages. This value is expressed in kB. 340 | */ 341 | VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5, 342 | 343 | /* Current balloon value (in KB). */ 344 | VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6, 345 | 346 | /* Resident Set Size of the process running the domain. This value 347 | * is in kB */ 348 | VIR_DOMAIN_MEMORY_STAT_RSS = 7, 349 | 350 | /* 351 | * The number of statistics supported by this version of the interface. 352 | * To add new statistics, add them to the enum and increase this value. 353 | */ 354 | VIR_DOMAIN_MEMORY_STAT_NR = 8, 355 | 356 | VIR_DOMAIN_MEMORY_STAT_LAST = VIR_DOMAIN_MEMORY_STAT_NR 357 | } virDomainMemoryStatTags; 358 | 359 | typedef struct _virDomainMemoryStat virDomainMemoryStatStruct; 360 | 361 | struct _virDomainMemoryStat { 362 | int tag; 363 | unsigned long long val; 364 | }; 365 | 366 | typedef virDomainMemoryStatStruct *virDomainMemoryStatPtr; 367 | 368 | 369 | /* Domain core dump flags. */ 370 | typedef enum { 371 | VIR_DUMP_CRASH = (1 << 0), /* crash after dump */ 372 | VIR_DUMP_LIVE = (1 << 1), /* live dump */ 373 | VIR_DUMP_BYPASS_CACHE = (1 << 2), /* avoid file system cache pollution */ 374 | VIR_DUMP_RESET = (1 << 3), /* reset domain after dump finishes */ 375 | VIR_DUMP_MEMORY_ONLY = (1 << 4), /* use dump-guest-memory */ 376 | } virDomainCoreDumpFlags; 377 | 378 | 379 | typedef enum { 380 | VIR_DOMAIN_CORE_DUMP_FORMAT_RAW, /* dump guest memory in raw format */ 381 | VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB, /* kdump-compressed format, with 382 | * zlib compression */ 383 | VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO, /* kdump-compressed format, with 384 | * lzo compression */ 385 | VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY, /* kdump-compressed format, with 386 | * snappy compression */ 387 | VIR_DOMAIN_CORE_DUMP_FORMAT_LAST 388 | } virDomainCoreDumpFormat; 389 | 390 | /* Domain migration flags. */ 391 | typedef enum { 392 | VIR_MIGRATE_LIVE = (1 << 0), /* live migration */ 393 | VIR_MIGRATE_PEER2PEER = (1 << 1), /* direct source -> dest host control channel */ 394 | /* Note the less-common spelling that we're stuck with: 395 | VIR_MIGRATE_TUNNELLED should be VIR_MIGRATE_TUNNELED */ 396 | VIR_MIGRATE_TUNNELLED = (1 << 2), /* tunnel migration data over libvirtd connection */ 397 | VIR_MIGRATE_PERSIST_DEST = (1 << 3), /* persist the VM on the destination */ 398 | VIR_MIGRATE_UNDEFINE_SOURCE = (1 << 4), /* undefine the VM on the source */ 399 | VIR_MIGRATE_PAUSED = (1 << 5), /* pause on remote side */ 400 | VIR_MIGRATE_NON_SHARED_DISK = (1 << 6), /* migration with non-shared storage with full disk copy */ 401 | VIR_MIGRATE_NON_SHARED_INC = (1 << 7), /* migration with non-shared storage with incremental copy */ 402 | /* (same base image shared between source and destination) */ 403 | VIR_MIGRATE_CHANGE_PROTECTION = (1 << 8), /* protect for changing domain configuration through the 404 | * whole migration process; this will be used automatically 405 | * when supported */ 406 | VIR_MIGRATE_UNSAFE = (1 << 9), /* force migration even if it is considered unsafe */ 407 | VIR_MIGRATE_OFFLINE = (1 << 10), /* offline migrate */ 408 | VIR_MIGRATE_COMPRESSED = (1 << 11), /* compress data during migration */ 409 | VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12), /* abort migration on I/O errors happened during migration */ 410 | VIR_MIGRATE_AUTO_CONVERGE = (1 << 13), /* force convergence */ 411 | VIR_MIGRATE_RDMA_PIN_ALL = (1 << 14), /* RDMA memory pinning */ 412 | } virDomainMigrateFlags; 413 | ]] 414 | 415 | 416 | export.VIR_MIGRATE_PARAM_URI = "migrate_uri"; 417 | export.VIR_MIGRATE_PARAM_DEST_NAME = "destination_name"; 418 | export.VIR_MIGRATE_PARAM_DEST_XML = "destination_xml"; 419 | export.VIR_MIGRATE_PARAM_BANDWIDTH = "bandwidth"; 420 | export.VIR_MIGRATE_PARAM_GRAPHICS_URI = "graphics_uri"; 421 | export.VIR_MIGRATE_PARAM_LISTEN_ADDRESS = "listen_address"; 422 | 423 | ffi.cdef[[ 424 | /* Domain migration. */ 425 | virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn, 426 | unsigned long flags, const char *dname, 427 | const char *uri, unsigned long bandwidth); 428 | virDomainPtr virDomainMigrate2(virDomainPtr domain, virConnectPtr dconn, 429 | const char *dxml, 430 | unsigned long flags, const char *dname, 431 | const char *uri, unsigned long bandwidth); 432 | virDomainPtr virDomainMigrate3(virDomainPtr domain, 433 | virConnectPtr dconn, 434 | virTypedParameterPtr params, 435 | unsigned int nparams, 436 | unsigned int flags); 437 | 438 | int virDomainMigrateToURI (virDomainPtr domain, const char *duri, 439 | unsigned long flags, const char *dname, 440 | unsigned long bandwidth); 441 | 442 | int virDomainMigrateToURI2(virDomainPtr domain, 443 | const char *dconnuri, 444 | const char *miguri, 445 | const char *dxml, 446 | unsigned long flags, 447 | const char *dname, 448 | unsigned long bandwidth); 449 | int virDomainMigrateToURI3(virDomainPtr domain, 450 | const char *dconnuri, 451 | virTypedParameterPtr params, 452 | unsigned int nparams, 453 | unsigned int flags); 454 | 455 | int virDomainMigrateSetMaxDowntime (virDomainPtr domain, 456 | unsigned long long downtime, 457 | unsigned int flags); 458 | 459 | int virDomainMigrateGetCompressionCache(virDomainPtr domain, 460 | unsigned long long *cacheSize, 461 | unsigned int flags); 462 | int virDomainMigrateSetCompressionCache(virDomainPtr domain, 463 | unsigned long long cacheSize, 464 | unsigned int flags); 465 | 466 | int virDomainMigrateSetMaxSpeed(virDomainPtr domain, 467 | unsigned long bandwidth, 468 | unsigned int flags); 469 | 470 | int virDomainMigrateGetMaxSpeed(virDomainPtr domain, 471 | unsigned long *bandwidth, 472 | unsigned int flags); 473 | 474 | char * virConnectGetDomainCapabilities(virConnectPtr conn, 475 | const char *emulatorbin, 476 | const char *arch, 477 | const char *machine, 478 | const char *virttype, 479 | unsigned int flags); 480 | ]] 481 | 482 | ffi.cdef[[ 483 | 484 | int virConnectListDomains (virConnectPtr conn, 485 | int *ids, 486 | int maxids); 487 | 488 | 489 | int virConnectNumOfDomains (virConnectPtr conn); 490 | 491 | 492 | 493 | virConnectPtr virDomainGetConnect (virDomainPtr domain); 494 | 495 | 496 | 497 | virDomainPtr virDomainCreateXML (virConnectPtr conn, 498 | const char *xmlDesc, 499 | unsigned int flags); 500 | virDomainPtr virDomainCreateXMLWithFiles(virConnectPtr conn, 501 | const char *xmlDesc, 502 | unsigned int nfiles, 503 | int *files, 504 | unsigned int flags); 505 | virDomainPtr virDomainLookupByName (virConnectPtr conn, 506 | const char *name); 507 | virDomainPtr virDomainLookupByID (virConnectPtr conn, 508 | int id); 509 | virDomainPtr virDomainLookupByUUID (virConnectPtr conn, 510 | const unsigned char *uuid); 511 | virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn, 512 | const char *uuid); 513 | 514 | typedef enum { 515 | VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, /* hypervisor choice */ 516 | VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ 517 | VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = (1 << 1), /* Use guest agent */ 518 | VIR_DOMAIN_SHUTDOWN_INITCTL = (1 << 2), /* Use initctl */ 519 | VIR_DOMAIN_SHUTDOWN_SIGNAL = (1 << 3), /* Send a signal */ 520 | VIR_DOMAIN_SHUTDOWN_PARAVIRT = (1 << 4), /* Use paravirt guest control */ 521 | } virDomainShutdownFlagValues; 522 | 523 | int virDomainShutdown (virDomainPtr domain); 524 | int virDomainShutdownFlags (virDomainPtr domain, 525 | unsigned int flags); 526 | 527 | typedef enum { 528 | VIR_DOMAIN_REBOOT_DEFAULT = 0, /* hypervisor choice */ 529 | VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ 530 | VIR_DOMAIN_REBOOT_GUEST_AGENT = (1 << 1), /* Use guest agent */ 531 | VIR_DOMAIN_REBOOT_INITCTL = (1 << 2), /* Use initctl */ 532 | VIR_DOMAIN_REBOOT_SIGNAL = (1 << 3), /* Send a signal */ 533 | VIR_DOMAIN_REBOOT_PARAVIRT = (1 << 4), /* Use paravirt guest control */ 534 | } virDomainRebootFlagValues; 535 | 536 | int virDomainReboot (virDomainPtr domain, 537 | unsigned int flags); 538 | int virDomainReset (virDomainPtr domain, 539 | unsigned int flags); 540 | 541 | int virDomainDestroy (virDomainPtr domain); 542 | 543 | 544 | typedef enum { 545 | VIR_DOMAIN_DESTROY_DEFAULT = 0, /* Default behavior - could lead to data loss!! */ 546 | VIR_DOMAIN_DESTROY_GRACEFUL = 1 << 0, /* only SIGTERM, no SIGKILL */ 547 | } virDomainDestroyFlagsValues; 548 | 549 | int virDomainDestroyFlags (virDomainPtr domain, 550 | unsigned int flags); 551 | int virDomainRef (virDomainPtr domain); 552 | int virDomainFree (virDomainPtr domain); 553 | ]] 554 | 555 | ffi.cdef[[ 556 | 557 | int virDomainSuspend (virDomainPtr domain); 558 | int virDomainResume (virDomainPtr domain); 559 | int virDomainPMSuspendForDuration (virDomainPtr domain, 560 | unsigned int target, 561 | unsigned long long duration, 562 | unsigned int flags); 563 | int virDomainPMWakeup (virDomainPtr domain, 564 | unsigned int flags); 565 | 566 | 567 | 568 | typedef enum { 569 | VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 << 0, /* Avoid file system cache pollution */ 570 | VIR_DOMAIN_SAVE_RUNNING = 1 << 1, /* Favor running over paused */ 571 | VIR_DOMAIN_SAVE_PAUSED = 1 << 2, /* Favor paused over running */ 572 | } virDomainSaveRestoreFlags; 573 | 574 | int virDomainSave (virDomainPtr domain, 575 | const char *to); 576 | int virDomainSaveFlags (virDomainPtr domain, 577 | const char *to, 578 | const char *dxml, 579 | unsigned int flags); 580 | int virDomainRestore (virConnectPtr conn, 581 | const char *from); 582 | int virDomainRestoreFlags (virConnectPtr conn, 583 | const char *from, 584 | const char *dxml, 585 | unsigned int flags); 586 | 587 | char * virDomainSaveImageGetXMLDesc (virConnectPtr conn, 588 | const char *file, 589 | unsigned int flags); 590 | int virDomainSaveImageDefineXML (virConnectPtr conn, 591 | const char *file, 592 | const char *dxml, 593 | unsigned int flags); 594 | ]] 595 | 596 | ffi.cdef[[ 597 | 598 | int virDomainManagedSave (virDomainPtr dom, 599 | unsigned int flags); 600 | int virDomainHasManagedSaveImage(virDomainPtr dom, 601 | unsigned int flags); 602 | int virDomainManagedSaveRemove(virDomainPtr dom, 603 | unsigned int flags); 604 | ]] 605 | 606 | ffi.cdef[[ 607 | 608 | int virDomainCoreDump (virDomainPtr domain, 609 | const char *to, 610 | unsigned int flags); 611 | 612 | 613 | int virDomainCoreDumpWithFormat (virDomainPtr domain, 614 | const char *to, 615 | unsigned int dumpformat, 616 | unsigned int flags); 617 | ]] 618 | 619 | ffi.cdef[[ 620 | 621 | char * virDomainScreenshot (virDomainPtr domain, 622 | virStreamPtr stream, 623 | unsigned int screen, 624 | unsigned int flags); 625 | ]] 626 | 627 | ffi.cdef[[ 628 | 629 | 630 | int virDomainGetInfo (virDomainPtr domain, 631 | virDomainInfoPtr info); 632 | int virDomainGetState (virDomainPtr domain, 633 | int *state, 634 | int *reason, 635 | unsigned int flags); 636 | ]] 637 | 638 | export.VIR_DOMAIN_CPU_STATS_CPUTIME ="cpu_time"; 639 | export.VIR_DOMAIN_CPU_STATS_USERTIME ="user_time"; 640 | export.VIR_DOMAIN_CPU_STATS_SYSTEMTIME ="system_time"; 641 | export.VIR_DOMAIN_CPU_STATS_VCPUTIME ="vcpu_time"; 642 | 643 | ffi.cdef[[ 644 | int virDomainGetCPUStats(virDomainPtr domain, 645 | virTypedParameterPtr params, 646 | unsigned int nparams, 647 | int start_cpu, 648 | unsigned int ncpus, 649 | unsigned int flags); 650 | 651 | int virDomainGetControlInfo (virDomainPtr domain, 652 | virDomainControlInfoPtr info, 653 | unsigned int flags); 654 | 655 | 656 | char * virDomainGetSchedulerType(virDomainPtr domain, 657 | int *nparams); 658 | ]] 659 | 660 | 661 | 662 | -- Manage blkio parameters. 663 | 664 | export.VIR_DOMAIN_BLKIO_WEIGHT ="weight"; 665 | export.VIR_DOMAIN_BLKIO_DEVICE_WEIGHT ="device_weight"; 666 | export.VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS ="device_read_iops_sec"; 667 | export.VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS ="device_write_iops_sec"; 668 | export.VIR_DOMAIN_BLKIO_DEVICE_READ_BPS ="device_read_bytes_sec"; 669 | export.VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS ="device_write_bytes_sec"; 670 | 671 | ffi.cdef[[ 672 | /* Set Blkio tunables for the domain*/ 673 | int virDomainSetBlkioParameters(virDomainPtr domain, 674 | virTypedParameterPtr params, 675 | int nparams, unsigned int flags); 676 | int virDomainGetBlkioParameters(virDomainPtr domain, 677 | virTypedParameterPtr params, 678 | int *nparams, unsigned int flags); 679 | ]] 680 | 681 | -- Manage memory parameters. 682 | 683 | 684 | export.VIR_DOMAIN_MEMORY_PARAM_UNLIMITED = 9007199254740991LL; -- = INT64_MAX >> 10 685 | 686 | 687 | export.VIR_DOMAIN_MEMORY_HARD_LIMIT ="hard_limit"; 688 | export.VIR_DOMAIN_MEMORY_SOFT_LIMIT ="soft_limit"; 689 | export.VIR_DOMAIN_MEMORY_MIN_GUARANTEE ="min_guarantee"; 690 | export.VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT ="swap_hard_limit"; 691 | 692 | ffi.cdef[[ 693 | /* Set memory tunables for the domain*/ 694 | int virDomainSetMemoryParameters(virDomainPtr domain, 695 | virTypedParameterPtr params, 696 | int nparams, unsigned int flags); 697 | int virDomainGetMemoryParameters(virDomainPtr domain, 698 | virTypedParameterPtr params, 699 | int *nparams, unsigned int flags); 700 | 701 | /* Memory size modification flags. */ 702 | typedef enum { 703 | /* See virDomainModificationImpact for these flags. */ 704 | VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, 705 | VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE, 706 | VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, 707 | 708 | /* Additionally, these flags may be bitwise-OR'd in. */ 709 | VIR_DOMAIN_MEM_MAXIMUM = (1 << 2), /* affect Max rather than current */ 710 | } virDomainMemoryModFlags; 711 | ]] 712 | 713 | ffi.cdef[[ 714 | /* Manage numa parameters */ 715 | 716 | typedef enum { 717 | VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, 718 | VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, 719 | VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, 720 | 721 | VIR_DOMAIN_NUMATUNE_MEM_LAST /* This constant is subject to change */ 722 | } virDomainNumatuneMemMode; 723 | ]] 724 | 725 | export.VIR_DOMAIN_NUMA_NODESET = "numa_nodeset" 726 | export.VIR_DOMAIN_NUMA_MODE = "numa_mode" 727 | 728 | ffi.cdef[[ 729 | int virDomainSetNumaParameters(virDomainPtr domain, 730 | virTypedParameterPtr params, 731 | int nparams, unsigned int flags); 732 | int virDomainGetNumaParameters(virDomainPtr domain, 733 | virTypedParameterPtr params, 734 | int *nparams, unsigned int flags); 735 | 736 | 737 | const char * virDomainGetName (virDomainPtr domain); 738 | unsigned int virDomainGetID (virDomainPtr domain); 739 | int virDomainGetUUID (virDomainPtr domain, 740 | unsigned char *uuid); 741 | int virDomainGetUUIDString (virDomainPtr domain, 742 | char *buf); 743 | char * virDomainGetOSType (virDomainPtr domain); 744 | unsigned long virDomainGetMaxMemory (virDomainPtr domain); 745 | int virDomainSetMaxMemory (virDomainPtr domain, 746 | unsigned long memory); 747 | int virDomainSetMemory (virDomainPtr domain, 748 | unsigned long memory); 749 | int virDomainSetMemoryFlags (virDomainPtr domain, 750 | unsigned long memory, 751 | unsigned int flags); 752 | int virDomainSetMemoryStatsPeriod (virDomainPtr domain, 753 | int period, 754 | unsigned int flags); 755 | int virDomainGetMaxVcpus (virDomainPtr domain); 756 | int virDomainGetSecurityLabel (virDomainPtr domain, 757 | virSecurityLabelPtr seclabel); 758 | char * virDomainGetHostname (virDomainPtr domain, 759 | unsigned int flags); 760 | int virDomainGetSecurityLabelList (virDomainPtr domain, 761 | virSecurityLabelPtr* seclabels); 762 | 763 | typedef enum { 764 | VIR_DOMAIN_METADATA_DESCRIPTION = 0, /* Operate on */ 765 | VIR_DOMAIN_METADATA_TITLE = 1, /* Operate on */ 766 | VIR_DOMAIN_METADATA_ELEMENT = 2, /* Operate on <metadata> */ 767 | 768 | VIR_DOMAIN_METADATA_LAST 769 | } virDomainMetadataType; 770 | 771 | int 772 | virDomainSetMetadata(virDomainPtr domain, 773 | int type, 774 | const char *metadata, 775 | const char *key, 776 | const char *uri, 777 | unsigned int flags); 778 | 779 | char * 780 | virDomainGetMetadata(virDomainPtr domain, 781 | int type, 782 | const char *uri, 783 | unsigned int flags); 784 | ]] 785 | 786 | ffi.cdef[[ 787 | /* 788 | * XML domain description 789 | */ 790 | 791 | typedef enum { 792 | VIR_DOMAIN_XML_SECURE = (1 << 0), /* dump security sensitive information too */ 793 | VIR_DOMAIN_XML_INACTIVE = (1 << 1), /* dump inactive domain information */ 794 | VIR_DOMAIN_XML_UPDATE_CPU = (1 << 2), /* update guest CPU requirements according to host CPU */ 795 | VIR_DOMAIN_XML_MIGRATABLE = (1 << 3), /* dump XML suitable for migration */ 796 | } virDomainXMLFlags; 797 | 798 | char * virDomainGetXMLDesc (virDomainPtr domain, 799 | unsigned int flags); 800 | 801 | 802 | char * virConnectDomainXMLFromNative(virConnectPtr conn, 803 | const char *nativeFormat, 804 | const char *nativeConfig, 805 | unsigned int flags); 806 | char * virConnectDomainXMLToNative(virConnectPtr conn, 807 | const char *nativeFormat, 808 | const char *domainXml, 809 | unsigned int flags); 810 | 811 | int virDomainBlockStats (virDomainPtr dom, 812 | const char *disk, 813 | virDomainBlockStatsPtr stats, 814 | size_t size); 815 | int virDomainBlockStatsFlags (virDomainPtr dom, 816 | const char *disk, 817 | virTypedParameterPtr params, 818 | int *nparams, 819 | unsigned int flags); 820 | int virDomainInterfaceStats (virDomainPtr dom, 821 | const char *path, 822 | virDomainInterfaceStatsPtr stats, 823 | size_t size); 824 | ]] 825 | 826 | -- Management of interface parameters 827 | 828 | 829 | export.VIR_DOMAIN_BANDWIDTH_IN_AVERAGE ="inbound.average"; 830 | export.VIR_DOMAIN_BANDWIDTH_IN_PEAK ="inbound.peak"; 831 | export.VIR_DOMAIN_BANDWIDTH_IN_BURST ="inbound.burst"; 832 | export.VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE ="outbound.average"; 833 | export.VIR_DOMAIN_BANDWIDTH_OUT_PEAK ="outbound.peak"; 834 | export.VIR_DOMAIN_BANDWIDTH_OUT_BURST ="outbound.burst"; 835 | 836 | ffi.cdef[[ 837 | int virDomainSetInterfaceParameters (virDomainPtr dom, 838 | const char *device, 839 | virTypedParameterPtr params, 840 | int nparams, unsigned int flags); 841 | int virDomainGetInterfaceParameters (virDomainPtr dom, 842 | const char *device, 843 | virTypedParameterPtr params, 844 | int *nparams, unsigned int flags); 845 | ]] 846 | 847 | ffi.cdef[[ 848 | /* Management of domain block devices */ 849 | 850 | int virDomainBlockPeek (virDomainPtr dom, 851 | const char *disk, 852 | unsigned long long offset, 853 | size_t size, 854 | void *buffer, 855 | unsigned int flags); 856 | 857 | 858 | typedef enum { 859 | VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1 << 0, /* size in bytes instead of KiB */ 860 | } virDomainBlockResizeFlags; 861 | 862 | int virDomainBlockResize (virDomainPtr dom, 863 | const char *disk, 864 | unsigned long long size, 865 | unsigned int flags); 866 | 867 | 868 | typedef struct _virDomainBlockInfo virDomainBlockInfo; 869 | typedef virDomainBlockInfo *virDomainBlockInfoPtr; 870 | struct _virDomainBlockInfo { 871 | unsigned long long capacity; /* logical size in bytes of the 872 | * image (how much storage the 873 | * guest will see) */ 874 | unsigned long long allocation; /* host storage in bytes occupied 875 | * by the image (such as highest 876 | * allocated extent if there are no 877 | * holes, similar to 'du') */ 878 | unsigned long long physical; /* host physical size in bytes of 879 | * the image container (last 880 | * offset, similar to 'ls')*/ 881 | }; 882 | 883 | int virDomainGetBlockInfo(virDomainPtr dom, 884 | const char *disk, 885 | virDomainBlockInfoPtr info, 886 | unsigned int flags); 887 | ]] 888 | 889 | ffi.cdef[[ 890 | /* Management of domain memory */ 891 | 892 | int virDomainMemoryStats (virDomainPtr dom, 893 | virDomainMemoryStatPtr stats, 894 | unsigned int nr_stats, 895 | unsigned int flags); 896 | 897 | /* Memory peeking flags. */ 898 | 899 | typedef enum { 900 | VIR_MEMORY_VIRTUAL = 1 << 0, /* addresses are virtual addresses */ 901 | VIR_MEMORY_PHYSICAL = 1 << 1, /* addresses are physical addresses */ 902 | } virDomainMemoryFlags; 903 | 904 | int virDomainMemoryPeek (virDomainPtr dom, 905 | unsigned long long start, 906 | size_t size, 907 | void *buffer, 908 | unsigned int flags); 909 | 910 | typedef enum { 911 | VIR_DOMAIN_DEFINE_VALIDATE = (1 << 0), /* Validate the XML document against schema */ 912 | } virDomainDefineFlags; 913 | 914 | 915 | virDomainPtr virDomainDefineXML (virConnectPtr conn, 916 | const char *xml); 917 | 918 | virDomainPtr virDomainDefineXMLFlags (virConnectPtr conn, 919 | const char *xml, 920 | unsigned int flags); 921 | int virDomainUndefine (virDomainPtr domain); 922 | 923 | typedef enum { 924 | VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = (1 << 0), /* Also remove any 925 | managed save */ 926 | VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = (1 << 1), /* If last use of domain, 927 | then also remove any 928 | snapshot metadata */ 929 | VIR_DOMAIN_UNDEFINE_NVRAM = (1 << 2), /* Also remove any 930 | nvram file */ 931 | 932 | /* Future undefine control flags should come here. */ 933 | } virDomainUndefineFlagsValues; 934 | 935 | 936 | int virDomainUndefineFlags (virDomainPtr domain, 937 | unsigned int flags); 938 | int virConnectNumOfDefinedDomains (virConnectPtr conn); 939 | int virConnectListDefinedDomains (virConnectPtr conn, 940 | char **const names, 941 | int maxnames); 942 | ]] 943 | 944 | ffi.cdef[[ 945 | 946 | typedef enum { 947 | VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1 << 0, 948 | VIR_CONNECT_LIST_DOMAINS_INACTIVE = 1 << 1, 949 | 950 | VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 1 << 2, 951 | VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 1 << 3, 952 | 953 | VIR_CONNECT_LIST_DOMAINS_RUNNING = 1 << 4, 954 | VIR_CONNECT_LIST_DOMAINS_PAUSED = 1 << 5, 955 | VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 1 << 6, 956 | VIR_CONNECT_LIST_DOMAINS_OTHER = 1 << 7, 957 | 958 | VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 1 << 8, 959 | VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 1 << 9, 960 | 961 | VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1 << 10, 962 | VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 1 << 11, 963 | 964 | VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 1 << 12, 965 | VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 1 << 13, 966 | } virConnectListAllDomainsFlags; 967 | 968 | int virConnectListAllDomains (virConnectPtr conn, 969 | virDomainPtr **domains, 970 | unsigned int flags); 971 | int virDomainCreate (virDomainPtr domain); 972 | int virDomainCreateWithFlags (virDomainPtr domain, 973 | unsigned int flags); 974 | 975 | int virDomainCreateWithFiles (virDomainPtr domain, 976 | unsigned int nfiles, 977 | int *files, 978 | unsigned int flags); 979 | 980 | int virDomainGetAutostart (virDomainPtr domain, 981 | int *autostart); 982 | int virDomainSetAutostart (virDomainPtr domain, 983 | int autostart); 984 | 985 | 986 | 987 | typedef enum { 988 | VIR_VCPU_OFFLINE = 0, /* the virtual CPU is offline */ 989 | VIR_VCPU_RUNNING = 1, /* the virtual CPU is running */ 990 | VIR_VCPU_BLOCKED = 2, /* the virtual CPU is blocked on resource */ 991 | 992 | VIR_VCPU_LAST 993 | } virVcpuState; 994 | 995 | typedef struct _virVcpuInfo virVcpuInfo; 996 | struct _virVcpuInfo { 997 | unsigned int number; /* virtual CPU number */ 998 | int state; /* value from virVcpuState */ 999 | unsigned long long cpuTime; /* CPU time used, in nanoseconds */ 1000 | int cpu; /* real CPU number, or -1 if offline */ 1001 | }; 1002 | typedef virVcpuInfo *virVcpuInfoPtr; 1003 | 1004 | /* Flags for controlling virtual CPU hot-plugging. */ 1005 | typedef enum { 1006 | /* See virDomainModificationImpact for these flags. */ 1007 | VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, 1008 | VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE, 1009 | VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, 1010 | 1011 | /* Additionally, these flags may be bitwise-OR'd in. */ 1012 | VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */ 1013 | VIR_DOMAIN_VCPU_GUEST = (1 << 3), /* Modify state of the cpu in the guest */ 1014 | } virDomainVcpuFlags; 1015 | ]] 1016 | 1017 | ffi.cdef[[ 1018 | int virDomainSetVcpus (virDomainPtr domain, 1019 | unsigned int nvcpus); 1020 | int virDomainSetVcpusFlags (virDomainPtr domain, 1021 | unsigned int nvcpus, 1022 | unsigned int flags); 1023 | int virDomainGetVcpusFlags (virDomainPtr domain, 1024 | unsigned int flags); 1025 | 1026 | int virDomainPinVcpu (virDomainPtr domain, 1027 | unsigned int vcpu, 1028 | unsigned char *cpumap, 1029 | int maplen); 1030 | int virDomainPinVcpuFlags (virDomainPtr domain, 1031 | unsigned int vcpu, 1032 | unsigned char *cpumap, 1033 | int maplen, 1034 | unsigned int flags); 1035 | 1036 | int virDomainGetVcpuPinInfo (virDomainPtr domain, 1037 | int ncpumaps, 1038 | unsigned char *cpumaps, 1039 | int maplen, 1040 | unsigned int flags); 1041 | 1042 | int virDomainPinEmulator (virDomainPtr domain, 1043 | unsigned char *cpumap, 1044 | int maplen, 1045 | unsigned int flags); 1046 | 1047 | int virDomainGetEmulatorPinInfo (virDomainPtr domain, 1048 | unsigned char *cpumaps, 1049 | int maplen, 1050 | unsigned int flags); 1051 | ]] 1052 | 1053 | ffi.cdef[[ 1054 | 1055 | typedef struct _virDomainIOThreadInfo virDomainIOThreadInfo; 1056 | typedef virDomainIOThreadInfo *virDomainIOThreadInfoPtr; 1057 | struct _virDomainIOThreadInfo { 1058 | unsigned int iothread_id; /* IOThread ID */ 1059 | unsigned char *cpumap; /* CPU map for thread. A pointer to an */ 1060 | /* array of real CPUs (in 8-bit bytes) */ 1061 | int cpumaplen; /* cpumap size */ 1062 | }; 1063 | 1064 | void virDomainIOThreadInfoFree(virDomainIOThreadInfoPtr info); 1065 | 1066 | int virDomainGetIOThreadInfo(virDomainPtr domain, 1067 | virDomainIOThreadInfoPtr **info, 1068 | unsigned int flags); 1069 | int virDomainPinIOThread(virDomainPtr domain, 1070 | unsigned int iothread_id, 1071 | unsigned char *cpumap, 1072 | int maplen, 1073 | unsigned int flags); 1074 | ]] 1075 | 1076 | 1077 | export.VIR_USE_CPU = function(cpumap, cpu) 1078 | cpumap[cpu / 8] = bor(cpumap[cpu / 8], lshift((cpu % 8),1)) 1079 | end 1080 | 1081 | export.VIR_UNUSE_CPU = function(cpumap, cpu) 1082 | cpumap[cpu / 8] = band(cpumap[cpu / 8], bnot(lshift((cpu % 8), 1))); 1083 | end 1084 | 1085 | export.VIR_CPU_USED = function(cpumap, cpu) 1086 | return band(cpumap[cpu / 8], lshift((cpu % 8),1)) 1087 | end 1088 | 1089 | export.VIR_CPU_MAPLEN = function(cpu) 1090 | return ((cpu + 7) / 8) 1091 | end 1092 | 1093 | 1094 | ffi.cdef[[ 1095 | int virDomainGetVcpus (virDomainPtr domain, 1096 | virVcpuInfoPtr info, 1097 | int maxinfo, 1098 | unsigned char *cpumaps, 1099 | int maplen); 1100 | ]] 1101 | 1102 | 1103 | export.VIR_CPU_USABLE = function(cpumaps, maplen, vcpu, cpu) 1104 | return VIR_CPU_USED(export.VIR_GET_CPUMAP(cpumaps, maplen, vcpu), cpu) 1105 | end 1106 | 1107 | export.VIR_COPY_CPUMAP = function(cpumaps, maplen, vcpu, cpumap) 1108 | memcpy(cpumap, VIR_GET_CPUMAP(cpumaps, maplen, vcpu), maplen) 1109 | end 1110 | 1111 | --[[ 1112 | -- TODO, get the address of a field 1113 | export.VIR_GET_CPUMAP(cpumaps, maplen, vcpu) 1114 | return (&((cpumaps)[(vcpu) * (maplen)])) 1115 | end 1116 | --]] 1117 | 1118 | ffi.cdef[[ 1119 | typedef enum { 1120 | /* See virDomainModificationImpact for these flags. */ 1121 | VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, 1122 | VIR_DOMAIN_DEVICE_MODIFY_LIVE = VIR_DOMAIN_AFFECT_LIVE, 1123 | VIR_DOMAIN_DEVICE_MODIFY_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, 1124 | 1125 | /* Additionally, these flags may be bitwise-OR'd in. */ 1126 | VIR_DOMAIN_DEVICE_MODIFY_FORCE = (1 << 2), /* Forcibly modify device 1127 | (ex. force eject a cdrom) */ 1128 | } virDomainDeviceModifyFlags; 1129 | 1130 | int virDomainAttachDevice(virDomainPtr domain, const char *xml); 1131 | int virDomainDetachDevice(virDomainPtr domain, const char *xml); 1132 | 1133 | int virDomainAttachDeviceFlags(virDomainPtr domain, 1134 | const char *xml, unsigned int flags); 1135 | int virDomainDetachDeviceFlags(virDomainPtr domain, 1136 | const char *xml, unsigned int flags); 1137 | int virDomainUpdateDeviceFlags(virDomainPtr domain, 1138 | const char *xml, unsigned int flags); 1139 | 1140 | typedef struct _virDomainStatsRecord virDomainStatsRecord; 1141 | typedef virDomainStatsRecord *virDomainStatsRecordPtr; 1142 | struct _virDomainStatsRecord { 1143 | virDomainPtr dom; 1144 | virTypedParameterPtr params; 1145 | int nparams; 1146 | }; 1147 | 1148 | typedef enum { 1149 | VIR_DOMAIN_STATS_STATE = (1 << 0), /* return domain state */ 1150 | VIR_DOMAIN_STATS_CPU_TOTAL = (1 << 1), /* return domain CPU info */ 1151 | VIR_DOMAIN_STATS_BALLOON = (1 << 2), /* return domain balloon info */ 1152 | VIR_DOMAIN_STATS_VCPU = (1 << 3), /* return domain virtual CPU info */ 1153 | VIR_DOMAIN_STATS_INTERFACE = (1 << 4), /* return domain interfaces info */ 1154 | VIR_DOMAIN_STATS_BLOCK = (1 << 5), /* return domain block info */ 1155 | } virDomainStatsTypes; 1156 | 1157 | typedef enum { 1158 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE = VIR_CONNECT_LIST_DOMAINS_ACTIVE, 1159 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE = VIR_CONNECT_LIST_DOMAINS_INACTIVE, 1160 | 1161 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT = VIR_CONNECT_LIST_DOMAINS_PERSISTENT, 1162 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = VIR_CONNECT_LIST_DOMAINS_TRANSIENT, 1163 | 1164 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = VIR_CONNECT_LIST_DOMAINS_RUNNING, 1165 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = VIR_CONNECT_LIST_DOMAINS_PAUSED, 1166 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = VIR_CONNECT_LIST_DOMAINS_SHUTOFF, 1167 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = VIR_CONNECT_LIST_DOMAINS_OTHER, 1168 | 1169 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING = 1 << 30, /* include backing chain for block stats */ 1170 | VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = 1 << 31, /* enforce requested stats */ 1171 | } virConnectGetAllDomainStatsFlags; 1172 | 1173 | int virConnectGetAllDomainStats(virConnectPtr conn, 1174 | unsigned int stats, 1175 | virDomainStatsRecordPtr **retStats, 1176 | unsigned int flags); 1177 | 1178 | int virDomainListGetStats(virDomainPtr *doms, 1179 | unsigned int stats, 1180 | virDomainStatsRecordPtr **retStats, 1181 | unsigned int flags); 1182 | 1183 | void virDomainStatsRecordListFree(virDomainStatsRecordPtr *stats); 1184 | ]] 1185 | 1186 | ffi.cdef[[ 1187 | /* 1188 | * BlockJob API 1189 | */ 1190 | 1191 | 1192 | typedef enum { 1193 | VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0, /* Placeholder */ 1194 | 1195 | VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1, 1196 | /* Block Pull (virDomainBlockPull, or virDomainBlockRebase without 1197 | * flags), job ends on completion */ 1198 | 1199 | VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2, 1200 | /* Block Copy (virDomainBlockCopy, or virDomainBlockRebase with 1201 | * flags), job exists as long as mirroring is active */ 1202 | 1203 | VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3, 1204 | /* Block Commit (virDomainBlockCommit without flags), job ends on 1205 | * completion */ 1206 | 1207 | VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4, 1208 | /* Active Block Commit (virDomainBlockCommit with flags), job 1209 | * exists as long as sync is active */ 1210 | 1211 | VIR_DOMAIN_BLOCK_JOB_TYPE_LAST 1212 | 1213 | } virDomainBlockJobType; 1214 | 1215 | 1216 | typedef enum { 1217 | VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1 << 0, 1218 | VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 1 << 1, 1219 | } virDomainBlockJobAbortFlags; 1220 | 1221 | int virDomainBlockJobAbort(virDomainPtr dom, const char *disk, 1222 | unsigned int flags); 1223 | 1224 | /* Flags for use with virDomainGetBlockJobInfo */ 1225 | typedef enum { 1226 | VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s 1227 | instead of MiB/s */ 1228 | } virDomainBlockJobInfoFlags; 1229 | 1230 | /* An iterator for monitoring block job operations */ 1231 | typedef unsigned long long virDomainBlockJobCursor; 1232 | 1233 | typedef struct _virDomainBlockJobInfo virDomainBlockJobInfo; 1234 | struct _virDomainBlockJobInfo { 1235 | int type; /* virDomainBlockJobType */ 1236 | unsigned long bandwidth; /* either bytes/s or MiB/s, according to flags */ 1237 | 1238 | /* 1239 | * The following fields provide an indication of block job progress. @cur 1240 | * indicates the current position and will be between 0 and @end. @end is 1241 | * the final cursor position for this operation and represents completion. 1242 | * To approximate progress, divide @cur by @end. 1243 | */ 1244 | virDomainBlockJobCursor cur; 1245 | virDomainBlockJobCursor end; 1246 | }; 1247 | typedef virDomainBlockJobInfo *virDomainBlockJobInfoPtr; 1248 | 1249 | int virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk, 1250 | virDomainBlockJobInfoPtr info, 1251 | unsigned int flags); 1252 | 1253 | /* Flags for use with virDomainBlockJobSetSpeed */ 1254 | typedef enum { 1255 | VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s 1256 | instead of MiB/s */ 1257 | } virDomainBlockJobSetSpeedFlags; 1258 | 1259 | int virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk, 1260 | unsigned long bandwidth, unsigned int flags); 1261 | 1262 | /* Flags for use with virDomainBlockPull (values chosen to be a subset 1263 | * of the flags for virDomainBlockRebase) */ 1264 | typedef enum { 1265 | VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s 1266 | instead of MiB/s */ 1267 | } virDomainBlockPullFlags; 1268 | 1269 | int virDomainBlockPull(virDomainPtr dom, const char *disk, 1270 | unsigned long bandwidth, unsigned int flags); 1271 | 1272 | /** 1273 | * virDomainBlockRebaseFlags: 1274 | * 1275 | * Flags available for virDomainBlockRebase(). 1276 | */ 1277 | typedef enum { 1278 | VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1 << 0, /* Limit copy to top of source 1279 | backing chain */ 1280 | VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 1 << 1, /* Reuse existing external 1281 | file for a copy */ 1282 | VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 1 << 2, /* Make destination file raw */ 1283 | VIR_DOMAIN_BLOCK_REBASE_COPY = 1 << 3, /* Start a copy job */ 1284 | VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 1 << 4, /* Keep backing chain 1285 | referenced using relative 1286 | names */ 1287 | VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 1 << 5, /* Treat destination as block 1288 | device instead of file */ 1289 | VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s 1290 | instead of MiB/s */ 1291 | } virDomainBlockRebaseFlags; 1292 | 1293 | int virDomainBlockRebase(virDomainPtr dom, const char *disk, 1294 | const char *base, unsigned long bandwidth, 1295 | unsigned int flags); 1296 | 1297 | 1298 | typedef enum { 1299 | VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1 << 0, /* Limit copy to top of source 1300 | backing chain */ 1301 | VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 1 << 1, /* Reuse existing external 1302 | file for a copy */ 1303 | } virDomainBlockCopyFlags; 1304 | ]] 1305 | 1306 | 1307 | export.VIR_DOMAIN_BLOCK_COPY_BANDWIDTH ="bandwidth"; 1308 | export.VIR_DOMAIN_BLOCK_COPY_GRANULARITY ="granularity"; 1309 | export.VIR_DOMAIN_BLOCK_COPY_BUF_SIZE ="buf-size"; 1310 | 1311 | 1312 | ffi.cdef[[ 1313 | int virDomainBlockCopy(virDomainPtr dom, const char *disk, 1314 | const char *destxml, 1315 | virTypedParameterPtr params, 1316 | int nparams, 1317 | unsigned int flags); 1318 | 1319 | 1320 | typedef enum { 1321 | VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1 << 0, /* NULL base means next backing 1322 | file, not whole chain */ 1323 | VIR_DOMAIN_BLOCK_COMMIT_DELETE = 1 << 1, /* Delete any files that are now 1324 | invalid after their contents 1325 | have been committed */ 1326 | VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 1 << 2, /* Allow a two-phase commit when 1327 | top is the active layer */ 1328 | VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 1 << 3, /* keep the backing chain 1329 | referenced using relative 1330 | names */ 1331 | VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 1 << 4, /* bandwidth in bytes/s 1332 | instead of MiB/s */ 1333 | } virDomainBlockCommitFlags; 1334 | 1335 | int virDomainBlockCommit(virDomainPtr dom, const char *disk, const char *base, 1336 | const char *top, unsigned long bandwidth, 1337 | unsigned int flags); 1338 | ]] 1339 | 1340 | 1341 | 1342 | -- Block I/O throttling support 1343 | 1344 | 1345 | export.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC ="total_bytes_sec" 1346 | 1347 | export.VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC ="read_bytes_sec" 1348 | 1349 | export.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC ="write_bytes_sec" 1350 | 1351 | export.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC ="total_iops_sec" 1352 | 1353 | export.VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC ="read_iops_sec" 1354 | 1355 | export.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC ="write_iops_sec" 1356 | 1357 | export.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC_MAX ="total_bytes_sec_max" 1358 | 1359 | export.VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC_MAX ="read_bytes_sec_max" 1360 | 1361 | export.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC_MAX ="write_bytes_sec_max" 1362 | 1363 | export.VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC_MAX ="total_iops_sec_max" 1364 | 1365 | export.VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC_MAX ="read_iops_sec_max" 1366 | 1367 | export.VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC_MAX ="write_iops_sec_max" 1368 | 1369 | export.VIR_DOMAIN_BLOCK_IOTUNE_SIZE_IOPS_SEC ="size_iops_sec" 1370 | 1371 | ffi.cdef[[ 1372 | int 1373 | virDomainSetBlockIoTune(virDomainPtr dom, 1374 | const char *disk, 1375 | virTypedParameterPtr params, 1376 | int nparams, 1377 | unsigned int flags); 1378 | int 1379 | virDomainGetBlockIoTune(virDomainPtr dom, 1380 | const char *disk, 1381 | virTypedParameterPtr params, 1382 | int *nparams, 1383 | unsigned int flags); 1384 | ]] 1385 | 1386 | ffi.cdef[[ 1387 | 1388 | typedef enum { 1389 | VIR_DOMAIN_DISK_ERROR_NONE = 0, /* no error */ 1390 | VIR_DOMAIN_DISK_ERROR_UNSPEC = 1, /* unspecified I/O error */ 1391 | VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2, /* no space left on the device */ 1392 | 1393 | VIR_DOMAIN_DISK_ERROR_LAST 1394 | 1395 | } virDomainDiskErrorCode; 1396 | 1397 | 1398 | typedef struct _virDomainDiskError virDomainDiskError; 1399 | typedef virDomainDiskError *virDomainDiskErrorPtr; 1400 | 1401 | struct _virDomainDiskError { 1402 | char *disk; /* disk target */ 1403 | int error; /* virDomainDiskErrorCode */ 1404 | }; 1405 | 1406 | int virDomainGetDiskErrors(virDomainPtr dom, 1407 | virDomainDiskErrorPtr errors, 1408 | unsigned int maxerrors, 1409 | unsigned int flags); 1410 | ]] 1411 | 1412 | ffi.cdef[[ 1413 | 1414 | typedef enum { 1415 | VIR_KEYCODE_SET_LINUX = 0, 1416 | VIR_KEYCODE_SET_XT = 1, 1417 | VIR_KEYCODE_SET_ATSET1 = 2, 1418 | VIR_KEYCODE_SET_ATSET2 = 3, 1419 | VIR_KEYCODE_SET_ATSET3 = 4, 1420 | VIR_KEYCODE_SET_OSX = 5, 1421 | VIR_KEYCODE_SET_XT_KBD = 6, 1422 | VIR_KEYCODE_SET_USB = 7, 1423 | VIR_KEYCODE_SET_WIN32 = 8, 1424 | VIR_KEYCODE_SET_RFB = 9, 1425 | 1426 | VIR_KEYCODE_SET_LAST 1427 | 1428 | } virKeycodeSet; 1429 | ]] 1430 | 1431 | export.VIR_DOMAIN_SEND_KEY_MAX_KEYS = 16; 1432 | 1433 | ffi.cdef[[ 1434 | int virDomainSendKey(virDomainPtr domain, 1435 | unsigned int codeset, 1436 | unsigned int holdtime, 1437 | unsigned int *keycodes, 1438 | int nkeycodes, 1439 | unsigned int flags); 1440 | ]] 1441 | 1442 | ffi.cdef[[ 1443 | 1444 | typedef enum { 1445 | VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0, /* No constant in POSIX/Linux */ 1446 | VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1, /* SIGHUP */ 1447 | VIR_DOMAIN_PROCESS_SIGNAL_INT = 2, /* SIGINT */ 1448 | VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3, /* SIGQUIT */ 1449 | VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4, /* SIGILL */ 1450 | VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5, /* SIGTRAP */ 1451 | VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6, /* SIGABRT */ 1452 | VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7, /* SIGBUS */ 1453 | VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8, /* SIGFPE */ 1454 | VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9, /* SIGKILL */ 1455 | 1456 | VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10, /* SIGUSR1 */ 1457 | VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11, /* SIGSEGV */ 1458 | VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12, /* SIGUSR2 */ 1459 | VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13, /* SIGPIPE */ 1460 | VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14, /* SIGALRM */ 1461 | VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15, /* SIGTERM */ 1462 | VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16, /* Not in POSIX (SIGSTKFLT on Linux )*/ 1463 | VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17, /* SIGCHLD */ 1464 | VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18, /* SIGCONT */ 1465 | VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19, /* SIGSTOP */ 1466 | 1467 | VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20, /* SIGTSTP */ 1468 | VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21, /* SIGTTIN */ 1469 | VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22, /* SIGTTOU */ 1470 | VIR_DOMAIN_PROCESS_SIGNAL_URG = 23, /* SIGURG */ 1471 | VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24, /* SIGXCPU */ 1472 | VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25, /* SIGXFSZ */ 1473 | VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26, /* SIGVTALRM */ 1474 | VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27, /* SIGPROF */ 1475 | VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28, /* Not in POSIX (SIGWINCH on Linux) */ 1476 | VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29, /* SIGPOLL (also known as SIGIO on Linux) */ 1477 | 1478 | VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30, /* Not in POSIX (SIGPWR on Linux) */ 1479 | VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31, /* SIGSYS (also known as SIGUNUSED on Linux) */ 1480 | VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32, /* SIGRTMIN */ 1481 | VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33, /* SIGRTMIN + 1 */ 1482 | VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34, /* SIGRTMIN + 2 */ 1483 | VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35, /* SIGRTMIN + 3 */ 1484 | VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36, /* SIGRTMIN + 4 */ 1485 | VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37, /* SIGRTMIN + 5 */ 1486 | VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38, /* SIGRTMIN + 6 */ 1487 | VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39, /* SIGRTMIN + 7 */ 1488 | 1489 | VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40, /* SIGRTMIN + 8 */ 1490 | VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41, /* SIGRTMIN + 9 */ 1491 | VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42, /* SIGRTMIN + 10 */ 1492 | VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43, /* SIGRTMIN + 11 */ 1493 | VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44, /* SIGRTMIN + 12 */ 1494 | VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45, /* SIGRTMIN + 13 */ 1495 | VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46, /* SIGRTMIN + 14 */ 1496 | VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47, /* SIGRTMIN + 15 */ 1497 | VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48, /* SIGRTMIN + 16 */ 1498 | VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49, /* SIGRTMIN + 17 */ 1499 | 1500 | VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50, /* SIGRTMIN + 18 */ 1501 | VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51, /* SIGRTMIN + 19 */ 1502 | VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52, /* SIGRTMIN + 20 */ 1503 | VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53, /* SIGRTMIN + 21 */ 1504 | VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54, /* SIGRTMIN + 22 */ 1505 | VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55, /* SIGRTMIN + 23 */ 1506 | VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56, /* SIGRTMIN + 24 */ 1507 | VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57, /* SIGRTMIN + 25 */ 1508 | VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58, /* SIGRTMIN + 26 */ 1509 | VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59, /* SIGRTMIN + 27 */ 1510 | 1511 | VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60, /* SIGRTMIN + 28 */ 1512 | VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61, /* SIGRTMIN + 29 */ 1513 | VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62, /* SIGRTMIN + 30 */ 1514 | VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63, /* SIGRTMIN + 31 */ 1515 | VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64, /* SIGRTMIN + 32 / SIGRTMAX */ 1516 | 1517 | VIR_DOMAIN_PROCESS_SIGNAL_LAST 1518 | } virDomainProcessSignal; 1519 | 1520 | int virDomainSendProcessSignal(virDomainPtr domain, 1521 | long long pid_value, 1522 | unsigned int signum, 1523 | unsigned int flags); 1524 | ]] 1525 | 1526 | 1527 | ffi.cdef[[ 1528 | /* 1529 | * Domain Event Notification 1530 | */ 1531 | 1532 | 1533 | typedef enum { 1534 | VIR_DOMAIN_EVENT_DEFINED = 0, 1535 | VIR_DOMAIN_EVENT_UNDEFINED = 1, 1536 | VIR_DOMAIN_EVENT_STARTED = 2, 1537 | VIR_DOMAIN_EVENT_SUSPENDED = 3, 1538 | VIR_DOMAIN_EVENT_RESUMED = 4, 1539 | VIR_DOMAIN_EVENT_STOPPED = 5, 1540 | VIR_DOMAIN_EVENT_SHUTDOWN = 6, 1541 | VIR_DOMAIN_EVENT_PMSUSPENDED = 7, 1542 | VIR_DOMAIN_EVENT_CRASHED = 8, 1543 | 1544 | VIR_DOMAIN_EVENT_LAST 1545 | } virDomainEventType; 1546 | 1547 | 1548 | typedef enum { 1549 | VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, /* Newly created config file */ 1550 | VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, /* Changed config file */ 1551 | 1552 | VIR_DOMAIN_EVENT_DEFINED_LAST 1553 | } virDomainEventDefinedDetailType; 1554 | 1555 | 1556 | typedef enum { 1557 | VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, /* Deleted the config file */ 1558 | 1559 | VIR_DOMAIN_EVENT_UNDEFINED_LAST 1560 | 1561 | } virDomainEventUndefinedDetailType; 1562 | 1563 | 1564 | typedef enum { 1565 | VIR_DOMAIN_EVENT_STARTED_BOOTED = 0, /* Normal startup from boot */ 1566 | VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1, /* Incoming migration from another host */ 1567 | VIR_DOMAIN_EVENT_STARTED_RESTORED = 2, /* Restored from a state file */ 1568 | VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3, /* Restored from snapshot */ 1569 | VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4, /* Started due to wakeup event */ 1570 | 1571 | VIR_DOMAIN_EVENT_STARTED_LAST 1572 | 1573 | } virDomainEventStartedDetailType; 1574 | 1575 | 1576 | typedef enum { 1577 | VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0, /* Normal suspend due to admin pause */ 1578 | VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1, /* Suspended for offline migration */ 1579 | VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2, /* Suspended due to a disk I/O error */ 1580 | VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3, /* Suspended due to a watchdog firing */ 1581 | VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4, /* Restored from paused state file */ 1582 | VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5, /* Restored from paused snapshot */ 1583 | VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6, /* suspended after failure during libvirt API call */ 1584 | 1585 | VIR_DOMAIN_EVENT_SUSPENDED_LAST 1586 | 1587 | } virDomainEventSuspendedDetailType; 1588 | 1589 | 1590 | typedef enum { 1591 | VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0, /* Normal resume due to admin unpause */ 1592 | VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1, /* Resumed for completion of migration */ 1593 | VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2, /* Resumed from snapshot */ 1594 | 1595 | VIR_DOMAIN_EVENT_RESUMED_LAST 1596 | } virDomainEventResumedDetailType; 1597 | 1598 | 1599 | typedef enum { 1600 | VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0, /* Normal shutdown */ 1601 | VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1, /* Forced poweroff from host */ 1602 | VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2, /* Guest crashed */ 1603 | VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3, /* Migrated off to another host */ 1604 | VIR_DOMAIN_EVENT_STOPPED_SAVED = 4, /* Saved to a state file */ 1605 | VIR_DOMAIN_EVENT_STOPPED_FAILED = 5, /* Host emulator/mgmt failed */ 1606 | VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6, /* offline snapshot loaded */ 1607 | 1608 | VIR_DOMAIN_EVENT_STOPPED_LAST 1609 | } virDomainEventStoppedDetailType; 1610 | 1611 | 1612 | 1613 | typedef enum { 1614 | VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, /* Guest finished shutdown sequence */ 1615 | 1616 | VIR_DOMAIN_EVENT_SHUTDOWN_LAST 1617 | } virDomainEventShutdownDetailType; 1618 | 1619 | typedef enum { 1620 | VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, /* Guest was PM suspended to memory */ 1621 | VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, /* Guest was PM suspended to disk */ 1622 | 1623 | VIR_DOMAIN_EVENT_PMSUSPENDED_LAST 1624 | } virDomainEventPMSuspendedDetailType; 1625 | 1626 | 1627 | typedef enum { 1628 | VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, /* Guest was panicked */ 1629 | 1630 | VIR_DOMAIN_EVENT_CRASHED_LAST 1631 | } virDomainEventCrashedDetailType; 1632 | ]] 1633 | 1634 | ffi.cdef[[ 1635 | 1636 | typedef int (*virConnectDomainEventCallback)(virConnectPtr conn, 1637 | virDomainPtr dom, 1638 | int event, 1639 | int detail, 1640 | void *opaque); 1641 | 1642 | int virConnectDomainEventRegister(virConnectPtr conn, 1643 | virConnectDomainEventCallback cb, 1644 | void *opaque, 1645 | virFreeCallback freecb); 1646 | 1647 | int virConnectDomainEventDeregister(virConnectPtr conn, 1648 | virConnectDomainEventCallback cb); 1649 | 1650 | 1651 | int virDomainIsActive(virDomainPtr dom); 1652 | int virDomainIsPersistent(virDomainPtr dom); 1653 | int virDomainIsUpdated(virDomainPtr dom); 1654 | 1655 | typedef enum { 1656 | VIR_DOMAIN_JOB_NONE = 0, /* No job is active */ 1657 | VIR_DOMAIN_JOB_BOUNDED = 1, /* Job with a finite completion time */ 1658 | VIR_DOMAIN_JOB_UNBOUNDED = 2, /* Job without a finite completion time */ 1659 | VIR_DOMAIN_JOB_COMPLETED = 3, /* Job has finished, but isn't cleaned up */ 1660 | VIR_DOMAIN_JOB_FAILED = 4, /* Job hit error, but isn't cleaned up */ 1661 | VIR_DOMAIN_JOB_CANCELLED = 5, /* Job was aborted, but isn't cleaned up */ 1662 | 1663 | VIR_DOMAIN_JOB_LAST 1664 | } virDomainJobType; 1665 | 1666 | typedef struct _virDomainJobInfo virDomainJobInfo; 1667 | typedef virDomainJobInfo *virDomainJobInfoPtr; 1668 | struct _virDomainJobInfo { 1669 | /* One of virDomainJobType */ 1670 | int type; 1671 | 1672 | /* Time is measured in milliseconds */ 1673 | unsigned long long timeElapsed; /* Always set */ 1674 | unsigned long long timeRemaining; /* Only for VIR_DOMAIN_JOB_BOUNDED */ 1675 | 1676 | 1677 | unsigned long long dataTotal; 1678 | unsigned long long dataProcessed; 1679 | unsigned long long dataRemaining; 1680 | 1681 | /* As above, but only tracking guest memory progress */ 1682 | unsigned long long memTotal; 1683 | unsigned long long memProcessed; 1684 | unsigned long long memRemaining; 1685 | 1686 | /* As above, but only tracking guest disk file progress */ 1687 | unsigned long long fileTotal; 1688 | unsigned long long fileProcessed; 1689 | unsigned long long fileRemaining; 1690 | }; 1691 | 1692 | 1693 | typedef enum { 1694 | VIR_DOMAIN_JOB_STATS_COMPLETED = 1 << 0, /* return stats of a recently 1695 | * completed job */ 1696 | } virDomainGetJobStatsFlags; 1697 | 1698 | int virDomainGetJobInfo(virDomainPtr dom, 1699 | virDomainJobInfoPtr info); 1700 | int virDomainGetJobStats(virDomainPtr domain, 1701 | int *type, 1702 | virTypedParameterPtr *params, 1703 | int *nparams, 1704 | unsigned int flags); 1705 | int virDomainAbortJob(virDomainPtr dom); 1706 | ]] 1707 | 1708 | export.VIR_DOMAIN_JOB_TIME_ELAPSED = "time_elapsed" 1709 | 1710 | export.VIR_DOMAIN_JOB_TIME_REMAINING ="time_remaining" 1711 | 1712 | export.VIR_DOMAIN_JOB_DOWNTIME = "downtime" 1713 | 1714 | export.VIR_DOMAIN_JOB_SETUP_TIME = "setup_time" 1715 | 1716 | export.VIR_DOMAIN_JOB_DATA_TOTAL = "data_total" 1717 | 1718 | export.VIR_DOMAIN_JOB_DATA_PROCESSED = "data_processed" 1719 | 1720 | export.VIR_DOMAIN_JOB_DATA_REMAINING = "data_remaining" 1721 | 1722 | export.VIR_DOMAIN_JOB_MEMORY_TOTAL = "memory_total" 1723 | 1724 | export.VIR_DOMAIN_JOB_MEMORY_PROCESSED = "memory_processed" 1725 | 1726 | export.VIR_DOMAIN_JOB_MEMORY_REMAINING = "memory_remaining" 1727 | 1728 | export.VIR_DOMAIN_JOB_MEMORY_CONSTANT = "memory_constant" 1729 | 1730 | export.VIR_DOMAIN_JOB_MEMORY_NORMAL = "memory_normal" 1731 | 1732 | export.VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES = "memory_normal_bytes" 1733 | 1734 | export.VIR_DOMAIN_JOB_MEMORY_BPS = "memory_bps" 1735 | 1736 | export.VIR_DOMAIN_JOB_DISK_TOTAL = "disk_total" 1737 | 1738 | export.VIR_DOMAIN_JOB_DISK_PROCESSED = "disk_processed" 1739 | 1740 | export.VIR_DOMAIN_JOB_DISK_REMAINING = "disk_remaining" 1741 | 1742 | export.VIR_DOMAIN_JOB_DISK_BPS = "disk_bps" 1743 | 1744 | export.VIR_DOMAIN_JOB_COMPRESSION_CACHE = "compression_cache" 1745 | 1746 | export.VIR_DOMAIN_JOB_COMPRESSION_BYTES = "compression_bytes" 1747 | 1748 | export.VIR_DOMAIN_JOB_COMPRESSION_PAGES = "compression_pages" 1749 | 1750 | export.VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES= "compression_cache_misses" 1751 | 1752 | export.VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW = "compression_overflow" 1753 | 1754 | 1755 | ffi.cdef[[ 1756 | 1757 | typedef void (*virConnectDomainEventGenericCallback)(virConnectPtr conn, 1758 | virDomainPtr dom, 1759 | void *opaque); 1760 | 1761 | 1762 | typedef void (*virConnectDomainEventRTCChangeCallback)(virConnectPtr conn, 1763 | virDomainPtr dom, 1764 | long long utcoffset, 1765 | void *opaque); 1766 | 1767 | 1768 | typedef enum { 1769 | VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, /* No action, watchdog ignored */ 1770 | VIR_DOMAIN_EVENT_WATCHDOG_PAUSE, /* Guest CPUs are paused */ 1771 | VIR_DOMAIN_EVENT_WATCHDOG_RESET, /* Guest CPUs are reset */ 1772 | VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF, /* Guest is forcibly powered off */ 1773 | VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN, /* Guest is requested to gracefully shutdown */ 1774 | VIR_DOMAIN_EVENT_WATCHDOG_DEBUG, /* No action, a debug message logged */ 1775 | 1776 | VIR_DOMAIN_EVENT_WATCHDOG_LAST 1777 | 1778 | } virDomainEventWatchdogAction; 1779 | 1780 | 1781 | typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn, 1782 | virDomainPtr dom, 1783 | int action, 1784 | void *opaque); 1785 | 1786 | 1787 | typedef enum { 1788 | VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, /* No action, IO error ignored */ 1789 | VIR_DOMAIN_EVENT_IO_ERROR_PAUSE, /* Guest CPUs are paused */ 1790 | VIR_DOMAIN_EVENT_IO_ERROR_REPORT, /* IO error reported to guest OS */ 1791 | 1792 | VIR_DOMAIN_EVENT_IO_ERROR_LAST 1793 | 1794 | } virDomainEventIOErrorAction; 1795 | 1796 | 1797 | 1798 | typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn, 1799 | virDomainPtr dom, 1800 | const char *srcPath, 1801 | const char *devAlias, 1802 | int action, 1803 | void *opaque); 1804 | 1805 | 1806 | typedef void (*virConnectDomainEventIOErrorReasonCallback)(virConnectPtr conn, 1807 | virDomainPtr dom, 1808 | const char *srcPath, 1809 | const char *devAlias, 1810 | int action, 1811 | const char *reason, 1812 | void *opaque); 1813 | 1814 | 1815 | typedef enum { 1816 | VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, /* Initial socket connection established */ 1817 | VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE, /* Authentication & setup completed */ 1818 | VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT, /* Final socket disconnection */ 1819 | 1820 | VIR_DOMAIN_EVENT_GRAPHICS_LAST 1821 | 1822 | } virDomainEventGraphicsPhase; 1823 | 1824 | 1825 | typedef enum { 1826 | VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4, /* IPv4 address */ 1827 | VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6, /* IPv6 address */ 1828 | VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX, /* UNIX socket path */ 1829 | 1830 | VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_LAST 1831 | } virDomainEventGraphicsAddressType; 1832 | 1833 | 1834 | 1835 | struct _virDomainEventGraphicsAddress { 1836 | int family; /* Address family, virDomainEventGraphicsAddressType */ 1837 | char *node; /* Address of node (eg IP address, or UNIX path) */ 1838 | char *service; /* Service name/number (eg TCP port, or NULL) */ 1839 | }; 1840 | typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress; 1841 | typedef virDomainEventGraphicsAddress *virDomainEventGraphicsAddressPtr; 1842 | ]] 1843 | 1844 | ffi.cdef[[ 1845 | struct _virDomainEventGraphicsSubjectIdentity { 1846 | char *type; /* Type of identity */ 1847 | char *name; /* Identity value */ 1848 | }; 1849 | typedef struct _virDomainEventGraphicsSubjectIdentity virDomainEventGraphicsSubjectIdentity; 1850 | typedef virDomainEventGraphicsSubjectIdentity *virDomainEventGraphicsSubjectIdentityPtr; 1851 | 1852 | 1853 | 1854 | struct _virDomainEventGraphicsSubject { 1855 | int nidentity; /* Number of identities in array*/ 1856 | virDomainEventGraphicsSubjectIdentityPtr identities; /* Array of identities for subject */ 1857 | }; 1858 | typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject; 1859 | typedef virDomainEventGraphicsSubject *virDomainEventGraphicsSubjectPtr; 1860 | ]] 1861 | 1862 | ffi.cdef[[ 1863 | 1864 | typedef void (*virConnectDomainEventGraphicsCallback)(virConnectPtr conn, 1865 | virDomainPtr dom, 1866 | int phase, 1867 | const virDomainEventGraphicsAddress *local, 1868 | const virDomainEventGraphicsAddress *remote, 1869 | const char *authScheme, 1870 | const virDomainEventGraphicsSubject *subject, 1871 | void *opaque); 1872 | 1873 | 1874 | typedef enum { 1875 | VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, 1876 | VIR_DOMAIN_BLOCK_JOB_FAILED = 1, 1877 | VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, 1878 | VIR_DOMAIN_BLOCK_JOB_READY = 3, 1879 | 1880 | VIR_DOMAIN_BLOCK_JOB_LAST 1881 | 1882 | } virConnectDomainEventBlockJobStatus; 1883 | 1884 | 1885 | typedef void (*virConnectDomainEventBlockJobCallback)(virConnectPtr conn, 1886 | virDomainPtr dom, 1887 | const char *disk, 1888 | int type, 1889 | int status, 1890 | void *opaque); 1891 | 1892 | 1893 | typedef enum { 1894 | VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, /* oldSrcPath is set */ 1895 | VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, 1896 | 1897 | VIR_DOMAIN_EVENT_DISK_CHANGE_LAST 1898 | } virConnectDomainEventDiskChangeReason; 1899 | 1900 | 1901 | typedef void (*virConnectDomainEventDiskChangeCallback)(virConnectPtr conn, 1902 | virDomainPtr dom, 1903 | const char *oldSrcPath, 1904 | const char *newSrcPath, 1905 | const char *devAlias, 1906 | int reason, 1907 | void *opaque); 1908 | 1909 | 1910 | typedef enum { 1911 | VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, 1912 | VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE, 1913 | 1914 | VIR_DOMAIN_EVENT_TRAY_CHANGE_LAST 1915 | } virDomainEventTrayChangeReason; 1916 | 1917 | 1918 | typedef void (*virConnectDomainEventTrayChangeCallback)(virConnectPtr conn, 1919 | virDomainPtr dom, 1920 | const char *devAlias, 1921 | int reason, 1922 | void *opaque); 1923 | 1924 | 1925 | typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn, 1926 | virDomainPtr dom, 1927 | int reason, 1928 | void *opaque); 1929 | 1930 | 1931 | typedef void (*virConnectDomainEventPMSuspendCallback)(virConnectPtr conn, 1932 | virDomainPtr dom, 1933 | int reason, 1934 | void *opaque); 1935 | 1936 | 1937 | 1938 | typedef void (*virConnectDomainEventBalloonChangeCallback)(virConnectPtr conn, 1939 | virDomainPtr dom, 1940 | unsigned long long actual, 1941 | void *opaque); 1942 | 1943 | 1944 | typedef void (*virConnectDomainEventPMSuspendDiskCallback)(virConnectPtr conn, 1945 | virDomainPtr dom, 1946 | int reason, 1947 | void *opaque); 1948 | 1949 | 1950 | typedef void (*virConnectDomainEventDeviceRemovedCallback)(virConnectPtr conn, 1951 | virDomainPtr dom, 1952 | const char *devAlias, 1953 | void *opaque); 1954 | ]] 1955 | 1956 | export.VIR_DOMAIN_TUNABLE_CPU_VCPUPIN ="cputune.vcpupin%u"; 1957 | 1958 | 1959 | export.VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN ="cputune.emulatorpin"; 1960 | 1961 | 1962 | export.VIR_DOMAIN_TUNABLE_CPU_IOTHREADSPIN ="cputune.iothreadpin%u"; 1963 | 1964 | 1965 | export.VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES ="cputune.cpu_shares"; 1966 | 1967 | 1968 | export.VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD ="cputune.vcpu_period"; 1969 | 1970 | 1971 | export.VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA ="cputune.vcpu_quota"; 1972 | 1973 | 1974 | export.VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD ="cputune.emulator_period"; 1975 | 1976 | 1977 | export.VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA ="cputune.emulator_quota"; 1978 | 1979 | 1980 | export.VIR_DOMAIN_TUNABLE_BLKDEV_DISK ="blkdeviotune.disk"; 1981 | 1982 | 1983 | export.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC ="blkdeviotune.total_bytes_sec"; 1984 | 1985 | 1986 | export.VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC ="blkdeviotune.read_bytes_sec"; 1987 | 1988 | 1989 | export.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC ="blkdeviotune.write_bytes_sec"; 1990 | 1991 | 1992 | export.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC ="blkdeviotune.total_iops_sec"; 1993 | 1994 | 1995 | export.VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC ="blkdeviotune.read_iops_sec"; 1996 | 1997 | 1998 | export.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC ="blkdeviotune.write_iops_sec"; 1999 | 2000 | 2001 | export.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC_MAX ="blkdeviotune.total_bytes_sec_max"; 2002 | 2003 | 2004 | export.VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC_MAX ="blkdeviotune.read_bytes_sec_max"; 2005 | 2006 | 2007 | export.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC_MAX ="blkdeviotune.write_bytes_sec_max"; 2008 | 2009 | 2010 | export.VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC_MAX ="blkdeviotune.total_iops_sec_max"; 2011 | 2012 | 2013 | export.VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC_MAX ="blkdeviotune.read_iops_sec_max"; 2014 | 2015 | 2016 | export.VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC_MAX ="blkdeviotune.write_iops_sec_max"; 2017 | 2018 | 2019 | export.VIR_DOMAIN_TUNABLE_BLKDEV_SIZE_IOPS_SEC ="blkdeviotune.size_iops_sec"; 2020 | 2021 | ffi.cdef[[ 2022 | 2023 | typedef void (*virConnectDomainEventTunableCallback)(virConnectPtr conn, 2024 | virDomainPtr dom, 2025 | virTypedParameterPtr params, 2026 | int nparams, 2027 | void *opaque); 2028 | 2029 | 2030 | typedef enum { 2031 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_CONNECTED = 1, /* agent connected */ 2032 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_DISCONNECTED = 2, /* agent disconnected */ 2033 | 2034 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_LAST 2035 | } virConnectDomainEventAgentLifecycleState; 2036 | 2037 | typedef enum { 2038 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_UNKNOWN = 0, /* unknown state change reason */ 2039 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED = 1, /* state changed due to domain start */ 2040 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL = 2, /* channel state changed */ 2041 | 2042 | VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_LAST 2043 | } virConnectDomainEventAgentLifecycleReason; 2044 | 2045 | 2046 | typedef void (*virConnectDomainEventAgentLifecycleCallback)(virConnectPtr conn, 2047 | virDomainPtr dom, 2048 | int state, 2049 | int reason, 2050 | void *opaque); 2051 | ]] 2052 | 2053 | 2054 | --# define VIR_DOMAIN_EVENT_CALLBACK(cb) ((virConnectDomainEventGenericCallback)(cb)) 2055 | 2056 | ffi.cdef[[ 2057 | 2058 | typedef enum { 2059 | VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, /* virConnectDomainEventCallback */ 2060 | VIR_DOMAIN_EVENT_ID_REBOOT = 1, /* virConnectDomainEventGenericCallback */ 2061 | VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2, /* virConnectDomainEventRTCChangeCallback */ 2062 | VIR_DOMAIN_EVENT_ID_WATCHDOG = 3, /* virConnectDomainEventWatchdogCallback */ 2063 | VIR_DOMAIN_EVENT_ID_IO_ERROR = 4, /* virConnectDomainEventIOErrorCallback */ 2064 | VIR_DOMAIN_EVENT_ID_GRAPHICS = 5, /* virConnectDomainEventGraphicsCallback */ 2065 | VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6, /* virConnectDomainEventIOErrorReasonCallback */ 2066 | VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7, /* virConnectDomainEventGenericCallback */ 2067 | VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8, /* virConnectDomainEventBlockJobCallback */ 2068 | VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9, /* virConnectDomainEventDiskChangeCallback */ 2069 | VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10, /* virConnectDomainEventTrayChangeCallback */ 2070 | VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11, /* virConnectDomainEventPMWakeupCallback */ 2071 | VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12, /* virConnectDomainEventPMSuspendCallback */ 2072 | VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13, /* virConnectDomainEventBalloonChangeCallback */ 2073 | VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14, /* virConnectDomainEventPMSuspendDiskCallback */ 2074 | VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15, /* virConnectDomainEventDeviceRemovedCallback */ 2075 | VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16, /* virConnectDomainEventBlockJobCallback */ 2076 | VIR_DOMAIN_EVENT_ID_TUNABLE = 17, /* virConnectDomainEventTunableCallback */ 2077 | VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18,/* virConnectDomainEventAgentLifecycleCallback */ 2078 | 2079 | VIR_DOMAIN_EVENT_ID_LAST 2080 | 2081 | } virDomainEventID; 2082 | 2083 | 2084 | /* Use VIR_DOMAIN_EVENT_CALLBACK() to cast the 'cb' parameter */ 2085 | int virConnectDomainEventRegisterAny(virConnectPtr conn, 2086 | virDomainPtr dom, /* Optional, to filter */ 2087 | int eventID, 2088 | virConnectDomainEventGenericCallback cb, 2089 | void *opaque, 2090 | virFreeCallback freecb); 2091 | 2092 | int virConnectDomainEventDeregisterAny(virConnectPtr conn, 2093 | int callbackID); 2094 | 2095 | 2096 | typedef enum { 2097 | 2098 | VIR_DOMAIN_CONSOLE_FORCE = (1 << 0), /* abort a (possibly) active console 2099 | connection to force a new 2100 | connection */ 2101 | VIR_DOMAIN_CONSOLE_SAFE = (1 << 1), /* check if the console driver supports 2102 | safe console operations */ 2103 | } virDomainConsoleFlags; 2104 | 2105 | int virDomainOpenConsole(virDomainPtr dom, 2106 | const char *dev_name, 2107 | virStreamPtr st, 2108 | unsigned int flags); 2109 | 2110 | 2111 | typedef enum { 2112 | VIR_DOMAIN_CHANNEL_FORCE = (1 << 0), /* abort a (possibly) active channel 2113 | connection to force a new 2114 | connection */ 2115 | } virDomainChannelFlags; 2116 | 2117 | int virDomainOpenChannel(virDomainPtr dom, 2118 | const char *name, 2119 | virStreamPtr st, 2120 | unsigned int flags); 2121 | 2122 | typedef enum { 2123 | VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = (1 << 0), 2124 | } virDomainOpenGraphicsFlags; 2125 | 2126 | int virDomainOpenGraphics(virDomainPtr dom, 2127 | unsigned int idx, 2128 | int fd, 2129 | unsigned int flags); 2130 | 2131 | int virDomainOpenGraphicsFD(virDomainPtr dom, 2132 | unsigned int idx, 2133 | unsigned int flags); 2134 | 2135 | int virDomainInjectNMI(virDomainPtr domain, unsigned int flags); 2136 | 2137 | int virDomainFSTrim(virDomainPtr dom, 2138 | const char *mountPoint, 2139 | unsigned long long minimum, 2140 | unsigned int flags); 2141 | 2142 | int virDomainFSFreeze(virDomainPtr dom, 2143 | const char **mountpoints, 2144 | unsigned int nmountpoints, 2145 | unsigned int flags); 2146 | 2147 | int virDomainFSThaw(virDomainPtr dom, 2148 | const char **mountpoints, 2149 | unsigned int nmountpoints, 2150 | unsigned int flags); 2151 | ]] 2152 | 2153 | ffi.cdef[[ 2154 | typedef struct _virDomainFSInfo virDomainFSInfo; 2155 | typedef virDomainFSInfo *virDomainFSInfoPtr; 2156 | struct _virDomainFSInfo { 2157 | char *mountpoint; /* path to mount point */ 2158 | char *name; /* device name in the guest (e.g. "sda1") */ 2159 | char *fstype; /* filesystem type */ 2160 | size_t ndevAlias; /* number of elements in devAlias */ 2161 | char **devAlias; /* array of disk device aliases */ 2162 | }; 2163 | 2164 | void virDomainFSInfoFree(virDomainFSInfoPtr info); 2165 | 2166 | int virDomainGetFSInfo(virDomainPtr dom, 2167 | virDomainFSInfoPtr **info, 2168 | unsigned int flags); 2169 | 2170 | int virDomainGetTime(virDomainPtr dom, 2171 | long long *seconds, 2172 | unsigned int *nseconds, 2173 | unsigned int flags); 2174 | 2175 | typedef enum { 2176 | VIR_DOMAIN_TIME_SYNC = (1 << 0), /* Re-sync domain time from domain's RTC */ 2177 | } virDomainSetTimeFlags; 2178 | 2179 | int virDomainSetTime(virDomainPtr dom, 2180 | long long seconds, 2181 | unsigned int nseconds, 2182 | unsigned int flags); 2183 | ]] 2184 | 2185 | --[[ 2186 | /** 2187 | * virSchedParameterType: 2188 | * 2189 | * A scheduler parameter field type. Provided for backwards 2190 | * compatibility; virTypedParameterType is the preferred enum since 2191 | * 0.9.2. 2192 | */ 2193 | typedef enum { 2194 | VIR_DOMAIN_SCHED_FIELD_INT = VIR_TYPED_PARAM_INT, 2195 | VIR_DOMAIN_SCHED_FIELD_UINT = VIR_TYPED_PARAM_UINT, 2196 | VIR_DOMAIN_SCHED_FIELD_LLONG = VIR_TYPED_PARAM_LLONG, 2197 | VIR_DOMAIN_SCHED_FIELD_ULLONG = VIR_TYPED_PARAM_ULLONG, 2198 | VIR_DOMAIN_SCHED_FIELD_DOUBLE = VIR_TYPED_PARAM_DOUBLE, 2199 | VIR_DOMAIN_SCHED_FIELD_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, 2200 | } virSchedParameterType; 2201 | --]] 2202 | 2203 | ffi.cdef[[ 2204 | static const int VIR_DOMAIN_SCHED_FIELD_LENGTH = VIR_TYPED_PARAM_FIELD_LENGTH; 2205 | 2206 | /** 2207 | * virSchedParameter: 2208 | * 2209 | * a virSchedParameter is the set of scheduler parameters. 2210 | * Provided for backwards compatibility; virTypedParameter is the 2211 | * preferred alias since 0.9.2. 2212 | */ 2213 | //# define _virSchedParameter _virTypedParameter 2214 | typedef struct _virTypedParameter virSchedParameter; 2215 | 2216 | /** 2217 | * virSchedParameterPtr: 2218 | * 2219 | * a virSchedParameterPtr is a pointer to a virSchedParameter structure. 2220 | * Provided for backwards compatibility; virTypedParameterPtr is the 2221 | * preferred alias since 0.9.2. 2222 | */ 2223 | typedef virSchedParameter *virSchedParameterPtr; 2224 | ]] 2225 | 2226 | --[[ 2227 | /** 2228 | * virBlkioParameterType: 2229 | * 2230 | * A blkio parameter field type. Provided for backwards 2231 | * compatibility; virTypedParameterType is the preferred enum since 2232 | * 0.9.2. 2233 | */ 2234 | typedef enum { 2235 | VIR_DOMAIN_BLKIO_PARAM_INT = VIR_TYPED_PARAM_INT, 2236 | VIR_DOMAIN_BLKIO_PARAM_UINT = VIR_TYPED_PARAM_UINT, 2237 | VIR_DOMAIN_BLKIO_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, 2238 | VIR_DOMAIN_BLKIO_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, 2239 | VIR_DOMAIN_BLKIO_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, 2240 | VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, 2241 | } virBlkioParameterType; 2242 | --]] 2243 | 2244 | --[[ 2245 | /** 2246 | * VIR_DOMAIN_BLKIO_FIELD_LENGTH: 2247 | * 2248 | * Macro providing the field length of virBlkioParameter. Provided 2249 | * for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the 2250 | * preferred value since 0.9.2. 2251 | */ 2252 | # define VIR_DOMAIN_BLKIO_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH 2253 | --]] 2254 | 2255 | --[[ 2256 | /** 2257 | * virBlkioParameter: 2258 | * 2259 | * a virBlkioParameter is the set of blkio parameters. 2260 | * Provided for backwards compatibility; virTypedParameter is the 2261 | * preferred alias since 0.9.2. 2262 | */ 2263 | # define _virBlkioParameter _virTypedParameter 2264 | typedef struct _virTypedParameter virBlkioParameter; 2265 | --]] 2266 | 2267 | --[[ 2268 | /** 2269 | * virBlkioParameterPtr: 2270 | * 2271 | * a virBlkioParameterPtr is a pointer to a virBlkioParameter structure. 2272 | * Provided for backwards compatibility; virTypedParameterPtr is the 2273 | * preferred alias since 0.9.2. 2274 | */ 2275 | typedef virBlkioParameter *virBlkioParameterPtr; 2276 | 2277 | /** 2278 | * virMemoryParameterType: 2279 | * 2280 | * A memory parameter field type. Provided for backwards 2281 | * compatibility; virTypedParameterType is the preferred enum since 2282 | * 0.9.2. 2283 | */ 2284 | typedef enum { 2285 | VIR_DOMAIN_MEMORY_PARAM_INT = VIR_TYPED_PARAM_INT, 2286 | VIR_DOMAIN_MEMORY_PARAM_UINT = VIR_TYPED_PARAM_UINT, 2287 | VIR_DOMAIN_MEMORY_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, 2288 | VIR_DOMAIN_MEMORY_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, 2289 | VIR_DOMAIN_MEMORY_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, 2290 | VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, 2291 | } virMemoryParameterType; 2292 | --]] 2293 | 2294 | --[[ 2295 | static const int VIR_DOMAIN_MEMORY_FIELD_LENGTH = VIR_TYPED_PARAM_FIELD_LENGTH; 2296 | 2297 | 2298 | //# define _virMemoryParameter _virTypedParameter 2299 | typedef struct _virTypedParameter virMemoryParameter; 2300 | 2301 | 2302 | typedef virMemoryParameter *virMemoryParameterPtr; 2303 | --]] 2304 | 2305 | ffi.cdef[[ 2306 | typedef enum { 2307 | VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0, /* Parse DHCP lease file */ 2308 | VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1, /* Query qemu guest agent */ 2309 | 2310 | VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LAST 2311 | } virDomainInterfaceAddressesSource; 2312 | 2313 | typedef struct _virDomainInterfaceIPAddress virDomainIPAddress; 2314 | typedef virDomainIPAddress *virDomainIPAddressPtr; 2315 | struct _virDomainInterfaceIPAddress { 2316 | int type; /* virIPAddrType */ 2317 | char *addr; /* IP address */ 2318 | unsigned int prefix; /* IP address prefix */ 2319 | }; 2320 | 2321 | typedef struct _virDomainInterface virDomainInterface; 2322 | typedef virDomainInterface *virDomainInterfacePtr; 2323 | struct _virDomainInterface { 2324 | char *name; /* interface name */ 2325 | char *hwaddr; /* hardware address, may be NULL */ 2326 | unsigned int naddrs; /* number of items in @addrs */ 2327 | virDomainIPAddressPtr addrs; /* array of IP addresses */ 2328 | }; 2329 | 2330 | int virDomainInterfaceAddresses(virDomainPtr dom, 2331 | virDomainInterfacePtr **ifaces, 2332 | unsigned int source, 2333 | unsigned int flags); 2334 | 2335 | void virDomainInterfaceFree(virDomainInterfacePtr iface); 2336 | ]] 2337 | 2338 | 2339 | return export 2340 | -------------------------------------------------------------------------------- /libvirt-event.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | typedef enum { 7 | VIR_EVENT_HANDLE_READABLE = (1 << 0), 8 | VIR_EVENT_HANDLE_WRITABLE = (1 << 1), 9 | VIR_EVENT_HANDLE_ERROR = (1 << 2), 10 | VIR_EVENT_HANDLE_HANGUP = (1 << 3), 11 | } virEventHandleType; 12 | 13 | 14 | typedef void (*virEventHandleCallback)(int watch, int fd, int events, void *opaque); 15 | 16 | 17 | typedef int (*virEventAddHandleFunc)(int fd, int event, 18 | virEventHandleCallback cb, 19 | void *opaque, 20 | virFreeCallback ff); 21 | 22 | 23 | typedef void (*virEventUpdateHandleFunc)(int watch, int event); 24 | 25 | 26 | typedef int (*virEventRemoveHandleFunc)(int watch); 27 | 28 | 29 | typedef void (*virEventTimeoutCallback)(int timer, void *opaque); 30 | 31 | 32 | typedef int (*virEventAddTimeoutFunc)(int timeout, 33 | virEventTimeoutCallback cb, 34 | void *opaque, 35 | virFreeCallback ff); 36 | 37 | 38 | typedef void (*virEventUpdateTimeoutFunc)(int timer, int timeout); 39 | 40 | 41 | typedef int (*virEventRemoveTimeoutFunc)(int timer); 42 | 43 | void virEventRegisterImpl(virEventAddHandleFunc addHandle, 44 | virEventUpdateHandleFunc updateHandle, 45 | virEventRemoveHandleFunc removeHandle, 46 | virEventAddTimeoutFunc addTimeout, 47 | virEventUpdateTimeoutFunc updateTimeout, 48 | virEventRemoveTimeoutFunc removeTimeout); 49 | 50 | int virEventRegisterDefaultImpl(void); 51 | int virEventRunDefaultImpl(void); 52 | 53 | int virEventAddHandle(int fd, int events, 54 | virEventHandleCallback cb, 55 | void *opaque, 56 | virFreeCallback ff); 57 | void virEventUpdateHandle(int watch, int events); 58 | int virEventRemoveHandle(int watch); 59 | 60 | int virEventAddTimeout(int frequency, 61 | virEventTimeoutCallback cb, 62 | void *opaque, 63 | virFreeCallback ff); 64 | void virEventUpdateTimeout(int timer, int frequency); 65 | int virEventRemoveTimeout(int timer); 66 | ]] 67 | 68 | return export 69 | -------------------------------------------------------------------------------- /libvirt-host.lua: -------------------------------------------------------------------------------- 1 | --[[ 2 | Copyright (C) 2015 3 | William A Adams 4 | 5 | Based On: 6 | /* 7 | * libvirt-host.h 8 | * Summary: APIs for management of hosts 9 | * Description: Provides APIs for the management of hosts 10 | * Author: Daniel Veillard <veillard@redhat.com> 11 | * 12 | * Copyright (C) 2006-2014 Red Hat, Inc. 13 | * 14 | * This library is free software; you can redistribute it and/or 15 | * modify it under the terms of the GNU Lesser General Public 16 | * License as published by the Free Software Foundation; either 17 | * version 2.1 of the License, or (at your option) any later version. 18 | * 19 | * This library is distributed in the hope that it will be useful, 20 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 | * Lesser General Public License for more details. 23 | * 24 | * You should have received a copy of the GNU Lesser General Public 25 | * License along with this library. If not, see 26 | * <http://www.gnu.org/licenses/>. 27 | */ 28 | --]] 29 | 30 | local ffi = require("ffi") 31 | 32 | local export = {} 33 | 34 | ffi.cdef[[ 35 | typedef void (*virFreeCallback)(void *opaque); 36 | 37 | typedef struct _virConnect virConnect; 38 | typedef virConnect *virConnectPtr; 39 | 40 | typedef enum { 41 | VIR_NODE_SUSPEND_TARGET_MEM = 0, 42 | VIR_NODE_SUSPEND_TARGET_DISK = 1, 43 | VIR_NODE_SUSPEND_TARGET_HYBRID = 2, 44 | 45 | 46 | VIR_NODE_SUSPEND_TARGET_LAST /* This constant is subject to change */ 47 | 48 | } virNodeSuspendTarget; 49 | 50 | 51 | typedef struct _virStream virStream; 52 | typedef virStream *virStreamPtr; 53 | 54 | 55 | static const int VIR_SECURITY_LABEL_BUFLEN = (4096+1); 56 | 57 | typedef struct _virSecurityLabel virSecurityLabel; 58 | 59 | struct _virSecurityLabel { 60 | char label[VIR_SECURITY_LABEL_BUFLEN]; /* security label string */ 61 | int enforcing; /* 1 if security policy is being enforced for domain */ 62 | }; 63 | 64 | 65 | typedef virSecurityLabel *virSecurityLabelPtr; 66 | 67 | 68 | static const int VIR_SECURITY_MODEL_BUFLEN = (256 + 1); 69 | 70 | static const int VIR_SECURITY_DOI_BUFLEN = (256 + 1); 71 | 72 | 73 | typedef struct _virSecurityModel virSecurityModel; 74 | 75 | struct _virSecurityModel { 76 | char model[VIR_SECURITY_MODEL_BUFLEN]; /* security model string */ 77 | char doi[VIR_SECURITY_DOI_BUFLEN]; /* domain of interpretation */ 78 | }; 79 | 80 | typedef virSecurityModel *virSecurityModelPtr; 81 | 82 | 83 | /* Common data types shared among interfaces with name/type/value lists. */ 84 | 85 | 86 | typedef enum { 87 | VIR_TYPED_PARAM_INT = 1, /* integer case */ 88 | VIR_TYPED_PARAM_UINT = 2, /* unsigned integer case */ 89 | VIR_TYPED_PARAM_LLONG = 3, /* long long case */ 90 | VIR_TYPED_PARAM_ULLONG = 4, /* unsigned long long case */ 91 | VIR_TYPED_PARAM_DOUBLE = 5, /* double case */ 92 | VIR_TYPED_PARAM_BOOLEAN = 6, /* boolean(character) case */ 93 | VIR_TYPED_PARAM_STRING = 7, /* string case */ 94 | 95 | VIR_TYPED_PARAM_LAST 96 | } virTypedParameterType; 97 | 98 | 99 | typedef enum { 100 | /* 1 << 0 is reserved for virDomainModificationImpact */ 101 | /* 1 << 1 is reserved for virDomainModificationImpact */ 102 | 103 | VIR_TYPED_PARAM_STRING_OKAY = 1 << 2, 104 | 105 | } virTypedParameterFlags; 106 | 107 | 108 | static const int VIR_TYPED_PARAM_FIELD_LENGTH = 80; 109 | 110 | 111 | typedef struct _virTypedParameter virTypedParameter; 112 | 113 | struct _virTypedParameter { 114 | char field[VIR_TYPED_PARAM_FIELD_LENGTH]; /* parameter name */ 115 | int type; /* parameter type, virTypedParameterType */ 116 | union { 117 | int i; /* type is INT */ 118 | unsigned int ui; /* type is UINT */ 119 | long long int l; /* type is LLONG */ 120 | unsigned long long int ul; /* type is ULLONG */ 121 | double d; /* type is DOUBLE */ 122 | char b; /* type is BOOLEAN */ 123 | char *s; /* type is STRING, may not be NULL */ 124 | } value; /* parameter value */ 125 | }; 126 | 127 | 128 | typedef virTypedParameter *virTypedParameterPtr; 129 | 130 | 131 | virTypedParameterPtr 132 | virTypedParamsGet (virTypedParameterPtr params, 133 | int nparams, 134 | const char *name); 135 | int 136 | virTypedParamsGetInt (virTypedParameterPtr params, 137 | int nparams, 138 | const char *name, 139 | int *value); 140 | int 141 | virTypedParamsGetUInt (virTypedParameterPtr params, 142 | int nparams, 143 | const char *name, 144 | unsigned int *value); 145 | int 146 | virTypedParamsGetLLong (virTypedParameterPtr params, 147 | int nparams, 148 | const char *name, 149 | long long *value); 150 | int 151 | virTypedParamsGetULLong (virTypedParameterPtr params, 152 | int nparams, 153 | const char *name, 154 | unsigned long long *value); 155 | int 156 | virTypedParamsGetDouble (virTypedParameterPtr params, 157 | int nparams, 158 | const char *name, 159 | double *value); 160 | int 161 | virTypedParamsGetBoolean(virTypedParameterPtr params, 162 | int nparams, 163 | const char *name, 164 | int *value); 165 | int 166 | virTypedParamsGetString (virTypedParameterPtr params, 167 | int nparams, 168 | const char *name, 169 | const char **value); 170 | int 171 | virTypedParamsAddInt (virTypedParameterPtr *params, 172 | int *nparams, 173 | int *maxparams, 174 | const char *name, 175 | int value); 176 | int 177 | virTypedParamsAddUInt (virTypedParameterPtr *params, 178 | int *nparams, 179 | int *maxparams, 180 | const char *name, 181 | unsigned int value); 182 | int 183 | virTypedParamsAddLLong (virTypedParameterPtr *params, 184 | int *nparams, 185 | int *maxparams, 186 | const char *name, 187 | long long value); 188 | int 189 | virTypedParamsAddULLong (virTypedParameterPtr *params, 190 | int *nparams, 191 | int *maxparams, 192 | const char *name, 193 | unsigned long long value); 194 | int 195 | virTypedParamsAddDouble (virTypedParameterPtr *params, 196 | int *nparams, 197 | int *maxparams, 198 | const char *name, 199 | double value); 200 | int 201 | virTypedParamsAddBoolean(virTypedParameterPtr *params, 202 | int *nparams, 203 | int *maxparams, 204 | const char *name, 205 | int value); 206 | int 207 | virTypedParamsAddString (virTypedParameterPtr *params, 208 | int *nparams, 209 | int *maxparams, 210 | const char *name, 211 | const char *value); 212 | int 213 | virTypedParamsAddFromString(virTypedParameterPtr *params, 214 | int *nparams, 215 | int *maxparams, 216 | const char *name, 217 | int type, 218 | const char *value); 219 | void 220 | virTypedParamsClear (virTypedParameterPtr params, 221 | int nparams); 222 | void 223 | virTypedParamsFree (virTypedParameterPtr params, 224 | int nparams); 225 | ]] 226 | 227 | ffi.cdef[[ 228 | /* data types related to virNodePtr */ 229 | 230 | typedef struct _virNodeInfo virNodeInfo; 231 | 232 | struct _virNodeInfo { 233 | char model[32]; /* string indicating the CPU model */ 234 | unsigned long memory; /* memory size in kilobytes */ 235 | unsigned int cpus; /* the number of active CPUs */ 236 | unsigned int mhz; /* expected CPU frequency */ 237 | unsigned int nodes; /* the number of NUMA cell, 1 for unusual NUMA 238 | topologies or uniform memory access; check 239 | capabilities XML for the actual NUMA topology */ 240 | unsigned int sockets; /* number of CPU sockets per node if nodes > 1, 241 | 1 in case of unusual NUMA topology */ 242 | unsigned int cores; /* number of cores per socket, total number of 243 | processors in case of unusual NUMA topology*/ 244 | unsigned int threads; /* number of threads per core, 1 in case of 245 | unusual numa topology */ 246 | }; 247 | 248 | 249 | static const int VIR_NODE_CPU_STATS_FIELD_LENGTH = 80; 250 | 251 | 252 | typedef enum { 253 | VIR_NODE_CPU_STATS_ALL_CPUS = -1, 254 | } virNodeGetCPUStatsAllCPUs; 255 | ]] 256 | 257 | export.VIR_NODE_CPU_STATS_KERNEL ="kernel"; 258 | export.VIR_NODE_CPU_STATS_USER ="user"; 259 | export.VIR_NODE_CPU_STATS_IDLE ="idle"; 260 | export.VIR_NODE_CPU_STATS_IOWAIT ="iowait"; 261 | export.VIR_NODE_CPU_STATS_INTR ="intr"; 262 | export.VIR_NODE_CPU_STATS_UTILIZATION ="utilization"; 263 | 264 | ffi.cdef[[ 265 | 266 | typedef struct _virNodeCPUStats virNodeCPUStats; 267 | 268 | struct _virNodeCPUStats { 269 | char field[VIR_NODE_CPU_STATS_FIELD_LENGTH]; 270 | unsigned long long value; 271 | }; 272 | 273 | 274 | static const int VIR_NODE_MEMORY_STATS_FIELD_LENGTH = 80; 275 | 276 | typedef enum { 277 | VIR_NODE_MEMORY_STATS_ALL_CELLS = -1, 278 | } virNodeGetMemoryStatsAllCells; 279 | ]] 280 | 281 | export.VIR_NODE_MEMORY_STATS_TOTAL ="total"; 282 | export.VIR_NODE_MEMORY_STATS_FREE ="free"; 283 | export.VIR_NODE_MEMORY_STATS_BUFFERS ="buffers"; 284 | export.VIR_NODE_MEMORY_STATS_CACHED ="cached"; 285 | 286 | ffi.cdef[[ 287 | 288 | typedef struct _virNodeMemoryStats virNodeMemoryStats; 289 | 290 | struct _virNodeMemoryStats { 291 | char field[VIR_NODE_MEMORY_STATS_FIELD_LENGTH]; 292 | unsigned long long value; 293 | }; 294 | ]] 295 | 296 | export.VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN ="shm_pages_to_scan"; 297 | 298 | export.VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS ="shm_sleep_millisecs"; 299 | 300 | export.VIR_NODE_MEMORY_SHARED_PAGES_SHARED ="shm_pages_shared"; 301 | 302 | export.VIR_NODE_MEMORY_SHARED_PAGES_SHARING ="shm_pages_sharing"; 303 | 304 | export.VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED ="shm_pages_unshared"; 305 | 306 | export.VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE = "shm_pages_volatile"; 307 | 308 | export.VIR_NODE_MEMORY_SHARED_FULL_SCANS ="shm_full_scans"; 309 | 310 | export.VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES ="shm_merge_across_nodes"; 311 | 312 | ffi.cdef[[ 313 | int virNodeGetMemoryParameters(virConnectPtr conn, 314 | virTypedParameterPtr params, 315 | int *nparams, 316 | unsigned int flags); 317 | 318 | int virNodeSetMemoryParameters(virConnectPtr conn, 319 | virTypedParameterPtr params, 320 | int nparams, 321 | unsigned int flags); 322 | 323 | 324 | int virNodeGetCPUMap(virConnectPtr conn, 325 | unsigned char **cpumap, 326 | unsigned int *online, 327 | unsigned int flags); 328 | ]] 329 | 330 | 331 | export.VIR_NODEINFO_MAXCPUS = function(nodeinfo) 332 | return nodeinfo.nodes*nodeinfo.sockets*nodeinfo.cores*nodeinfo.threads; 333 | end 334 | 335 | ffi.cdef[[ 336 | 337 | typedef virNodeInfo *virNodeInfoPtr; 338 | 339 | typedef virNodeCPUStats *virNodeCPUStatsPtr; 340 | 341 | typedef virNodeMemoryStats *virNodeMemoryStatsPtr; 342 | 343 | 344 | typedef enum { 345 | VIR_CONNECT_RO = (1 << 0), /* A readonly connection */ 346 | VIR_CONNECT_NO_ALIASES = (1 << 1), /* Don't try to resolve URI aliases */ 347 | } virConnectFlags; 348 | 349 | 350 | typedef enum { 351 | VIR_CRED_USERNAME = 1, /* Identity to act as */ 352 | VIR_CRED_AUTHNAME = 2, /* Identify to authorize as */ 353 | VIR_CRED_LANGUAGE = 3, /* RFC 1766 languages, comma separated */ 354 | VIR_CRED_CNONCE = 4, /* client supplies a nonce */ 355 | VIR_CRED_PASSPHRASE = 5, /* Passphrase secret */ 356 | VIR_CRED_ECHOPROMPT = 6, /* Challenge response */ 357 | VIR_CRED_NOECHOPROMPT = 7, /* Challenge response */ 358 | VIR_CRED_REALM = 8, /* Authentication realm */ 359 | VIR_CRED_EXTERNAL = 9, /* Externally managed credential */ 360 | 361 | VIR_CRED_LAST /* More may be added - expect the unexpected */ 362 | 363 | } virConnectCredentialType; 364 | 365 | struct _virConnectCredential { 366 | int type; /* One of virConnectCredentialType constants */ 367 | const char *prompt; /* Prompt to show to user */ 368 | const char *challenge; /* Additional challenge to show */ 369 | const char *defresult; /* Optional default result */ 370 | char *result; /* Result to be filled with user response (or defresult) */ 371 | unsigned int resultlen; /* Length of the result */ 372 | }; 373 | 374 | typedef struct _virConnectCredential virConnectCredential; 375 | typedef virConnectCredential *virConnectCredentialPtr; 376 | 377 | 378 | 379 | typedef int (*virConnectAuthCallbackPtr)(virConnectCredentialPtr cred, 380 | unsigned int ncred, 381 | void *cbdata); 382 | 383 | struct _virConnectAuth { 384 | int *credtype; /* List of supported virConnectCredentialType values */ 385 | unsigned int ncredtype; 386 | 387 | virConnectAuthCallbackPtr cb; /* Callback used to collect credentials */ 388 | void *cbdata; 389 | }; 390 | 391 | 392 | typedef struct _virConnectAuth virConnectAuth; 393 | typedef virConnectAuth *virConnectAuthPtr; 394 | 395 | virConnectAuthPtr virConnectAuthPtrDefault; 396 | ]] 397 | 398 | 399 | export.VIR_UUID_BUFLEN = (16); 400 | export.VIR_UUID_STRING_BUFLEN = (36+1); 401 | 402 | ffi.cdef[[ 403 | int virGetVersion (unsigned long *libVer, 404 | const char *type, 405 | unsigned long *typeVer); 406 | 407 | /* 408 | * Connection and disconnections to the Hypervisor 409 | */ 410 | int virInitialize (void); 411 | 412 | virConnectPtr virConnectOpen (const char *name); 413 | virConnectPtr virConnectOpenReadOnly (const char *name); 414 | virConnectPtr virConnectOpenAuth (const char *name, 415 | virConnectAuthPtr auth, 416 | unsigned int flags); 417 | int virConnectRef (virConnectPtr conn); 418 | int virConnectClose (virConnectPtr conn); 419 | const char * virConnectGetType (virConnectPtr conn); 420 | int virConnectGetVersion (virConnectPtr conn, 421 | unsigned long *hvVer); 422 | int virConnectGetLibVersion (virConnectPtr conn, 423 | unsigned long *libVer); 424 | char * virConnectGetHostname (virConnectPtr conn); 425 | char * virConnectGetURI (virConnectPtr conn); 426 | char * virConnectGetSysinfo (virConnectPtr conn, 427 | unsigned int flags); 428 | 429 | int virConnectSetKeepAlive(virConnectPtr conn, 430 | int interval, 431 | unsigned int count); 432 | 433 | typedef enum { 434 | VIR_CONNECT_CLOSE_REASON_ERROR = 0, /* Misc I/O error */ 435 | VIR_CONNECT_CLOSE_REASON_EOF = 1, /* End-of-file from server */ 436 | VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2, /* Keepalive timer triggered */ 437 | VIR_CONNECT_CLOSE_REASON_CLIENT = 3, /* Client requested it */ 438 | 439 | VIR_CONNECT_CLOSE_REASON_LAST 440 | } virConnectCloseReason; 441 | 442 | 443 | typedef void (*virConnectCloseFunc)(virConnectPtr conn, 444 | int reason, 445 | void *opaque); 446 | 447 | int virConnectRegisterCloseCallback(virConnectPtr conn, 448 | virConnectCloseFunc cb, 449 | void *opaque, 450 | virFreeCallback freecb); 451 | int virConnectUnregisterCloseCallback(virConnectPtr conn, 452 | virConnectCloseFunc cb); 453 | ]] 454 | 455 | ffi.cdef[[ 456 | /* 457 | * Capabilities of the connection / driver. 458 | */ 459 | 460 | int virConnectGetMaxVcpus (virConnectPtr conn, 461 | const char *type); 462 | int virNodeGetInfo (virConnectPtr conn, 463 | virNodeInfoPtr info); 464 | char * virConnectGetCapabilities (virConnectPtr conn); 465 | 466 | int virNodeGetCPUStats (virConnectPtr conn, 467 | int cpuNum, 468 | virNodeCPUStatsPtr params, 469 | int *nparams, 470 | unsigned int flags); 471 | 472 | int virNodeGetMemoryStats (virConnectPtr conn, 473 | int cellNum, 474 | virNodeMemoryStatsPtr params, 475 | int *nparams, 476 | unsigned int flags); 477 | 478 | unsigned long long virNodeGetFreeMemory (virConnectPtr conn); 479 | 480 | int virNodeGetSecurityModel (virConnectPtr conn, 481 | virSecurityModelPtr secmodel); 482 | 483 | int virNodeSuspendForDuration (virConnectPtr conn, 484 | unsigned int target, 485 | unsigned long long duration, 486 | unsigned int flags); 487 | ]] 488 | 489 | ffi.cdef[[ 490 | /* 491 | * NUMA support 492 | */ 493 | 494 | int virNodeGetCellsFreeMemory(virConnectPtr conn, 495 | unsigned long long *freeMems, 496 | int startCell, 497 | int maxCells); 498 | ]] 499 | 500 | ffi.cdef[[ 501 | int virConnectIsEncrypted(virConnectPtr conn); 502 | int virConnectIsSecure(virConnectPtr conn); 503 | int virConnectIsAlive(virConnectPtr conn); 504 | ]] 505 | 506 | 507 | ffi.cdef[[ 508 | /* 509 | * CPU specification API 510 | */ 511 | 512 | typedef enum { 513 | VIR_CPU_COMPARE_ERROR = -1, 514 | VIR_CPU_COMPARE_INCOMPATIBLE = 0, 515 | VIR_CPU_COMPARE_IDENTICAL = 1, 516 | VIR_CPU_COMPARE_SUPERSET = 2, 517 | 518 | VIR_CPU_COMPARE_LAST 519 | 520 | } virCPUCompareResult; 521 | 522 | typedef enum { 523 | VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = (1 << 0), /* treat incompatible 524 | CPUs as failure */ 525 | } virConnectCompareCPUFlags; 526 | 527 | int virConnectCompareCPU(virConnectPtr conn, 528 | const char *xmlDesc, 529 | unsigned int flags); 530 | 531 | // virarch.c contains arch names 532 | int virConnectGetCPUModelNames(virConnectPtr conn, 533 | const char *arch, 534 | char ***models, 535 | unsigned int flags); 536 | 537 | 538 | typedef enum { 539 | VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = (1 << 0), /* show all features */ 540 | VIR_CONNECT_BASELINE_CPU_MIGRATABLE = (1 << 1), /* filter out non-migratable features */ 541 | } virConnectBaselineCPUFlags; 542 | 543 | char *virConnectBaselineCPU(virConnectPtr conn, 544 | const char **xmlCPUs, 545 | unsigned int ncpus, 546 | unsigned int flags); 547 | 548 | 549 | int virNodeGetFreePages(virConnectPtr conn, 550 | unsigned int npages, 551 | unsigned int *pages, 552 | int startcell, 553 | unsigned int cellcount, 554 | unsigned long long *counts, 555 | unsigned int flags); 556 | 557 | typedef enum { 558 | VIR_NODE_ALLOC_PAGES_ADD = 0, /* Add @pageCounts to the pages pool. This 559 | can be used only to size up the pool. */ 560 | VIR_NODE_ALLOC_PAGES_SET = (1 << 0), /* Don't add @pageCounts, instead set 561 | passed number of pages. This can be 562 | used to free allocated pages. */ 563 | } virNodeAllocPagesFlags; 564 | 565 | int virNodeAllocPages(virConnectPtr conn, 566 | unsigned int npages, 567 | unsigned int *pageSizes, 568 | unsigned long long *pageCounts, 569 | int startCell, 570 | unsigned int cellCount, 571 | unsigned int flags); 572 | 573 | 574 | ]] 575 | 576 | 577 | 578 | return export; 579 | -------------------------------------------------------------------------------- /libvirt-interface.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef struct _virInterface virInterface; 8 | 9 | typedef virInterface *virInterfacePtr; 10 | 11 | virConnectPtr virInterfaceGetConnect (virInterfacePtr iface); 12 | 13 | int virConnectNumOfInterfaces (virConnectPtr conn); 14 | int virConnectListInterfaces (virConnectPtr conn, 15 | char **const names, 16 | int maxnames); 17 | 18 | int virConnectNumOfDefinedInterfaces (virConnectPtr conn); 19 | int virConnectListDefinedInterfaces (virConnectPtr conn, 20 | char **const names, 21 | int maxnames); 22 | 23 | typedef enum { 24 | VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1 << 0, 25 | VIR_CONNECT_LIST_INTERFACES_ACTIVE = 1 << 1, 26 | } virConnectListAllInterfacesFlags; 27 | 28 | int virConnectListAllInterfaces (virConnectPtr conn, 29 | virInterfacePtr **ifaces, 30 | unsigned int flags); 31 | 32 | virInterfacePtr virInterfaceLookupByName (virConnectPtr conn, 33 | const char *name); 34 | virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn, 35 | const char *mac); 36 | 37 | const char* virInterfaceGetName (virInterfacePtr iface); 38 | const char* virInterfaceGetMACString (virInterfacePtr iface); 39 | 40 | typedef enum { 41 | VIR_INTERFACE_XML_INACTIVE = 1 << 0 /* dump inactive interface information */ 42 | } virInterfaceXMLFlags; 43 | 44 | char * virInterfaceGetXMLDesc (virInterfacePtr iface, 45 | unsigned int flags); 46 | virInterfacePtr virInterfaceDefineXML (virConnectPtr conn, 47 | const char *xmlDesc, 48 | unsigned int flags); 49 | 50 | int virInterfaceUndefine (virInterfacePtr iface); 51 | 52 | int virInterfaceCreate (virInterfacePtr iface, 53 | unsigned int flags); 54 | 55 | int virInterfaceDestroy (virInterfacePtr iface, 56 | unsigned int flags); 57 | 58 | int virInterfaceRef (virInterfacePtr iface); 59 | int virInterfaceFree (virInterfacePtr iface); 60 | 61 | int virInterfaceChangeBegin (virConnectPtr conn, 62 | unsigned int flags); 63 | int virInterfaceChangeCommit (virConnectPtr conn, 64 | unsigned int flags); 65 | int virInterfaceChangeRollback(virConnectPtr conn, 66 | unsigned int flags); 67 | 68 | int virInterfaceIsActive(virInterfacePtr iface); 69 | 70 | ]] 71 | 72 | return export 73 | 74 | -------------------------------------------------------------------------------- /libvirt-network.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | typedef enum { 7 | VIR_NETWORK_XML_INACTIVE = (1 << 0), /* dump inactive network information */ 8 | } virNetworkXMLFlags; 9 | 10 | 11 | typedef struct _virNetwork virNetwork; 12 | 13 | 14 | typedef virNetwork *virNetworkPtr; 15 | 16 | 17 | virConnectPtr virNetworkGetConnect (virNetworkPtr network); 18 | 19 | 20 | int virConnectNumOfNetworks (virConnectPtr conn); 21 | int virConnectListNetworks (virConnectPtr conn, 22 | char **const names, 23 | int maxnames); 24 | 25 | 26 | int virConnectNumOfDefinedNetworks (virConnectPtr conn); 27 | int virConnectListDefinedNetworks (virConnectPtr conn, 28 | char **const names, 29 | int maxnames); 30 | 31 | typedef enum { 32 | VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1 << 0, 33 | VIR_CONNECT_LIST_NETWORKS_ACTIVE = 1 << 1, 34 | 35 | VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 1 << 2, 36 | VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 1 << 3, 37 | 38 | VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 1 << 4, 39 | VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 1 << 5, 40 | } virConnectListAllNetworksFlags; 41 | 42 | int virConnectListAllNetworks (virConnectPtr conn, 43 | virNetworkPtr **nets, 44 | unsigned int flags); 45 | 46 | 47 | virNetworkPtr virNetworkLookupByName (virConnectPtr conn, 48 | const char *name); 49 | virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn, 50 | const unsigned char *uuid); 51 | virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn, 52 | const char *uuid); 53 | 54 | 55 | virNetworkPtr virNetworkCreateXML (virConnectPtr conn, 56 | const char *xmlDesc); 57 | 58 | 59 | virNetworkPtr virNetworkDefineXML (virConnectPtr conn, 60 | const char *xmlDesc); 61 | 62 | 63 | int virNetworkUndefine (virNetworkPtr network); 64 | 65 | 66 | typedef enum { 67 | VIR_NETWORK_UPDATE_COMMAND_NONE = 0, /* (invalid) */ 68 | VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1, /* modify an existing element */ 69 | VIR_NETWORK_UPDATE_COMMAND_DELETE = 2, /* delete an existing element */ 70 | VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3, /* add an element at end of list */ 71 | VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4, /* add an element at start of list */ 72 | VIR_NETWORK_UPDATE_COMMAND_LAST 73 | 74 | } virNetworkUpdateCommand; 75 | 76 | 77 | typedef enum { 78 | VIR_NETWORK_SECTION_NONE = 0, /* (invalid) */ 79 | VIR_NETWORK_SECTION_BRIDGE = 1, /* <bridge> */ 80 | VIR_NETWORK_SECTION_DOMAIN = 2, /* <domain> */ 81 | VIR_NETWORK_SECTION_IP = 3, /* <ip> */ 82 | VIR_NETWORK_SECTION_IP_DHCP_HOST = 4, /* <ip>/<dhcp>/<host> */ 83 | VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5, /* <ip>/<dhcp>/<range> */ 84 | VIR_NETWORK_SECTION_FORWARD = 6, /* <forward> */ 85 | VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7, /* <forward>/<interface> */ 86 | VIR_NETWORK_SECTION_FORWARD_PF = 8, /* <forward>/<pf> */ 87 | VIR_NETWORK_SECTION_PORTGROUP = 9, /* <portgroup> */ 88 | VIR_NETWORK_SECTION_DNS_HOST = 10, /* <dns>/<host> */ 89 | VIR_NETWORK_SECTION_DNS_TXT = 11, /* <dns>/<txt> */ 90 | VIR_NETWORK_SECTION_DNS_SRV = 12, /* <dns>/<srv> */ 91 | VIR_NETWORK_SECTION_LAST 92 | 93 | } virNetworkUpdateSection; 94 | 95 | 96 | typedef enum { 97 | VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0, /* affect live if network is active, 98 | config if it's not active */ 99 | VIR_NETWORK_UPDATE_AFFECT_LIVE = 1 << 0, /* affect live state of network only */ 100 | VIR_NETWORK_UPDATE_AFFECT_CONFIG = 1 << 1, /* affect persistent config only */ 101 | } virNetworkUpdateFlags; 102 | 103 | 104 | int virNetworkUpdate(virNetworkPtr network, 105 | unsigned int command, /* virNetworkUpdateCommand */ 106 | unsigned int section, /* virNetworkUpdateSection */ 107 | int parentIndex, 108 | const char *xml, 109 | unsigned int flags); 110 | 111 | 112 | int virNetworkCreate (virNetworkPtr network); 113 | 114 | 115 | int virNetworkDestroy (virNetworkPtr network); 116 | int virNetworkRef (virNetworkPtr network); 117 | int virNetworkFree (virNetworkPtr network); 118 | 119 | 120 | const char* virNetworkGetName (virNetworkPtr network); 121 | int virNetworkGetUUID (virNetworkPtr network, 122 | unsigned char *uuid); 123 | int virNetworkGetUUIDString (virNetworkPtr network, 124 | char *buf); 125 | char * virNetworkGetXMLDesc (virNetworkPtr network, 126 | unsigned int flags); 127 | char * virNetworkGetBridgeName (virNetworkPtr network); 128 | 129 | int virNetworkGetAutostart (virNetworkPtr network, 130 | int *autostart); 131 | int virNetworkSetAutostart (virNetworkPtr network, 132 | int autostart); 133 | 134 | int virNetworkIsActive(virNetworkPtr net); 135 | int virNetworkIsPersistent(virNetworkPtr net); 136 | 137 | 138 | typedef enum { 139 | VIR_NETWORK_EVENT_DEFINED = 0, 140 | VIR_NETWORK_EVENT_UNDEFINED = 1, 141 | VIR_NETWORK_EVENT_STARTED = 2, 142 | VIR_NETWORK_EVENT_STOPPED = 3, 143 | 144 | VIR_NETWORK_EVENT_LAST 145 | 146 | } virNetworkEventLifecycleType; 147 | 148 | 149 | typedef void (*virConnectNetworkEventLifecycleCallback)(virConnectPtr conn, 150 | virNetworkPtr net, 151 | int event, 152 | int detail, 153 | void *opaque); 154 | ]] 155 | 156 | --# define VIR_NETWORK_EVENT_CALLBACK(cb) ((virConnectNetworkEventGenericCallback)(cb)) 157 | 158 | ffi.cdef[[ 159 | 160 | typedef enum { 161 | VIR_NETWORK_EVENT_ID_LIFECYCLE = 0, /* virConnectNetworkEventLifecycleCallback */ 162 | 163 | VIR_NETWORK_EVENT_ID_LAST 164 | 165 | } virNetworkEventID; 166 | 167 | typedef enum { 168 | VIR_IP_ADDR_TYPE_IPV4, 169 | VIR_IP_ADDR_TYPE_IPV6, 170 | 171 | VIR_IP_ADDR_TYPE_LAST 172 | } virIPAddrType; 173 | 174 | typedef struct _virNetworkDHCPLease virNetworkDHCPLease; 175 | typedef virNetworkDHCPLease *virNetworkDHCPLeasePtr; 176 | struct _virNetworkDHCPLease { 177 | char *iface; /* Network interface name */ 178 | long long expirytime; /* Seconds since epoch */ 179 | int type; /* virIPAddrType */ 180 | char *mac; /* MAC address */ 181 | char *iaid; /* IAID */ 182 | char *ipaddr; /* IP address */ 183 | unsigned int prefix; /* IP address prefix */ 184 | char *hostname; /* Hostname */ 185 | char *clientid; /* Client ID or DUID */ 186 | }; 187 | 188 | void virNetworkDHCPLeaseFree(virNetworkDHCPLeasePtr lease); 189 | 190 | int virNetworkGetDHCPLeases(virNetworkPtr network, 191 | const char *mac, 192 | virNetworkDHCPLeasePtr **leases, 193 | unsigned int flags); 194 | 195 | 196 | typedef void (*virConnectNetworkEventGenericCallback)(virConnectPtr conn, 197 | virNetworkPtr net, 198 | void *opaque); 199 | 200 | /* Use VIR_NETWORK_EVENT_CALLBACK() to cast the 'cb' parameter */ 201 | int virConnectNetworkEventRegisterAny(virConnectPtr conn, 202 | virNetworkPtr net, /* Optional, to filter */ 203 | int eventID, 204 | virConnectNetworkEventGenericCallback cb, 205 | void *opaque, 206 | virFreeCallback freecb); 207 | 208 | int virConnectNetworkEventDeregisterAny(virConnectPtr conn, 209 | int callbackID); 210 | 211 | ]] 212 | 213 | return export 214 | -------------------------------------------------------------------------------- /libvirt-nodedev.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef struct _virNodeDevice virNodeDevice; 8 | 9 | 10 | typedef virNodeDevice *virNodeDevicePtr; 11 | 12 | 13 | int virNodeNumOfDevices (virConnectPtr conn, 14 | const char *cap, 15 | unsigned int flags); 16 | 17 | int virNodeListDevices (virConnectPtr conn, 18 | const char *cap, 19 | char **const names, 20 | int maxnames, 21 | unsigned int flags); 22 | 23 | typedef enum { 24 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1 << 0, /* System capability */ 25 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 1 << 1, /* PCI device */ 26 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 1 << 2, /* USB device */ 27 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 1 << 3, /* USB interface */ 28 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 1 << 4, /* Network device */ 29 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 1 << 5, /* SCSI Host Bus Adapter */ 30 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 1 << 6, /* SCSI Target */ 31 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 1 << 7, /* SCSI device */ 32 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 1 << 8, /* Storage device */ 33 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 1 << 9, /* FC Host Bus Adapter */ 34 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1 << 10, /* Capable of vport */ 35 | VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 1 << 11, /* Capable of scsi_generic */ 36 | } virConnectListAllNodeDeviceFlags; 37 | 38 | int virConnectListAllNodeDevices (virConnectPtr conn, 39 | virNodeDevicePtr **devices, 40 | unsigned int flags); 41 | 42 | virNodeDevicePtr virNodeDeviceLookupByName (virConnectPtr conn, 43 | const char *name); 44 | 45 | virNodeDevicePtr virNodeDeviceLookupSCSIHostByWWN (virConnectPtr conn, 46 | const char *wwnn, 47 | const char *wwpn, 48 | unsigned int flags); 49 | 50 | const char * virNodeDeviceGetName (virNodeDevicePtr dev); 51 | 52 | const char * virNodeDeviceGetParent (virNodeDevicePtr dev); 53 | 54 | int virNodeDeviceNumOfCaps (virNodeDevicePtr dev); 55 | 56 | int virNodeDeviceListCaps (virNodeDevicePtr dev, 57 | char **const names, 58 | int maxnames); 59 | 60 | char * virNodeDeviceGetXMLDesc (virNodeDevicePtr dev, 61 | unsigned int flags); 62 | 63 | int virNodeDeviceRef (virNodeDevicePtr dev); 64 | int virNodeDeviceFree (virNodeDevicePtr dev); 65 | 66 | int virNodeDeviceDettach (virNodeDevicePtr dev); 67 | int virNodeDeviceDetachFlags(virNodeDevicePtr dev, 68 | const char *driverName, 69 | unsigned int flags); 70 | int virNodeDeviceReAttach (virNodeDevicePtr dev); 71 | int virNodeDeviceReset (virNodeDevicePtr dev); 72 | 73 | virNodeDevicePtr virNodeDeviceCreateXML (virConnectPtr conn, 74 | const char *xmlDesc, 75 | unsigned int flags); 76 | 77 | int virNodeDeviceDestroy (virNodeDevicePtr dev); 78 | ]] 79 | 80 | return export 81 | -------------------------------------------------------------------------------- /libvirt-nwfilter.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef struct _virNWFilter virNWFilter; 8 | 9 | 10 | typedef virNWFilter *virNWFilterPtr; 11 | 12 | 13 | 14 | int virConnectNumOfNWFilters (virConnectPtr conn); 15 | int virConnectListNWFilters (virConnectPtr conn, 16 | char **const names, 17 | int maxnames); 18 | int virConnectListAllNWFilters(virConnectPtr conn, 19 | virNWFilterPtr **filters, 20 | unsigned int flags); 21 | 22 | virNWFilterPtr virNWFilterLookupByName (virConnectPtr conn, 23 | const char *name); 24 | virNWFilterPtr virNWFilterLookupByUUID (virConnectPtr conn, 25 | const unsigned char *uuid); 26 | virNWFilterPtr virNWFilterLookupByUUIDString (virConnectPtr conn, 27 | const char *uuid); 28 | 29 | 30 | virNWFilterPtr virNWFilterDefineXML (virConnectPtr conn, 31 | const char *xmlDesc); 32 | 33 | 34 | int virNWFilterUndefine (virNWFilterPtr nwfilter); 35 | 36 | 37 | int virNWFilterRef (virNWFilterPtr nwfilter); 38 | int virNWFilterFree (virNWFilterPtr nwfilter); 39 | 40 | 41 | const char* virNWFilterGetName (virNWFilterPtr nwfilter); 42 | int virNWFilterGetUUID (virNWFilterPtr nwfilter, 43 | unsigned char *uuid); 44 | int virNWFilterGetUUIDString (virNWFilterPtr nwfilter, 45 | char *buf); 46 | char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter, 47 | unsigned int flags); 48 | ]] 49 | 50 | return export 51 | -------------------------------------------------------------------------------- /libvirt-secret.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef struct _virSecret virSecret; 8 | typedef virSecret *virSecretPtr; 9 | 10 | typedef enum { 11 | VIR_SECRET_USAGE_TYPE_NONE = 0, 12 | VIR_SECRET_USAGE_TYPE_VOLUME = 1, 13 | VIR_SECRET_USAGE_TYPE_CEPH = 2, 14 | VIR_SECRET_USAGE_TYPE_ISCSI = 3, 15 | 16 | VIR_SECRET_USAGE_TYPE_LAST 17 | } virSecretUsageType; 18 | 19 | virConnectPtr virSecretGetConnect (virSecretPtr secret); 20 | int virConnectNumOfSecrets (virConnectPtr conn); 21 | int virConnectListSecrets (virConnectPtr conn, 22 | char **uuids, 23 | int maxuuids); 24 | 25 | typedef enum { 26 | VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1 << 0, /* kept in memory, never 27 | stored persistently */ 28 | VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 1 << 1, 29 | 30 | VIR_CONNECT_LIST_SECRETS_PRIVATE = 1 << 2, /* not revealed to any caller 31 | of libvirt, nor to any other 32 | node */ 33 | VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 1 << 3, 34 | } virConnectListAllSecretsFlags; 35 | 36 | int virConnectListAllSecrets(virConnectPtr conn, 37 | virSecretPtr **secrets, 38 | unsigned int flags); 39 | virSecretPtr virSecretLookupByUUID(virConnectPtr conn, 40 | const unsigned char *uuid); 41 | virSecretPtr virSecretLookupByUUIDString(virConnectPtr conn, 42 | const char *uuid); 43 | virSecretPtr virSecretLookupByUsage(virConnectPtr conn, 44 | int usageType, 45 | const char *usageID); 46 | virSecretPtr virSecretDefineXML (virConnectPtr conn, 47 | const char *xml, 48 | unsigned int flags); 49 | int virSecretGetUUID (virSecretPtr secret, 50 | unsigned char *buf); 51 | int virSecretGetUUIDString (virSecretPtr secret, 52 | char *buf); 53 | int virSecretGetUsageType (virSecretPtr secret); 54 | const char * virSecretGetUsageID (virSecretPtr secret); 55 | char * virSecretGetXMLDesc (virSecretPtr secret, 56 | unsigned int flags); 57 | int virSecretSetValue (virSecretPtr secret, 58 | const unsigned char *value, 59 | size_t value_size, 60 | unsigned int flags); 61 | unsigned char * virSecretGetValue (virSecretPtr secret, 62 | size_t *value_size, 63 | unsigned int flags); 64 | int virSecretUndefine (virSecretPtr secret); 65 | int virSecretRef (virSecretPtr secret); 66 | int virSecretFree (virSecretPtr secret); 67 | 68 | 69 | ]] 70 | 71 | return export 72 | -------------------------------------------------------------------------------- /libvirt-storage.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef struct _virStoragePool virStoragePool; 8 | 9 | 10 | typedef virStoragePool *virStoragePoolPtr; 11 | 12 | 13 | typedef enum { 14 | VIR_STORAGE_POOL_INACTIVE = 0, /* Not running */ 15 | VIR_STORAGE_POOL_BUILDING = 1, /* Initializing pool, not available */ 16 | VIR_STORAGE_POOL_RUNNING = 2, /* Running normally */ 17 | VIR_STORAGE_POOL_DEGRADED = 3, /* Running degraded */ 18 | VIR_STORAGE_POOL_INACCESSIBLE = 4, /* Running, but not accessible */ 19 | 20 | VIR_STORAGE_POOL_STATE_LAST 21 | 22 | } virStoragePoolState; 23 | 24 | 25 | typedef enum { 26 | VIR_STORAGE_POOL_BUILD_NEW = 0, /* Regular build from scratch */ 27 | VIR_STORAGE_POOL_BUILD_REPAIR = (1 << 0), /* Repair / reinitialize */ 28 | VIR_STORAGE_POOL_BUILD_RESIZE = (1 << 1), /* Extend existing pool */ 29 | VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = (1 << 2), /* Do not overwrite existing pool */ 30 | VIR_STORAGE_POOL_BUILD_OVERWRITE = (1 << 3), /* Overwrite data */ 31 | } virStoragePoolBuildFlags; 32 | 33 | typedef enum { 34 | VIR_STORAGE_POOL_DELETE_NORMAL = 0, /* Delete metadata only (fast) */ 35 | VIR_STORAGE_POOL_DELETE_ZEROED = 1 << 0, /* Clear all data to zeros (slow) */ 36 | } virStoragePoolDeleteFlags; 37 | 38 | typedef struct _virStoragePoolInfo virStoragePoolInfo; 39 | 40 | struct _virStoragePoolInfo { 41 | int state; /* virStoragePoolState flags */ 42 | unsigned long long capacity; /* Logical size bytes */ 43 | unsigned long long allocation; /* Current allocation bytes */ 44 | unsigned long long available; /* Remaining free space bytes */ 45 | }; 46 | 47 | typedef virStoragePoolInfo *virStoragePoolInfoPtr; 48 | 49 | 50 | 51 | typedef struct _virStorageVol virStorageVol; 52 | 53 | 54 | typedef virStorageVol *virStorageVolPtr; 55 | 56 | 57 | typedef enum { 58 | VIR_STORAGE_VOL_FILE = 0, /* Regular file based volumes */ 59 | VIR_STORAGE_VOL_BLOCK = 1, /* Block based volumes */ 60 | VIR_STORAGE_VOL_DIR = 2, /* Directory-passthrough based volume */ 61 | VIR_STORAGE_VOL_NETWORK = 3, /* Network volumes like RBD (RADOS Block Device) */ 62 | VIR_STORAGE_VOL_NETDIR = 4, /* Network accessible directory that can 63 | * contain other network volumes */ 64 | 65 | VIR_STORAGE_VOL_LAST 66 | 67 | } virStorageVolType; 68 | 69 | typedef enum { 70 | VIR_STORAGE_VOL_DELETE_NORMAL = 0, /* Delete metadata only (fast) */ 71 | VIR_STORAGE_VOL_DELETE_ZEROED = 1 << 0, /* Clear all data to zeros (slow) */ 72 | } virStorageVolDeleteFlags; 73 | 74 | typedef enum { 75 | VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0, /* 1-pass, all zeroes */ 76 | VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1, /* 4-pass NNSA Policy Letter 77 | NAP-14.1-C (XVI-8) */ 78 | VIR_STORAGE_VOL_WIPE_ALG_DOD = 2, /* 4-pass DoD 5220.22-M section 79 | 8-306 procedure */ 80 | VIR_STORAGE_VOL_WIPE_ALG_BSI = 3, /* 9-pass method recommended by the 81 | German Center of Security in 82 | Information Technologies */ 83 | VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4, /* The canonical 35-pass sequence */ 84 | VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5, /* 7-pass method described by 85 | Bruce Schneier in "Applied 86 | Cryptography" (1996) */ 87 | VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6, /* 7-pass random */ 88 | 89 | VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7, /* 33-pass random */ 90 | 91 | VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8, /* 1-pass random */ 92 | 93 | 94 | VIR_STORAGE_VOL_WIPE_ALG_LAST 95 | 96 | 97 | } virStorageVolWipeAlgorithm; 98 | 99 | typedef struct _virStorageVolInfo virStorageVolInfo; 100 | 101 | struct _virStorageVolInfo { 102 | int type; /* virStorageVolType flags */ 103 | unsigned long long capacity; /* Logical size bytes */ 104 | unsigned long long allocation; /* Current allocation bytes */ 105 | }; 106 | 107 | typedef virStorageVolInfo *virStorageVolInfoPtr; 108 | 109 | typedef enum { 110 | VIR_STORAGE_XML_INACTIVE = (1 << 0), /* dump inactive pool/volume information */ 111 | } virStorageXMLFlags; 112 | 113 | 114 | virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool); 115 | 116 | 117 | int virConnectNumOfStoragePools (virConnectPtr conn); 118 | int virConnectListStoragePools (virConnectPtr conn, 119 | char **const names, 120 | int maxnames); 121 | 122 | 123 | int virConnectNumOfDefinedStoragePools(virConnectPtr conn); 124 | int virConnectListDefinedStoragePools(virConnectPtr conn, 125 | char **const names, 126 | int maxnames); 127 | 128 | 129 | typedef enum { 130 | VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1 << 0, 131 | VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 1 << 1, 132 | 133 | VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 1 << 2, 134 | VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 1 << 3, 135 | 136 | VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 1 << 4, 137 | VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 1 << 5, 138 | 139 | /* List pools by type */ 140 | VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 1 << 6, 141 | VIR_CONNECT_LIST_STORAGE_POOLS_FS = 1 << 7, 142 | VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 1 << 8, 143 | VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 1 << 9, 144 | VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1 << 10, 145 | VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 1 << 11, 146 | VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 1 << 12, 147 | VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 1 << 13, 148 | VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 1 << 14, 149 | VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 1 << 15, 150 | VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 1 << 16, 151 | VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 1 << 17, 152 | } virConnectListAllStoragePoolsFlags; 153 | 154 | int virConnectListAllStoragePools(virConnectPtr conn, 155 | virStoragePoolPtr **pools, 156 | unsigned int flags); 157 | 158 | char * virConnectFindStoragePoolSources(virConnectPtr conn, 159 | const char *type, 160 | const char *srcSpec, 161 | unsigned int flags); 162 | 163 | 164 | virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn, 165 | const char *name); 166 | virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn, 167 | const unsigned char *uuid); 168 | virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn, 169 | const char *uuid); 170 | virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol); 171 | 172 | 173 | virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn, 174 | const char *xmlDesc, 175 | unsigned int flags); 176 | virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn, 177 | const char *xmlDesc, 178 | unsigned int flags); 179 | int virStoragePoolBuild (virStoragePoolPtr pool, 180 | unsigned int flags); 181 | int virStoragePoolUndefine (virStoragePoolPtr pool); 182 | int virStoragePoolCreate (virStoragePoolPtr pool, 183 | unsigned int flags); 184 | int virStoragePoolDestroy (virStoragePoolPtr pool); 185 | int virStoragePoolDelete (virStoragePoolPtr pool, 186 | unsigned int flags); 187 | int virStoragePoolRef (virStoragePoolPtr pool); 188 | int virStoragePoolFree (virStoragePoolPtr pool); 189 | int virStoragePoolRefresh (virStoragePoolPtr pool, 190 | unsigned int flags); 191 | 192 | 193 | const char* virStoragePoolGetName (virStoragePoolPtr pool); 194 | int virStoragePoolGetUUID (virStoragePoolPtr pool, 195 | unsigned char *uuid); 196 | int virStoragePoolGetUUIDString (virStoragePoolPtr pool, 197 | char *buf); 198 | 199 | int virStoragePoolGetInfo (virStoragePoolPtr vol, 200 | virStoragePoolInfoPtr info); 201 | 202 | char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool, 203 | unsigned int flags); 204 | 205 | int virStoragePoolGetAutostart (virStoragePoolPtr pool, 206 | int *autostart); 207 | int virStoragePoolSetAutostart (virStoragePoolPtr pool, 208 | int autostart); 209 | 210 | 211 | int virStoragePoolNumOfVolumes (virStoragePoolPtr pool); 212 | int virStoragePoolListVolumes (virStoragePoolPtr pool, 213 | char **const names, 214 | int maxnames); 215 | int virStoragePoolListAllVolumes (virStoragePoolPtr pool, 216 | virStorageVolPtr **vols, 217 | unsigned int flags); 218 | 219 | virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol); 220 | 221 | 222 | virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool, 223 | const char *name); 224 | virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn, 225 | const char *key); 226 | virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn, 227 | const char *path); 228 | 229 | 230 | const char* virStorageVolGetName (virStorageVolPtr vol); 231 | const char* virStorageVolGetKey (virStorageVolPtr vol); 232 | 233 | typedef enum { 234 | VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1 << 0, 235 | VIR_STORAGE_VOL_CREATE_REFLINK = 1 << 1, /* perform a btrfs lightweight copy */ 236 | } virStorageVolCreateFlags; 237 | 238 | virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool, 239 | const char *xmldesc, 240 | unsigned int flags); 241 | virStorageVolPtr virStorageVolCreateXMLFrom (virStoragePoolPtr pool, 242 | const char *xmldesc, 243 | virStorageVolPtr clonevol, 244 | unsigned int flags); 245 | int virStorageVolDownload (virStorageVolPtr vol, 246 | virStreamPtr stream, 247 | unsigned long long offset, 248 | unsigned long long length, 249 | unsigned int flags); 250 | int virStorageVolUpload (virStorageVolPtr vol, 251 | virStreamPtr stream, 252 | unsigned long long offset, 253 | unsigned long long length, 254 | unsigned int flags); 255 | int virStorageVolDelete (virStorageVolPtr vol, 256 | unsigned int flags); 257 | int virStorageVolWipe (virStorageVolPtr vol, 258 | unsigned int flags); 259 | int virStorageVolWipePattern (virStorageVolPtr vol, 260 | unsigned int algorithm, 261 | unsigned int flags); 262 | int virStorageVolRef (virStorageVolPtr vol); 263 | int virStorageVolFree (virStorageVolPtr vol); 264 | 265 | int virStorageVolGetInfo (virStorageVolPtr vol, 266 | virStorageVolInfoPtr info); 267 | char * virStorageVolGetXMLDesc (virStorageVolPtr pool, 268 | unsigned int flags); 269 | 270 | char * virStorageVolGetPath (virStorageVolPtr vol); 271 | 272 | typedef enum { 273 | VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1 << 0, /* force allocation of new size */ 274 | VIR_STORAGE_VOL_RESIZE_DELTA = 1 << 1, /* size is relative to current */ 275 | VIR_STORAGE_VOL_RESIZE_SHRINK = 1 << 2, /* allow decrease in capacity */ 276 | } virStorageVolResizeFlags; 277 | 278 | int virStorageVolResize (virStorageVolPtr vol, 279 | unsigned long long capacity, 280 | unsigned int flags); 281 | 282 | int virStoragePoolIsActive(virStoragePoolPtr pool); 283 | int virStoragePoolIsPersistent(virStoragePoolPtr pool); 284 | 285 | ]] 286 | 287 | return export 288 | 289 | -------------------------------------------------------------------------------- /libvirt-stream.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | typedef enum { 7 | VIR_STREAM_NONBLOCK = (1 << 0), 8 | } virStreamFlags; 9 | 10 | virStreamPtr virStreamNew(virConnectPtr conn, 11 | unsigned int flags); 12 | int virStreamRef(virStreamPtr st); 13 | 14 | int virStreamSend(virStreamPtr st, 15 | const char *data, 16 | size_t nbytes); 17 | 18 | int virStreamRecv(virStreamPtr st, 19 | char *data, 20 | size_t nbytes); 21 | 22 | 23 | 24 | typedef int (*virStreamSourceFunc)(virStreamPtr st, 25 | char *data, 26 | size_t nbytes, 27 | void *opaque); 28 | 29 | int virStreamSendAll(virStreamPtr st, 30 | virStreamSourceFunc handler, 31 | void *opaque); 32 | 33 | 34 | typedef int (*virStreamSinkFunc)(virStreamPtr st, 35 | const char *data, 36 | size_t nbytes, 37 | void *opaque); 38 | 39 | int virStreamRecvAll(virStreamPtr st, 40 | virStreamSinkFunc handler, 41 | void *opaque); 42 | 43 | typedef enum { 44 | VIR_STREAM_EVENT_READABLE = (1 << 0), 45 | VIR_STREAM_EVENT_WRITABLE = (1 << 1), 46 | VIR_STREAM_EVENT_ERROR = (1 << 2), 47 | VIR_STREAM_EVENT_HANGUP = (1 << 3), 48 | } virStreamEventType; 49 | 50 | 51 | 52 | typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void *opaque); 53 | 54 | int virStreamEventAddCallback(virStreamPtr stream, 55 | int events, 56 | virStreamEventCallback cb, 57 | void *opaque, 58 | virFreeCallback ff); 59 | 60 | int virStreamEventUpdateCallback(virStreamPtr stream, 61 | int events); 62 | 63 | int virStreamEventRemoveCallback(virStreamPtr stream); 64 | 65 | 66 | int virStreamFinish(virStreamPtr st); 67 | int virStreamAbort(virStreamPtr st); 68 | 69 | int virStreamFree(virStreamPtr st); 70 | ]] 71 | 72 | return export 73 | 74 | -------------------------------------------------------------------------------- /libvirt.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | __VIR_LIBVIRT_H_INCLUDES__ = true; 4 | 5 | local export = {} 6 | 7 | -- Copy one dictionary into another 8 | local function appendTable(dst, src) 9 | if not src then 10 | return dst; 11 | end 12 | 13 | for key, value in pairs(src) do 14 | dst.key = value; 15 | end 16 | 17 | return dst; 18 | end 19 | 20 | -- Load all the definitions, while copying 21 | -- dictionary values into export table 22 | appendTable(export, require "libvirt-host"); 23 | appendTable(export, require "libvirt-domain"); 24 | appendTable(export, require "libvirt-domain-snapshot"); 25 | appendTable(export, require "libvirt-event"); 26 | appendTable(export, require "libvirt-interface"); 27 | appendTable(export, require "libvirt-network"); 28 | appendTable(export, require "libvirt-nodedev"); 29 | appendTable(export, require "libvirt-nwfilter"); 30 | appendTable(export, require "libvirt-secret"); 31 | appendTable(export, require "libvirt-storage"); 32 | appendTable(export, require "libvirt-stream"); 33 | appendTable(export, require "virterror"); 34 | 35 | 36 | if ffi.os == "Windows" then 37 | export.Lib = ffi.load("libvirt-0.dll") 38 | elseif ffi.os == "Linux" then 39 | export.Lib = ffi.load("/usr/lib/libvirt.so") 40 | elseif ffi.os == "OSX" then 41 | export.Lib = ffi.load("libvirt"); 42 | end 43 | 44 | if not export.Lib then 45 | return nil, "could not load library, 'libvirt'" 46 | end 47 | 48 | local err = export.Lib.virInitialize(); 49 | 50 | if (err ~= 0) then 51 | return nil, "could not initialize libvirt"; 52 | end 53 | 54 | return export 55 | 56 | -------------------------------------------------------------------------------- /testy/get_domain_status.lua: -------------------------------------------------------------------------------- 1 | -- get_domain_stat.lua 2 | package.path = package.path..';../?.lua' 3 | 4 | local ffi = require("ffi") 5 | 6 | local Connection = require("hostconnection") 7 | local Domain = require("domain") 8 | 9 | 10 | local function printAttributes(conn) 11 | print("==== Connection Attributes ====") 12 | print("Host Name: ", conn:getHostName()); 13 | print("Encrypted: ", conn:isEncrypted()); 14 | print(" Secure: ", conn:isSecure()); 15 | print(" Live: ", conn:isAlive()); 16 | end 17 | 18 | 19 | local function getstats(conn, domainname, whichstats) 20 | -- get a handle on the domain by name 21 | local dom = Domain(conn.Handle, domainname) 22 | if not dom then 23 | return false, "could not get domain" 24 | end 25 | 26 | for stat in dom:stats(ffi.C.VIR_DOMAIN_STATS_CPU_TOTAL) do 27 | for k,v in pairs(stat) do 28 | print("STAT: ", k, v); 29 | if (type(v) == "table") then 30 | for key,value in pairs(v) do 31 | print(key, value) 32 | end 33 | end 34 | end 35 | end 36 | 37 | return true 38 | end 39 | 40 | local domains = { 41 | {hosturi = "qemu:///system", domainidentifier = "arch1"}, 42 | -- {hosturi = "qemu:///system", domainidentifier = "win81"}, 43 | -- {hosturi = "test:///default", domainidentifier = "test"}, 44 | } 45 | 46 | for _, info in ipairs(domains) do 47 | local conn = Connection(info.hosturi); 48 | if conn then 49 | printAttributes(conn) 50 | getstats(conn, info.domainidentifier) 51 | else 52 | print("No connection established to: ", hosturi) 53 | end 54 | end 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /testy/test_hostconnection.lua: -------------------------------------------------------------------------------- 1 | -- test_hostconnection.lua 2 | package.path = package.path..';../?.lua' 3 | 4 | local ffi = require("ffi") 5 | 6 | local Connection = require("hostconnection") 7 | local Domain = require("domain") 8 | 9 | 10 | local function printAttributes(conn) 11 | local lv,err = conn:getLibraryVersion(); 12 | local libstr = nil; 13 | if (lv) then 14 | libstr = string.format("%d.%d.%d", lv.major, lv.minor, lv.release); 15 | else 16 | print("getLibraryVersion() failed: ", err); 17 | end 18 | 19 | print("==== Connection Attributes ====") 20 | print(" Library: ", libstr); 21 | print("Host Name: ", conn:getHostName()); 22 | print(" URI: ", conn:getURI()); 23 | print("Encrypted: ", conn:isEncrypted()); 24 | print(" Secure: ", conn:isSecure()); 25 | print(" Live: ", conn:isAlive()); 26 | end 27 | 28 | local function printCPUModelNames(conn) 29 | -- try out the model names iterator 30 | print("==== printCPUModelNames ====") 31 | for name in conn:cpuModelNames() do 32 | print("MODEL: ", name); 33 | end 34 | end 35 | 36 | local function printCapabilities(conn) 37 | print("==== printCapabilities ===="); 38 | print(conn:getCapabilities()) 39 | end 40 | 41 | local function printDomainInfo(conn) 42 | print("==== printDomainInfo ====") 43 | print("Number Of Domains: ", conn:getNumberOfDomains()); 44 | for id in conn:domainIds() do 45 | print("ID: ", id) 46 | local dom = Domain(conn.Handle, id); 47 | print(dom); 48 | if dom then 49 | print("==== Domain: ", id) 50 | print(" Name: ", dom:getName()) 51 | print(" Host Name: ", dom:getHostName()) 52 | print(" OS Type: ", dom:getOSType()) 53 | print("UUID String: ", dom:getUUIDString()) 54 | print(" XML Desc: ", dom:getXMLDesc(ffi.C.VIR_DOMAIN_XML_SECURE)) 55 | print("-- Info --") 56 | for k,v in pairs(dom:getInfo()) do 57 | print(k,v) 58 | end 59 | end 60 | end 61 | end 62 | 63 | local hosturi = "qemu:///system" 64 | --local hosturi = "test:///default" 65 | 66 | local conn = Connection(hosturi); 67 | if not conn then 68 | print("No connection established to: ", hosturi) 69 | return 70 | end 71 | 72 | 73 | printAttributes(conn) 74 | --printCPUModelNames(conn) 75 | --printCapabilities(conn) 76 | printDomainInfo(conn) 77 | 78 | -------------------------------------------------------------------------------- /testy/test_libvirt.lua: -------------------------------------------------------------------------------- 1 | package.path = package.path..';../?.lua' 2 | 3 | local ffi = require("ffi") 4 | 5 | local libvirt, err = require("libvirt") 6 | 7 | 8 | if (not libvirt) then 9 | print(err); 10 | return nil; 11 | end 12 | 13 | 14 | local function printHostName(conn) 15 | local hostname = ffi.string(libvirt.Lib.virConnectGetHostname(conn)); 16 | print("Host: ", hostname); 17 | end 18 | 19 | local function printCPUModelNames(conn, arch) 20 | local flags = 0; 21 | print("==== printCPUModelNames ====") 22 | 23 | -- first find out how many there are 24 | local err = libvirt.Lib.virConnectGetCPUModelNames(conn,arch,nil,flags); 25 | 26 | print("Number of models: ", err) 27 | if err < 0 then 28 | return false 29 | end 30 | 31 | --local voidPtr = ffi.new("void*[1]") 32 | local modelsArray = ffi.new(ffi.typeof("char **[1]")) 33 | err = libvirt.Lib.virConnectGetCPUModelNames(conn,arch,modelsArray,flags); 34 | if err < 0 then 35 | print("error with virConnectGetCPUModelNames: ", err) 36 | return false 37 | end 38 | 39 | 40 | print("Models: ", modelsArray) 41 | 42 | for i=0,err-1 do 43 | local str = modelsArray[0][i] 44 | if str ~= nil then 45 | print("MODEL: ", ffi.string(str)) 46 | end 47 | end 48 | 49 | end 50 | 51 | local function printCapabilities(conn) 52 | local caps = libvirt.Lib.virConnectGetCapabilities (conn); 53 | if caps ~= nil then 54 | print("CAPS: ",ffi.string(caps)); 55 | end 56 | --free(caps); 57 | end 58 | 59 | local driveruri = "qemu:///system"; 60 | local conn = libvirt.Lib.virConnectOpenReadOnly(driveruri); 61 | 62 | if not conn then 63 | print("No connection") 64 | return 65 | end 66 | 67 | printHostName(conn) 68 | printCPUModelNames(conn, "x86_64") 69 | printCPUModelNames(conn, "mips") 70 | --printCapabilities(conn); 71 | 72 | libvirt.Lib.virConnectClose(conn); 73 | 74 | -------------------------------------------------------------------------------- /testy/test_reboot.lua: -------------------------------------------------------------------------------- 1 | -- test_hostconnection.lua 2 | package.path = package.path..';../?.lua' 3 | 4 | local Connection = require("hostconnection") 5 | local Domain = require("domain") 6 | 7 | 8 | local function printAttributes(conn) 9 | print("==== printAttributes ====") 10 | print("Host Name: ", conn:getHostName()); 11 | print("Encrypted: ", conn:isEncrypted()); 12 | print(" Secure: ", conn:isSecure()); 13 | print(" Live: ", conn:isAlive()); 14 | end 15 | 16 | 17 | local function reboot(conn, domainname) 18 | -- get a handle on the domain by name 19 | local dom = Domain(conn.Handle, domainname) 20 | if not dom then 21 | return false, "could not get domain" 22 | end 23 | 24 | dom:reboot(); 25 | 26 | return true 27 | end 28 | 29 | local hosturi = "qemu:///system" 30 | local conn = Connection(hosturi); 31 | if not conn then 32 | print("No connection established to: ", hosturi) 33 | return 34 | end 35 | 36 | printAttributes(conn) 37 | reboot(conn, "win81") 38 | 39 | -------------------------------------------------------------------------------- /virterror.lua: -------------------------------------------------------------------------------- 1 | local ffi = require("ffi") 2 | 3 | local export = {} 4 | 5 | ffi.cdef[[ 6 | 7 | typedef enum { 8 | VIR_ERR_NONE = 0, 9 | VIR_ERR_WARNING = 1, /* A simple warning */ 10 | VIR_ERR_ERROR = 2 /* An error */ 11 | } virErrorLevel; 12 | ]] 13 | 14 | ffi.cdef[[ 15 | typedef enum { 16 | VIR_FROM_NONE = 0, 17 | VIR_FROM_XEN = 1, /* Error at Xen hypervisor layer */ 18 | VIR_FROM_XEND = 2, /* Error at connection with xend daemon */ 19 | VIR_FROM_XENSTORE = 3, /* Error at connection with xen store */ 20 | VIR_FROM_SEXPR = 4, /* Error in the S-Expression code */ 21 | 22 | VIR_FROM_XML = 5, /* Error in the XML code */ 23 | VIR_FROM_DOM = 6, /* Error when operating on a domain */ 24 | VIR_FROM_RPC = 7, /* Error in the XML-RPC code */ 25 | VIR_FROM_PROXY = 8, /* Error in the proxy code; unused since 26 | 0.8.6 */ 27 | VIR_FROM_CONF = 9, /* Error in the configuration file handling */ 28 | 29 | VIR_FROM_QEMU = 10, /* Error at the QEMU daemon */ 30 | VIR_FROM_NET = 11, /* Error when operating on a network */ 31 | VIR_FROM_TEST = 12, /* Error from test driver */ 32 | VIR_FROM_REMOTE = 13, /* Error from remote driver */ 33 | VIR_FROM_OPENVZ = 14, /* Error from OpenVZ driver */ 34 | 35 | VIR_FROM_XENXM = 15, /* Error at Xen XM layer */ 36 | VIR_FROM_STATS_LINUX = 16, /* Error in the Linux Stats code */ 37 | VIR_FROM_LXC = 17, /* Error from Linux Container driver */ 38 | VIR_FROM_STORAGE = 18, /* Error from storage driver */ 39 | VIR_FROM_NETWORK = 19, /* Error from network config */ 40 | 41 | VIR_FROM_DOMAIN = 20, /* Error from domain config */ 42 | VIR_FROM_UML = 21, /* Error at the UML driver */ 43 | VIR_FROM_NODEDEV = 22, /* Error from node device monitor */ 44 | VIR_FROM_XEN_INOTIFY = 23, /* Error from xen inotify layer */ 45 | VIR_FROM_SECURITY = 24, /* Error from security framework */ 46 | 47 | VIR_FROM_VBOX = 25, /* Error from VirtualBox driver */ 48 | VIR_FROM_INTERFACE = 26, /* Error when operating on an interface */ 49 | VIR_FROM_ONE = 27, /* The OpenNebula driver no longer exists. 50 | Retained for ABI/API compat only */ 51 | VIR_FROM_ESX = 28, /* Error from ESX driver */ 52 | VIR_FROM_PHYP = 29, /* Error from IBM power hypervisor */ 53 | 54 | VIR_FROM_SECRET = 30, /* Error from secret storage */ 55 | VIR_FROM_CPU = 31, /* Error from CPU driver */ 56 | VIR_FROM_XENAPI = 32, /* Error from XenAPI */ 57 | VIR_FROM_NWFILTER = 33, /* Error from network filter driver */ 58 | VIR_FROM_HOOK = 34, /* Error from Synchronous hooks */ 59 | 60 | VIR_FROM_DOMAIN_SNAPSHOT = 35,/* Error from domain snapshot */ 61 | VIR_FROM_AUDIT = 36, /* Error from auditing subsystem */ 62 | VIR_FROM_SYSINFO = 37, /* Error from sysinfo/SMBIOS */ 63 | VIR_FROM_STREAMS = 38, /* Error from I/O streams */ 64 | VIR_FROM_VMWARE = 39, /* Error from VMware driver */ 65 | 66 | VIR_FROM_EVENT = 40, /* Error from event loop impl */ 67 | VIR_FROM_LIBXL = 41, /* Error from libxenlight driver */ 68 | VIR_FROM_LOCKING = 42, /* Error from lock manager */ 69 | VIR_FROM_HYPERV = 43, /* Error from Hyper-V driver */ 70 | VIR_FROM_CAPABILITIES = 44, /* Error from capabilities */ 71 | 72 | VIR_FROM_URI = 45, /* Error from URI handling */ 73 | VIR_FROM_AUTH = 46, /* Error from auth handling */ 74 | VIR_FROM_DBUS = 47, /* Error from DBus */ 75 | VIR_FROM_PARALLELS = 48, /* Error from Parallels */ 76 | VIR_FROM_DEVICE = 49, /* Error from Device */ 77 | 78 | VIR_FROM_SSH = 50, /* Error from libssh2 connection transport */ 79 | VIR_FROM_LOCKSPACE = 51, /* Error from lockspace */ 80 | VIR_FROM_INITCTL = 52, /* Error from initctl device communication */ 81 | VIR_FROM_IDENTITY = 53, /* Error from identity code */ 82 | VIR_FROM_CGROUP = 54, /* Error from cgroups */ 83 | 84 | VIR_FROM_ACCESS = 55, /* Error from access control manager */ 85 | VIR_FROM_SYSTEMD = 56, /* Error from systemd code */ 86 | VIR_FROM_BHYVE = 57, /* Error from bhyve driver */ 87 | VIR_FROM_CRYPTO = 58, /* Error from crypto code */ 88 | VIR_FROM_FIREWALL = 59, /* Error from firewall */ 89 | 90 | VIR_FROM_POLKIT = 60, /* Error from polkit code */ 91 | VIR_FROM_THREAD = 61, /* Error from thread utils */ 92 | 93 | VIR_ERR_DOMAIN_LAST 94 | } virErrorDomain; 95 | ]] 96 | 97 | ffi.cdef[[ 98 | 99 | typedef struct _virError virError; 100 | typedef virError *virErrorPtr; 101 | struct _virError { 102 | int code; /* The error code, a virErrorNumber */ 103 | int domain; /* What part of the library raised this error */ 104 | char *message;/* human-readable informative error message */ 105 | virErrorLevel level;/* how consequent is the error */ 106 | // virConnectPtr conn VIR_DEPRECATED; // connection if available, deprecated 107 | // see note above 108 | // virDomainPtr dom VIR_DEPRECATED; // domain if available, deprecated 109 | // see note above 110 | char *str1; /* extra string information */ 111 | char *str2; /* extra string information */ 112 | char *str3; /* extra string information */ 113 | int int1; /* extra number information */ 114 | int int2; /* extra number information */ 115 | // virNetworkPtr net VIR_DEPRECATED; // network if available, deprecated 116 | // see note above 117 | }; 118 | ]] 119 | 120 | ffi.cdef[[ 121 | 122 | typedef enum { 123 | VIR_ERR_OK = 0, 124 | VIR_ERR_INTERNAL_ERROR = 1, /* internal error */ 125 | VIR_ERR_NO_MEMORY = 2, /* memory allocation failure */ 126 | VIR_ERR_NO_SUPPORT = 3, /* no support for this function */ 127 | VIR_ERR_UNKNOWN_HOST = 4, /* could not resolve hostname */ 128 | VIR_ERR_NO_CONNECT = 5, /* can't connect to hypervisor */ 129 | VIR_ERR_INVALID_CONN = 6, /* invalid connection object */ 130 | VIR_ERR_INVALID_DOMAIN = 7, /* invalid domain object */ 131 | VIR_ERR_INVALID_ARG = 8, /* invalid function argument */ 132 | VIR_ERR_OPERATION_FAILED = 9, /* a command to hypervisor failed */ 133 | VIR_ERR_GET_FAILED = 10, /* a HTTP GET command to failed */ 134 | VIR_ERR_POST_FAILED = 11, /* a HTTP POST command to failed */ 135 | VIR_ERR_HTTP_ERROR = 12, /* unexpected HTTP error code */ 136 | VIR_ERR_SEXPR_SERIAL = 13, /* failure to serialize an S-Expr */ 137 | VIR_ERR_NO_XEN = 14, /* could not open Xen hypervisor 138 | control */ 139 | VIR_ERR_XEN_CALL = 15, /* failure doing an hypervisor call */ 140 | VIR_ERR_OS_TYPE = 16, /* unknown OS type */ 141 | VIR_ERR_NO_KERNEL = 17, /* missing kernel information */ 142 | VIR_ERR_NO_ROOT = 18, /* missing root device information */ 143 | VIR_ERR_NO_SOURCE = 19, /* missing source device information */ 144 | VIR_ERR_NO_TARGET = 20, /* missing target device information */ 145 | VIR_ERR_NO_NAME = 21, /* missing domain name information */ 146 | VIR_ERR_NO_OS = 22, /* missing domain OS information */ 147 | VIR_ERR_NO_DEVICE = 23, /* missing domain devices information */ 148 | VIR_ERR_NO_XENSTORE = 24, /* could not open Xen Store control */ 149 | VIR_ERR_DRIVER_FULL = 25, /* too many drivers registered */ 150 | VIR_ERR_CALL_FAILED = 26, /* not supported by the drivers 151 | (DEPRECATED) */ 152 | VIR_ERR_XML_ERROR = 27, /* an XML description is not well 153 | formed or broken */ 154 | VIR_ERR_DOM_EXIST = 28, /* the domain already exist */ 155 | VIR_ERR_OPERATION_DENIED = 29, /* operation forbidden on read-only 156 | connections */ 157 | VIR_ERR_OPEN_FAILED = 30, /* failed to open a conf file */ 158 | VIR_ERR_READ_FAILED = 31, /* failed to read a conf file */ 159 | VIR_ERR_PARSE_FAILED = 32, /* failed to parse a conf file */ 160 | VIR_ERR_CONF_SYNTAX = 33, /* failed to parse the syntax of a 161 | conf file */ 162 | VIR_ERR_WRITE_FAILED = 34, /* failed to write a conf file */ 163 | VIR_ERR_XML_DETAIL = 35, /* detail of an XML error */ 164 | VIR_ERR_INVALID_NETWORK = 36, /* invalid network object */ 165 | VIR_ERR_NETWORK_EXIST = 37, /* the network already exist */ 166 | VIR_ERR_SYSTEM_ERROR = 38, /* general system call failure */ 167 | VIR_ERR_RPC = 39, /* some sort of RPC error */ 168 | VIR_ERR_GNUTLS_ERROR = 40, /* error from a GNUTLS call */ 169 | VIR_WAR_NO_NETWORK = 41, /* failed to start network */ 170 | VIR_ERR_NO_DOMAIN = 42, /* domain not found or unexpectedly 171 | disappeared */ 172 | VIR_ERR_NO_NETWORK = 43, /* network not found */ 173 | VIR_ERR_INVALID_MAC = 44, /* invalid MAC address */ 174 | VIR_ERR_AUTH_FAILED = 45, /* authentication failed */ 175 | VIR_ERR_INVALID_STORAGE_POOL = 46, /* invalid storage pool object */ 176 | VIR_ERR_INVALID_STORAGE_VOL = 47, /* invalid storage vol object */ 177 | VIR_WAR_NO_STORAGE = 48, /* failed to start storage */ 178 | VIR_ERR_NO_STORAGE_POOL = 49, /* storage pool not found */ 179 | VIR_ERR_NO_STORAGE_VOL = 50, /* storage volume not found */ 180 | VIR_WAR_NO_NODE = 51, /* failed to start node driver */ 181 | VIR_ERR_INVALID_NODE_DEVICE = 52, /* invalid node device object */ 182 | VIR_ERR_NO_NODE_DEVICE = 53, /* node device not found */ 183 | VIR_ERR_NO_SECURITY_MODEL = 54, /* security model not found */ 184 | VIR_ERR_OPERATION_INVALID = 55, /* operation is not applicable at this 185 | time */ 186 | VIR_WAR_NO_INTERFACE = 56, /* failed to start interface driver */ 187 | VIR_ERR_NO_INTERFACE = 57, /* interface driver not running */ 188 | VIR_ERR_INVALID_INTERFACE = 58, /* invalid interface object */ 189 | VIR_ERR_MULTIPLE_INTERFACES = 59, /* more than one matching interface 190 | found */ 191 | VIR_WAR_NO_NWFILTER = 60, /* failed to start nwfilter driver */ 192 | VIR_ERR_INVALID_NWFILTER = 61, /* invalid nwfilter object */ 193 | VIR_ERR_NO_NWFILTER = 62, /* nw filter pool not found */ 194 | VIR_ERR_BUILD_FIREWALL = 63, /* nw filter pool not found */ 195 | VIR_WAR_NO_SECRET = 64, /* failed to start secret storage */ 196 | VIR_ERR_INVALID_SECRET = 65, /* invalid secret */ 197 | VIR_ERR_NO_SECRET = 66, /* secret not found */ 198 | VIR_ERR_CONFIG_UNSUPPORTED = 67, /* unsupported configuration 199 | construct */ 200 | VIR_ERR_OPERATION_TIMEOUT = 68, /* timeout occurred during operation */ 201 | VIR_ERR_MIGRATE_PERSIST_FAILED = 69,/* a migration worked, but making the 202 | VM persist on the dest host failed */ 203 | VIR_ERR_HOOK_SCRIPT_FAILED = 70, /* a synchronous hook script failed */ 204 | VIR_ERR_INVALID_DOMAIN_SNAPSHOT = 71,/* invalid domain snapshot */ 205 | VIR_ERR_NO_DOMAIN_SNAPSHOT = 72, /* domain snapshot not found */ 206 | VIR_ERR_INVALID_STREAM = 73, /* stream pointer not valid */ 207 | VIR_ERR_ARGUMENT_UNSUPPORTED = 74, /* valid API use but unsupported by 208 | the given driver */ 209 | VIR_ERR_STORAGE_PROBE_FAILED = 75, /* storage pool probe failed */ 210 | VIR_ERR_STORAGE_POOL_BUILT = 76, /* storage pool already built */ 211 | VIR_ERR_SNAPSHOT_REVERT_RISKY = 77, /* force was not requested for a 212 | risky domain snapshot revert */ 213 | VIR_ERR_OPERATION_ABORTED = 78, /* operation on a domain was 214 | canceled/aborted by user */ 215 | VIR_ERR_AUTH_CANCELLED = 79, /* authentication cancelled */ 216 | VIR_ERR_NO_DOMAIN_METADATA = 80, /* The metadata is not present */ 217 | VIR_ERR_MIGRATE_UNSAFE = 81, /* Migration is not safe */ 218 | VIR_ERR_OVERFLOW = 82, /* integer overflow */ 219 | VIR_ERR_BLOCK_COPY_ACTIVE = 83, /* action prevented by block copy job */ 220 | VIR_ERR_OPERATION_UNSUPPORTED = 84, /* The requested operation is not 221 | supported */ 222 | VIR_ERR_SSH = 85, /* error in ssh transport driver */ 223 | VIR_ERR_AGENT_UNRESPONSIVE = 86, /* guest agent is unresponsive, 224 | not running or not usable */ 225 | VIR_ERR_RESOURCE_BUSY = 87, /* resource is already in use */ 226 | VIR_ERR_ACCESS_DENIED = 88, /* operation on the object/resource 227 | was denied */ 228 | VIR_ERR_DBUS_SERVICE = 89, /* error from a dbus service */ 229 | VIR_ERR_STORAGE_VOL_EXIST = 90, /* the storage vol already exists */ 230 | VIR_ERR_CPU_INCOMPATIBLE = 91, /* given CPU is incompatible with host 231 | CPU*/ 232 | VIR_ERR_XML_INVALID_SCHEMA = 92, /* XML document doesn't validate against schema */ 233 | } virErrorNumber; 234 | ]] 235 | 236 | ffi.cdef[[ 237 | 238 | typedef void (*virErrorFunc) (void *userData, virErrorPtr error); 239 | 240 | 241 | virErrorPtr virGetLastError (void); 242 | virErrorPtr virSaveLastError (void); 243 | void virResetLastError (void); 244 | void virResetError (virErrorPtr err); 245 | void virFreeError (virErrorPtr err); 246 | 247 | const char * virGetLastErrorMessage (void); 248 | 249 | virErrorPtr virConnGetLastError (virConnectPtr conn); 250 | void virConnResetLastError (virConnectPtr conn); 251 | int virCopyLastError (virErrorPtr to); 252 | 253 | void virDefaultErrorFunc (virErrorPtr err); 254 | void virSetErrorFunc (void *userData, 255 | virErrorFunc handler); 256 | void virConnSetErrorFunc (virConnectPtr conn, 257 | void *userData, 258 | virErrorFunc handler); 259 | int virConnCopyLastError (virConnectPtr conn, 260 | virErrorPtr to); 261 | ]] 262 | 263 | --[[ 264 | export.GetLastError = export.Lib.virGetLastError; 265 | export.SaveLastError = export.Lib.virSaveLastError; 266 | export.ResetLastError = export.Lib.virResetLastError; 267 | export.ResetError = export.Lib.virResetError; 268 | export.FreeError = export.Lib.virFreeError; 269 | 270 | export.GetLastErrorMessage = export.Lib.virGetLastErrorMessage; 271 | 272 | export.ConnGetLastError = export.Lib.virConnGetLastError; 273 | export.ConnResetLastError = export.Lib.virConnResetLastError; 274 | export.CopyLastError = export.Lib.virCopyLastError; 275 | 276 | export.DefaultErrorFunc = export.Lib.DefaultErrorFunc; 277 | export.SetErrorFunc = export.Lib.virSetErrorFunc; 278 | export.ConnSetErrorFunc = export.Lib.virConnSetErrorFunc; 279 | export.ConnCopyLastError = export.Lib.virConnCopyLastError; 280 | --]] 281 | 282 | return export; 283 | --------------------------------------------------------------------------------