libvirt/src/libvirt_public.syms

865 lines
20 KiB
Plaintext
Raw Normal View History

#
# Officially exported symbols, for which header
# file definitions are installed in /usr/include/libvirt
# either from libvirt.h and virterror.h
#
# Versions here are *fixed* to match the libvirt version
# at which the symbol was introduced. This ensures that
# a new client app requiring symbol foo() can't accidentally
# run with old libvirt.so not providing foo() - the global
# soname version info can't enforce this since we never
# change the soname
#
LIBVIRT_0.0.3 {
global:
virConnectClose;
virConnectGetType;
virConnectGetVersion;
virConnectListDomains;
virConnectNumOfDomains;
virConnectOpen;
virConnectOpenReadOnly;
virDomainCreateLinux;
virDomainDestroy;
virDomainFree;
virDomainGetID;
virDomainGetInfo;
virDomainGetMaxMemory;
virDomainGetName;
virDomainGetOSType;
virDomainGetXMLDesc;
virDomainLookupByID;
virDomainLookupByName;
virDomainRestore;
virDomainResume;
virDomainSave;
virDomainSetMaxMemory;
virDomainShutdown;
virDomainSuspend;
virGetVersion;
};
LIBVIRT_0.0.5 {
global:
virDomainLookupByUUID;
virDomainGetUUID;
} LIBVIRT_0.0.3;
LIBVIRT_0.1.0 {
global:
virInitialize;
virNodeGetInfo;
virDomainReboot;
virCopyLastError;
virConnSetErrorFunc;
virResetLastError;
virResetError;
virConnGetLastError;
virGetLastError;
virSetErrorFunc;
virConnCopyLastError;
virConnResetLastError;
virDefaultErrorFunc;
} LIBVIRT_0.0.5;
LIBVIRT_0.1.1 {
global:
virDomainLookupByUUIDString;
virDomainGetUUIDString;
virDomainSetMemory;
virDomainDefineXML;
virDomainCreate;
virDomainUndefine;
virConnectListDefinedDomains;
} LIBVIRT_0.1.0;
LIBVIRT_0.1.4 {
global:
virDomainSetVcpus;
virDomainPinVcpu;
virDomainGetVcpus;
} LIBVIRT_0.1.1;
LIBVIRT_0.1.5 {
global:
virConnectNumOfDefinedDomains;
} LIBVIRT_0.1.4;
LIBVIRT_0.1.9 {
global:
virDomainCoreDump;
virDomainAttachDevice;
virDomainDetachDevice;
} LIBVIRT_0.1.5;
LIBVIRT_0.2.0 {
global:
virConnectNumOfNetworks;
virConnectListNetworks;
virConnectNumOfDefinedNetworks;
virConnectListDefinedNetworks;
virNetworkLookupByName;
virNetworkLookupByUUID;
virNetworkLookupByUUIDString;
virNetworkCreateXML;
virNetworkDefineXML;
virNetworkUndefine;
virNetworkCreate;
virNetworkDestroy;
virNetworkFree;
virNetworkGetName;
virNetworkGetUUID;
virNetworkGetUUIDString;
virNetworkGetXMLDesc;
virNetworkGetBridgeName;
} LIBVIRT_0.1.9;
LIBVIRT_0.2.1 {
global:
virConnectGetCapabilities;
virConnectGetMaxVcpus;
virDomainGetMaxVcpus;
virDomainGetAutostart;
virDomainSetAutostart;
virNetworkGetAutostart;
virNetworkSetAutostart;
} LIBVIRT_0.2.0;
LIBVIRT_0.2.3 {
global:
virDomainGetSchedulerType;
virDomainGetSchedulerParameters;
virDomainSetSchedulerParameters;
} LIBVIRT_0.2.1;
LIBVIRT_0.3.0 {
global:
virConnectGetHostname;
virConnectGetURI;
virDomainGetConnect;
virNetworkGetConnect;
} LIBVIRT_0.2.3;
LIBVIRT_0.3.2 {
global:
virDomainMigrate;
virDomainBlockStats;
virDomainInterfaceStats;
} LIBVIRT_0.3.0;
LIBVIRT_0.3.3 {
global:
virNodeGetCellsFreeMemory;
virNodeGetFreeMemory;
} LIBVIRT_0.3.2;
LIBVIRT_0.4.0 {
global:
virConnectOpenAuth;
virConnectAuthPtrDefault;
} LIBVIRT_0.3.3;
LIBVIRT_0.4.1 {
global:
virStoragePoolGetConnect;
virConnectNumOfStoragePools;
virConnectNumOfDefinedStoragePools;
virConnectListStoragePools;
virConnectListDefinedStoragePools;
virStoragePoolLookupByName;
virStoragePoolLookupByUUID;
virStoragePoolLookupByUUIDString;
virStoragePoolLookupByVolume;
virStoragePoolCreateXML;
virStoragePoolDefineXML;
virStoragePoolUndefine;
virStoragePoolCreate;
virStoragePoolBuild;
virStoragePoolDestroy;
virStoragePoolDelete;
virStoragePoolRefresh;
virStoragePoolFree;
virStoragePoolGetName;
virStoragePoolGetUUID;
virStoragePoolGetUUIDString;
virStoragePoolGetInfo;
virStoragePoolGetXMLDesc;
virStoragePoolSetAutostart;
virStoragePoolGetAutostart;
virStoragePoolNumOfVolumes;
virStoragePoolListVolumes;
virStorageVolGetConnect;
virStorageVolLookupByName;
virStorageVolLookupByKey;
virStorageVolLookupByPath;
virStorageVolCreateXML;
virStorageVolDelete;
virStorageVolFree;
virStorageVolGetName;
virStorageVolGetKey;
virStorageVolGetInfo;
virStorageVolGetXMLDesc;
virStorageVolGetPath;
} LIBVIRT_0.4.0;
LIBVIRT_0.4.2 {
global:
virDomainBlockPeek;
virDomainMemoryPeek;
} LIBVIRT_0.4.1;
LIBVIRT_0.4.5 {
global:
virConnectFindStoragePoolSources;
} LIBVIRT_0.4.2;
LIBVIRT_0.5.0 {
global:
virDomainCreateXML;
virEventRegisterImpl;
virConnectDomainEventRegister;
virConnectDomainEventDeregister;
virNodeNumOfDevices;
virNodeListDevices;
virNodeDeviceLookupByName;
virNodeDeviceFree;
virNodeDeviceGetXMLDesc;
virNodeDeviceGetName;
virNodeDeviceGetParent;
virNodeDeviceNumOfCaps;
virNodeDeviceListCaps;
} LIBVIRT_0.4.5;
LIBVIRT_0.6.0 {
global:
virConnectRef;
virDomainRef;
virNetworkRef;
virStoragePoolRef;
virStorageVolRef;
virNodeDeviceRef;
} LIBVIRT_0.5.0;
LIBVIRT_0.6.1 {
global:
virFreeError;
virSaveLastError;
virNodeDeviceDettach;
virNodeDeviceReAttach;
virNodeDeviceReset;
virDomainGetSecurityLabel;
virNodeGetSecurityModel;
} LIBVIRT_0.6.0;
LIBVIRT_0.6.3 {
global:
virNodeDeviceCreateXML;
virNodeDeviceDestroy;
} LIBVIRT_0.6.1;
LIBVIRT_0.6.4 {
global:
virInterfaceGetConnect;
virConnectNumOfInterfaces;
virConnectListInterfaces;
virInterfaceLookupByName;
virInterfaceLookupByMACString;
virInterfaceGetName;
virInterfaceGetMACString;
virInterfaceGetXMLDesc;
virInterfaceRef;
virInterfaceFree;
virInterfaceDefineXML;
virInterfaceUndefine;
virInterfaceCreate;
virInterfaceDestroy;
virStorageVolCreateXMLFrom;
virConnectDomainXMLFromNative;
virConnectDomainXMLToNative;
} LIBVIRT_0.6.3;
2009-05-21 13:46:35 +00:00
LIBVIRT_0.7.0 {
global:
virConnectNumOfDefinedInterfaces;
virConnectListDefinedInterfaces;
} LIBVIRT_0.6.4;
LIBVIRT_0.7.1 {
global:
virSecretGetConnect;
virConnectNumOfSecrets;
virConnectListSecrets;
Fix UUID handling in secrets/storage encryption APIs Convert all the secret/storage encryption APIs / wire format to handle UUIDs in raw format instead of non-canonical printable format. Guarentees data format correctness. * docs/schemas/storageencryption.rng: Make UUID mandatory for a secret and validate fully * docs/schemas/secret.rng: Fully validate UUID * include/libvirt/libvirt.h, include/libvirt/libvirt.h.in, Add virSecretLookupByUUID and virSecretGetUUID. Make virSecretGetUUIDString follow normal API design pattern * python/generator.py: Skip generation of virSecretGetUUID, virSecretGetUUIDString and virSecretLookupByUUID * python/libvir.c, python/libvirt-python-api.xml: Manual impl of virSecretGetUUID,virSecretGetUUIDString and virSecretLookupByUUID * qemud/remote.c: s/virSecretLookupByUUIDString/virSecretLookupByUUID/ Fix get_nonnull_secret/make_nonnull_secret to use unsigned char * qemud/remote_protocol.x: Fix remote_nonnull_secret to use a remote_uuid instead of remote_nonnull_string for UUID field. Rename REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING to REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING and make it take an remote_uuid value * qemud/remote_dispatch_args.h, qemud/remote_dispatch_prototypes.h, qemud/remote_dispatch_ret.h, qemud/remote_dispatch_table.h, qemud/remote_protocol.c, qemud/remote_protocol.h: Re-generate * src/datatypes.h, src/datatypes.c: Store UUID in raw format instead of printable. Change virGetSecret to use raw format UUID * src/driver.h: Rename virDrvSecretLookupByUUIDString to virDrvSecretLookupByUUID and use raw format UUID * src/libvirt.c: Add virSecretLookupByUUID and virSecretGetUUID and re-implement virSecretLookupByUUIDString and virSecretGetUUIDString in terms of those * src/libvirt_public.syms: Add virSecretLookupByUUID and virSecretGetUUID * src/remote_internal.c: Rename remoteSecretLookupByUUIDString to remoteSecretLookupByUUID. Fix typo in args for remoteSecretDefineXML impl. Use raw UUID format for get_nonnull_secret and make_nonnull_secret * src/storage_encryption_conf.c, src/storage_encryption_conf.h: Storage UUID in raw format, and require it to be present in XML. Use UUID parser to validate. * secret_conf.h, secret_conf.c: Generate a UUID if none is provided. Storage UUID in raw format. * src/secret_driver.c: Adjust to deal with raw UUIDs. Save secrets in a filed with printable UUID, instead of base64 UUID. * src/virsh.c: Adjust for changed public API contract of virSecretGetUUIDString. * src/storage_Backend.c: DOn't undefine secret we just generated upon successful volume creation. Fix to handle raw UUIDs. Generate a non-clashing UUID * src/qemu_driver.c: Change to use lookupByUUID instead of lookupByUUIDString
2009-09-10 16:44:12 +00:00
virSecretLookupByUUID;
virSecretLookupByUUIDString;
virSecretLookupByUsage;
virSecretDefineXML;
Fix UUID handling in secrets/storage encryption APIs Convert all the secret/storage encryption APIs / wire format to handle UUIDs in raw format instead of non-canonical printable format. Guarentees data format correctness. * docs/schemas/storageencryption.rng: Make UUID mandatory for a secret and validate fully * docs/schemas/secret.rng: Fully validate UUID * include/libvirt/libvirt.h, include/libvirt/libvirt.h.in, Add virSecretLookupByUUID and virSecretGetUUID. Make virSecretGetUUIDString follow normal API design pattern * python/generator.py: Skip generation of virSecretGetUUID, virSecretGetUUIDString and virSecretLookupByUUID * python/libvir.c, python/libvirt-python-api.xml: Manual impl of virSecretGetUUID,virSecretGetUUIDString and virSecretLookupByUUID * qemud/remote.c: s/virSecretLookupByUUIDString/virSecretLookupByUUID/ Fix get_nonnull_secret/make_nonnull_secret to use unsigned char * qemud/remote_protocol.x: Fix remote_nonnull_secret to use a remote_uuid instead of remote_nonnull_string for UUID field. Rename REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING to REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING and make it take an remote_uuid value * qemud/remote_dispatch_args.h, qemud/remote_dispatch_prototypes.h, qemud/remote_dispatch_ret.h, qemud/remote_dispatch_table.h, qemud/remote_protocol.c, qemud/remote_protocol.h: Re-generate * src/datatypes.h, src/datatypes.c: Store UUID in raw format instead of printable. Change virGetSecret to use raw format UUID * src/driver.h: Rename virDrvSecretLookupByUUIDString to virDrvSecretLookupByUUID and use raw format UUID * src/libvirt.c: Add virSecretLookupByUUID and virSecretGetUUID and re-implement virSecretLookupByUUIDString and virSecretGetUUIDString in terms of those * src/libvirt_public.syms: Add virSecretLookupByUUID and virSecretGetUUID * src/remote_internal.c: Rename remoteSecretLookupByUUIDString to remoteSecretLookupByUUID. Fix typo in args for remoteSecretDefineXML impl. Use raw UUID format for get_nonnull_secret and make_nonnull_secret * src/storage_encryption_conf.c, src/storage_encryption_conf.h: Storage UUID in raw format, and require it to be present in XML. Use UUID parser to validate. * secret_conf.h, secret_conf.c: Generate a UUID if none is provided. Storage UUID in raw format. * src/secret_driver.c: Adjust to deal with raw UUIDs. Save secrets in a filed with printable UUID, instead of base64 UUID. * src/virsh.c: Adjust for changed public API contract of virSecretGetUUIDString. * src/storage_Backend.c: DOn't undefine secret we just generated upon successful volume creation. Fix to handle raw UUIDs. Generate a non-clashing UUID * src/qemu_driver.c: Change to use lookupByUUID instead of lookupByUUIDString
2009-09-10 16:44:12 +00:00
virSecretGetUUID;
virSecretGetUUIDString;
virSecretGetUsageType;
virSecretGetUsageID;
virSecretGetXMLDesc;
virSecretSetValue;
virSecretGetValue;
virSecretUndefine;
virSecretRef;
virSecretFree;
} LIBVIRT_0.7.0;
LIBVIRT_0.7.2 {
global:
virStreamNew;
virStreamRef;
virStreamSend;
virStreamRecv;
virStreamSendAll;
virStreamRecvAll;
virStreamEventAddCallback;
virStreamEventUpdateCallback;
virStreamEventRemoveCallback;
virStreamFinish;
virStreamAbort;
virStreamFree;
virDomainMigrateToURI;
} LIBVIRT_0.7.1;
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
LIBVIRT_0.7.3 {
global:
virConnectGetLibVersion;
virConnectIsEncrypted;
virConnectIsSecure;
virDomainIsActive;
virDomainIsPersistent;
virNetworkIsActive;
virNetworkIsPersistent;
virStoragePoolIsActive;
virStoragePoolIsPersistent;
virInterfaceIsActive;
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
} LIBVIRT_0.7.2;
LIBVIRT_0.7.5 {
global:
virConnectCompareCPU;
virDomainMemoryStats;
} LIBVIRT_0.7.3;
LIBVIRT_0.7.7 {
global:
virDomainAttachDeviceFlags;
virDomainDetachDeviceFlags;
2010-01-22 13:52:41 +00:00
virConnectBaselineCPU;
virDomainGetJobInfo;
virDomainAbortJob;
} LIBVIRT_0.7.5;
LIBVIRT_0.8.0 {
2010-03-01 19:56:46 +00:00
global:
virStorageVolWipe;
virDomainMigrateSetMaxDowntime;
Introduce a new public API for domain events The current API for domain events has a number of problems - Only allows for domain lifecycle change events - Does not allow the same callback to be registered multiple times - Does not allow filtering of events to a specific domain This introduces a new more general purpose domain events API typedef enum { VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, /* virConnectDomainEventCallback */ ...more events later.. } int virConnectDomainEventRegisterAny(virConnectPtr conn, virDomainPtr dom, /* Optional, to filter */ int eventID, virConnectDomainEventGenericCallback cb, void *opaque, virFreeCallback freecb); int virConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID); Since different event types can received different data in the callback, the API is defined with a generic callback. Specific events will each have a custom signature for their callback. Thus when registering an event it is neccessary to cast the callback to the generic signature eg int myDomainEventCallback(virConnectPtr conn, virDomainPtr dom, int event, int detail, void *opaque) { ... } virConnectDomainEventRegisterAny(conn, NULL, VIR_DOMAIN_EVENT_ID_LIFECYCLE, VIR_DOMAIN_EVENT_CALLBACK(myDomainEventCallback) NULL, NULL); The VIR_DOMAIN_EVENT_CALLBACK() macro simply does a "bad" cast to the generic signature * include/libvirt/libvirt.h.in: Define new APIs for registering domain events * src/driver.h: Internal driver entry points for new events APIs * src/libvirt.c: Wire up public API to driver API for events APIs * src/libvirt_public.syms: Export new APIs * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c, src/xenapi/xenapi_driver.c: Stub out new API entries
2010-03-18 13:01:48 +00:00
virConnectDomainEventRegisterAny;
virConnectDomainEventDeregisterAny;
virDomainUpdateDeviceFlags;
virConnectListNWFilters;
virConnectNumOfNWFilters;
virNWFilterLookupByName;
virNWFilterLookupByUUID;
virNWFilterLookupByUUIDString;
virNWFilterFree;
virNWFilterGetName;
virNWFilterGetUUID;
virNWFilterGetUUIDString;
virNWFilterGetXMLDesc;
virNWFilterRef;
virNWFilterDefineXML;
virNWFilterUndefine;
virDomainManagedSave;
virDomainHasManagedSaveImage;
virDomainManagedSaveRemove;
virDomainSnapshotCreateXML;
virDomainSnapshotGetXMLDesc;
virDomainSnapshotNum;
virDomainSnapshotListNames;
virDomainSnapshotLookupByName;
virDomainHasCurrentSnapshot;
virDomainSnapshotCurrent;
virDomainRevertToSnapshot;
virDomainSnapshotDelete;
virDomainSnapshotFree;
2010-03-01 19:56:46 +00:00
} LIBVIRT_0.7.7;
LIBVIRT_0.8.1 {
global:
virDomainGetBlockInfo;
} LIBVIRT_0.8.0;
LIBVIRT_0.8.2 {
global:
virDomainCreateWithFlags;
} LIBVIRT_0.8.1;
LIBVIRT_0.8.5 {
global:
virDomainSetMemoryParameters;
virDomainGetMemoryParameters;
virDomainGetVcpusFlags;
virDomainSetVcpusFlags;
} LIBVIRT_0.8.2;
LIBVIRT_0.8.6 {
global:
virDomainOpenConsole;
virDomainIsUpdated;
} LIBVIRT_0.8.5;
LIBVIRT_0.8.8 {
global:
virConnectGetSysinfo;
} LIBVIRT_0.8.6;
LIBVIRT_0.9.0 {
global:
virDomainGetBlkioParameters;
virDomainMigrateSetMaxSpeed;
virDomainSetBlkioParameters;
virDomainSetMemoryFlags;
virEventRegisterDefaultImpl;
virEventRunDefaultImpl;
virStorageVolDownload;
virStorageVolUpload;
} LIBVIRT_0.8.8;
2011-05-10 08:26:01 +00:00
LIBVIRT_0.9.2 {
global:
virDomainGetSchedulerParametersFlags;
virDomainGetState;
2011-05-10 08:26:01 +00:00
virDomainInjectNMI;
virDomainMigrate2;
virDomainMigrateToURI2;
virDomainScreenshot;
virDomainSetSchedulerParametersFlags;
virInterfaceChangeBegin;
virInterfaceChangeCommit;
virInterfaceChangeRollback;
2011-05-10 08:26:01 +00:00
} LIBVIRT_0.9.0;
LIBVIRT_0.9.3 {
global:
virDomainGetControlInfo;
virDomainGetVcpuPinInfo;
virDomainPinVcpuFlags;
virDomainSendKey;
virEventAddHandle;
virEventAddTimeout;
virEventRemoveHandle;
virEventRemoveTimeout;
virEventUpdateHandle;
virEventUpdateTimeout;
virNodeGetCPUStats;
virNodeGetMemoryStats;
} LIBVIRT_0.9.2;
LIBVIRT_0.9.4 {
global:
virDomainRestoreFlags;
virDomainSaveFlags;
virDomainSaveImageDefineXML;
virDomainSaveImageGetXMLDesc;
virDomainUndefineFlags;
virDomainDestroyFlags;
virDomainBlockJobAbort;
virDomainGetBlockJobInfo;
virDomainBlockJobSetSpeed;
virDomainBlockPull;
} LIBVIRT_0.9.3;
LIBVIRT_0.9.5 {
global:
virDomainBlockStatsFlags;
virDomainMigrateGetMaxSpeed;
virDomainSnapshotGetConnect;
virDomainSnapshotGetDomain;
virDomainSnapshotGetName;
} LIBVIRT_0.9.4;
LIBVIRT_0.9.7 {
global:
virDomainOpenGraphics;
virDomainReset;
virDomainSnapshotGetParent;
virDomainSnapshotListChildrenNames;
virDomainSnapshotNumChildren;
} LIBVIRT_0.9.5;
LIBVIRT_0.9.8 {
global:
virConnectIsAlive;
virConnectSetKeepAlive;
virDomainBlockResize;
virDomainGetBlockIoTune;
virDomainSetBlockIoTune;
virNodeSuspendForDuration;
} LIBVIRT_0.9.7;
LIBVIRT_0.9.9 {
global:
virDomainGetInterfaceParameters;
virDomainGetNumaParameters;
virDomainSetInterfaceParameters;
virDomainSetNumaParameters;
} LIBVIRT_0.9.8;
LIBVIRT_0.9.10 {
global:
block rebase: add new API virDomainBlockRebase Qemu is adding the ability to do a partial rebase. That is, given: base <- intermediate <- current virDomainBlockPull will produce: current but qemu now has the ability to leave base in the chain, to produce: base <- current Note that current qemu can only do a forward merge, and only with the current image as the destination, which is fully described by this API without flags. But in the future, it may be possible to enhance this API for additional scenarios by using flags: Merging the current image back into a previous image (that is, undoing a live snapshot), could be done by passing base as the destination and flags with a bit requesting a backward merge. Merging any other part of the image chain, whether forwards (the backing image contents are pulled into the newer file) or backwards (the deltas recorded in the newer file are merged back into the backing file), could also be done by passing a new flag that says that base should be treated as an XML snippet rather than an absolute path name, where the XML could then supply the additional instructions of which part of the image chain is being merged into any other part. * include/libvirt/libvirt.h.in (virDomainBlockRebase): New declaration. * src/libvirt.c (virDomainBlockRebase): Implement it. * src/libvirt_public.syms (LIBVIRT_0.9.10): Export it. * src/driver.h (virDrvDomainBlockRebase): New driver callback. * src/rpc/gendispatch.pl (long_legacy): Add exemption. * docs/apibuild.py (long_legacy_functions): Likewise.
2012-02-01 04:19:51 +00:00
virDomainBlockRebase;
virDomainGetCPUStats;
virDomainGetDiskErrors;
virDomainGetMetadata;
virDomainPMSuspendForDuration;
virDomainSetMetadata;
virDomainShutdownFlags;
virStorageVolResize;
virStorageVolWipePattern;
} LIBVIRT_0.9.9;
LIBVIRT_0.9.11 {
global:
virDomainPMWakeup;
} LIBVIRT_0.9.10;
LIBVIRT_0.9.13 {
global:
lib: Add public api to enable atomic listing of guest This patch adds a new public api that lists domains. The new approach is different from those used before. There are key points to this: 1) The list is acquired atomically and contains both active and inactive domains (guests). This eliminates the need to call two different list APIs, where the state might change in between the calls. 2) The returned list consists of virDomainPtrs instead of names or ID's that have to be converted to virDomainPtrs anyways using separate calls for each one of them. This is more convenient and saves hypervisor calls. 3) The returned list is auto-allocated. This saves a lot of hassle for the users. 4) Built in support for filtering. The API call supports various filtering flags that modify the output list according to user needs. Available filter groups: Domain status: VIR_CONNECT_LIST_DOMAINS_ACTIVE, VIR_CONNECT_LIST_DOMAINS_INACTIVE Domain persistence: VIR_CONNECT_LIST_DOMAINS_PERSISTENT, VIR_CONNECT_LIST_DOMAINS_TRANSIENT Domain state: VIR_CONNECT_LIST_DOMAINS_RUNNING, VIR_CONNECT_LIST_DOMAINS_PAUSED, VIR_CONNECT_LIST_DOMAINS_SHUTOFF, VIR_CONNECT_LIST_DOMAINS_OTHER Existence of managed save image: VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE, VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE Auto-start option: VIR_CONNECT_LIST_DOMAINS_AUTOSTART, VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART Existence of snapshot: VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT, VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT 5) The python binding returns a list of domain objects that is very neat to work with. The only problem with this approach is no support from code generators so both RPC code and python bindings had to be written manually. *include/libvirt/libvirt.h.in: - add API prototype - clean up whitespace mistakes nearby *python/generator.py: - inhibit generation of the bindings for the new api *src/driver.h: - add driver prototype - clean up some whitespace mistakes nearby *src/libvirt.c: - add public implementation *src/libvirt_public.syms: - export the new symbol
2012-05-18 15:22:02 +00:00
virConnectListAllDomains;
virDomainListAllSnapshots;
snapshot: new query APIs Right now, starting from just a virDomainSnapshotPtr, and wanting to know if it is the current snapshot for its respective domain, you have to use virDomainSnapshotGetDomain(), then virDomainSnapshotCurrent(), then compare the two names returned by virDomainSnapshotGetName(). It is a bit easier if we can directly query this information from the snapshot itself. Right now, it is possible to filter a snapshot listing based on whether snapshots have metadata that would prevent domain deletion, but the only way to learn if an individual snapshot has metadata is to see if that snapshot appears in the list returned by a listing. Additionally, I hope to expand the qemu driver in a future patch to use qemu-img to reconstruct snapshot XML corresponding to internal qcow2 snapshot names not otherwise tracked by libvirt (in part, so that libvirt can guarantee that new snapshots are not created with a name that would silently corrupt the existing portion of the qcow2 file); if I ever get that in, then it would no longer be an all-or-none decision on whether snapshots have metadata, and becomes all the more important to be able to directly determine that information from a particular snapshot. Other query functions (such as virDomainIsActive) do not have a flags argument, but since virDomainHasCurrentSnapshot takes a flags argument, I figured it was safer to provide a flags argument here as well. * include/libvirt/libvirt.h.in (virDomainSnapshotIsCurrent) (virDomainSnapshotHasMetadata): New declarations. * src/libvirt.c (virDomainSnapshotIsCurrent) (virDomainSnapshotHasMetadata): New functions. * src/libvirt_public.syms (LIBVIRT_0.9.13): Export them. * src/driver.h (virDrvDomainSnapshotIsCurrent) (virDrvDomainSnapshotHasMetadata): New driver callbacks.
2012-05-23 23:10:39 +00:00
virDomainSnapshotHasMetadata;
virDomainSnapshotIsCurrent;
virDomainSnapshotListAllChildren;
virDomainSnapshotRef;
} LIBVIRT_0.9.11;
LIBVIRT_0.10.0 {
global:
virDomainGetHostname;
virConnectRegisterCloseCallback;
virConnectUnregisterCloseCallback;
virDomainGetSecurityLabelList;
virDomainPinEmulator;
virDomainGetEmulatorPinInfo;
} LIBVIRT_0.9.13;
LIBVIRT_0.10.2 {
global:
virConnectListAllInterfaces;
virConnectListAllNetworks;
virConnectListAllNodeDevices;
virConnectListAllNWFilters;
virConnectListAllSecrets;
virConnectListAllStoragePools;
blockjob: add virDomainBlockCommit A block commit moves data in the opposite direction of block pull. Block pull reduces the chain length by dropping backing files after data has been pulled into the top overlay, and is always safe; block commit reduces the chain length by dropping overlays after data has been committed into the backing file, and any files that depended on base but not on top are invalidated at any point where they have unallocated data that is now pointing to changed contents in base. Both directions are useful, however: a qcow2 layer that is more than 50% allocated will typically be faster with a pull operation, while a qcow2 layer with less than 50% allocation will be faster as a commit operation. Committing across multiple layers can be more efficient than repeatedly committing one layer at a time, but requires extra support from the hypervisor. This API matches Jeff Cody's proposed qemu command 'block-commit': https://lists.gnu.org/archive/html/qemu-devel/2012-09/msg02226.html Jeff's command is still in the works for qemu 1.3, and may gain further enhancements, such as the ability to control on-error handling (it will be comparable to the error handling Paolo is adding to 'drive-mirror', so a similar solution will be needed when I finally propose virDomainBlockCopy with more functionality than the basics supported by virDomainBlockRebase). However, even without qemu support, this API will be useful for _offline_ block commits, by wrapping qemu-img calls and turning them into a block job, so this API is worth committing now. For some examples of how this will be implemented, all starting with the chain: base <- snap1 <- snap2 <- active + These are equivalent: virDomainBlockCommit(dom, disk, NULL, NULL, 0, 0) virDomainBlockCommit(dom, disk, NULL, "active", 0, 0) virDomainBlockCommit(dom, disk, "base", NULL, 0, 0) virDomainBlockCommit(dom, disk, "base", "active", 0, 0) but cannot be implemented for online qemu with round 1 of Jeff's patches; and for offline images, it would require three back-to-back qemu-img invocations unless qemu-img is patched to allow more efficient multi-layer commits; the end result would be 'base' as the active disk with contents from all three other files, where 'snap1' and 'snap2' are invalid right away, and 'active' is invalid once any further changes to 'base' are made. + These are equivalent: virDomainBlockCommit(dom, disk, "snap2", NULL, 0, 0) virDomainBlockCommit(dom, disk, NULL, NULL, 0, _SHALLOW) they cannot be implemented for online qemu, but for offline, it is a matter of 'qemu-img commit active', so that 'snap2' is now the active disk with contents formerly in 'active'. + Similarly: virDomainBlockCommit(dom, disk, "snap2", NULL, 0, _DELETE) for an offline domain will merge 'active' into 'snap2', then delete 'active' to avoid leaving a potentially invalid file around. + This version: virDomainBlockCommit(dom, disk, NULL, "snap2", 0, _SHALLOW) can be implemented online with 'block-commit' passing a base of snap1 and a top of snap2; and can be implemented offline by 'qemu-img commit snap2' followed by 'qemu-img rebase -u -b snap1 active' * include/libvirt/libvirt.h.in (virDomainBlockCommit): New API. * src/libvirt.c (virDomainBlockCommit): Implement it. * src/libvirt_public.syms (LIBVIRT_0.10.2): Export it. * src/driver.h (virDrvDomainBlockCommit): New driver callback. * docs/apibuild.py (CParser.parseSignature): Add exception.
2012-09-17 17:56:27 +00:00
virDomainBlockCommit;
virNetworkUpdate;
virNodeGetMemoryParameters;
virNodeSetMemoryParameters;
virStoragePoolListAllVolumes;
} LIBVIRT_0.10.0;
LIBVIRT_1.0.0 {
global:
virNodeGetCPUMap;
} LIBVIRT_0.10.2;
LIBVIRT_1.0.1 {
global:
virDomainFSTrim;
virDomainSendProcessSignal;
} LIBVIRT_1.0.0;
LIBVIRT_1.0.2 {
global:
virDomainOpenChannel;
virTypedParamsAddBoolean;
virTypedParamsAddDouble;
virTypedParamsAddFromString;
virTypedParamsAddInt;
virTypedParamsAddLLong;
virTypedParamsAddString;
virTypedParamsAddUInt;
virTypedParamsAddULLong;
virTypedParamsClear;
virTypedParamsFree;
virTypedParamsGet;
virTypedParamsGetBoolean;
virTypedParamsGetDouble;
virTypedParamsGetInt;
virTypedParamsGetLLong;
virTypedParamsGetString;
virTypedParamsGetUInt;
virTypedParamsGetULLong;
} LIBVIRT_1.0.1;
LIBVIRT_1.0.3 {
global:
virDomainGetJobStats;
virDomainMigrateGetCompressionCache;
virDomainMigrateSetCompressionCache;
virNodeDeviceLookupSCSIHostByWWN;
} LIBVIRT_1.0.2;
LIBVIRT_1.0.5 {
global:
virNodeDeviceDetachFlags;
} LIBVIRT_1.0.3;
LIBVIRT_1.0.6 {
global:
virGetLastErrorMessage;
} LIBVIRT_1.0.5;
LIBVIRT_1.1.0 {
global:
virDomainMigrate3;
virDomainMigrateToURI3;
} LIBVIRT_1.0.6;
LIBVIRT_1.1.1 {
global:
virDomainCreateWithFiles;
virDomainCreateXMLWithFiles;
virDomainSetMemoryStatsPeriod;
} LIBVIRT_1.1.0;
LIBVIRT_1.1.3 {
global:
virConnectGetCPUModelNames;
} LIBVIRT_1.1.1;
LIBVIRT_1.2.1 {
global:
virConnectNetworkEventRegisterAny;
virConnectNetworkEventDeregisterAny;
} LIBVIRT_1.1.3;
LIBVIRT_1.2.3 {
global:
virDomainCoreDumpWithFormat;
} LIBVIRT_1.2.1;
LIBVIRT_1.2.5 {
global:
virDomainFSFreeze;
virDomainFSThaw;
virDomainGetTime;
virDomainSetTime;
} LIBVIRT_1.2.3;
LIBVIRT_1.2.6 {
global:
virNodeGetFreePages;
2014-06-23 21:01:49 +00:00
virNetworkDHCPLeaseFree;
virNetworkGetDHCPLeases;
} LIBVIRT_1.2.5;
LIBVIRT_1.2.7 {
global:
virConnectGetDomainCapabilities;
} LIBVIRT_1.2.6;
LIBVIRT_1.2.8 {
lib: Introduce API for retrieving bulk domain stats The motivation for this API is that management layers that use libvirt usually poll for statistics using various split up APIs we currently provide. To get all the necessary stuff, the app needs to issue a lot of calls and aggregate the results. The APIs I'm introducing here: 1) Returns data in a format that we can expand in the future and is (pseudo) hierarchical. The data is returned as typed parameters where the fields are constructed as dot-separated strings containing names and other stuff in a list of typed params. 2) Stats for multiple (all) domains can be queried at once and are returned in one call. This will decrease the overhead necessary to issue multiple calls per domain multiplied by the count of domains. 3) Selectable (bit mask) fields in the returned format. This will allow to retrieve only specific stats according to the app's need. The stats groups will be enabled using a bit field @stats passed as the function argument. A few sample stats groups that this API will support: VIR_DOMAIN_STATS_STATE VIR_DOMAIN_STATS_CPU VIR_DOMAIN_STATS_BLOCK VIR_DOMAIN_STATS_INTERFACE (Note that this is only an example, the initial implementation supports only VIR_DOMAIN_STATS_STATE while others will be added later.) the returned typed params will use the following scheme state.state = VIR_DOMAIN_RUNNING state.reason = VIR_DOMAIN_RUNNING_BOOTED (the actual values according to the enum) cpu.count = 8 cpu.0.state = running cpu.0.time = 1234
2014-08-26 19:11:42 +00:00
global:
virConnectGetAllDomainStats;
blockcopy: virDomainBlockCopy with XML destination, typed params This commit (finally) adds the virDomainBlockCopy API, with the intent that it will provide more power to the existing 'virsh blockcopy' command. 'virsh blockcopy' was first added in Apr 2012 (v0.9.12), which corresponds to the upstream qemu 1.2 timeframe. It was done as a hack on top of the existing virDomainBlockRebase() API call, for two reasons: 1) it was targetting a feature that landed first in downstream RHEL qemu, but had not stabilized in upstream qemu at the time (and indeed, 'drive-mirror' only landed upstream in qemu 1.3 with slight differences to the first RHEL attempt, and later gained further parameters like granularity and buf-size that are also worth exposing), and 2) extending an existing API allowed it to be backported without worrying about bumping .so versions. A virDomainBlockCopy() API was proposed at that time [1], but we decided not to accept it into libvirt until after upstream qemu stabilized, and it ended up getting scrapped. Whether or not RHEL should have attempted adding a new feature without getting it upstream first is a debate that can be held another day; but enough time has now elapsed that we are ready to do the interface cleanly. [1] https://www.redhat.com/archives/libvir-list/2012-April/msg00768.html Delaying the creation of a clean API until now has also had a benefit: we've only recently learned of a few shortcomings in the original design: 1) it is unable to target a network destination (such as a gluster volume) because it hard-coded the assumption that the destination is a local file name. Because of all the refactoring we've done to add virStorageSourcePtr, we are in a better position to declare an API that parses XML describing a host storage source as the copy destination, which was not possible had we implemented virDomainBlockCopy as it had been originally envisioned (although a network target will have to wait until a later libvirt release compared to the API addition to actually be implemented). 2) the design of using MiB/sec as the bandwidth throttle is rather coarse; qemu is actually tuned to bytes/second, and libvirt is preventing access to that level of detail. A later patch will add flags to existing block job API that can request bytes/second instead of back-compat MiB/s, but as this is a new API, we can get it right to begin with. At least I had the foresight to create 'virsh blockcopy' as a separate command at the UI level (commit 1f06c00) rather than leaking the underlying API overload of virDomainBlockRebase onto shell users. A further note on the bandwidth option: virTypedParameters intentionally lacks unsigned long (since variable-width interaction between mixed 32- vs. 64-bit client/server setups is nasty), but we have to deal with the fact that we are interacting with existing older code that mistakenly chose unsigned long bandwidth at a point before we decided to prohibit it in all new API. The typed parameter is therefore unsigned long long, but the implementation (in a later patch) will have to do overflow detection on 32-bit platforms, as well as capping the value to match the LLONG_MAX>>20 cap of the existing MiB/s interfaces. * include/libvirt/libvirt.h.in (virDomainBlockCopy): New API. (virDomainBlockJobType, virConnectDomainEventBlockJobStatus): Update related documentation. * src/libvirt.c (virDomainBlockCopy): Implement it. * src/libvirt_public.syms (LIBVIRT_1.2.8): Export it. * src/driver.h (_virDriver): New driver callback. Signed-off-by: Eric Blake <eblake@redhat.com>
2014-08-26 21:16:48 +00:00
virDomainBlockCopy;
lib: Introduce API for retrieving bulk domain stats The motivation for this API is that management layers that use libvirt usually poll for statistics using various split up APIs we currently provide. To get all the necessary stuff, the app needs to issue a lot of calls and aggregate the results. The APIs I'm introducing here: 1) Returns data in a format that we can expand in the future and is (pseudo) hierarchical. The data is returned as typed parameters where the fields are constructed as dot-separated strings containing names and other stuff in a list of typed params. 2) Stats for multiple (all) domains can be queried at once and are returned in one call. This will decrease the overhead necessary to issue multiple calls per domain multiplied by the count of domains. 3) Selectable (bit mask) fields in the returned format. This will allow to retrieve only specific stats according to the app's need. The stats groups will be enabled using a bit field @stats passed as the function argument. A few sample stats groups that this API will support: VIR_DOMAIN_STATS_STATE VIR_DOMAIN_STATS_CPU VIR_DOMAIN_STATS_BLOCK VIR_DOMAIN_STATS_INTERFACE (Note that this is only an example, the initial implementation supports only VIR_DOMAIN_STATS_STATE while others will be added later.) the returned typed params will use the following scheme state.state = VIR_DOMAIN_RUNNING state.reason = VIR_DOMAIN_RUNNING_BOOTED (the actual values according to the enum) cpu.count = 8 cpu.0.state = running cpu.0.time = 1234
2014-08-26 19:11:42 +00:00
virDomainListGetStats;
virDomainOpenGraphicsFD;
virDomainStatsRecordListFree;
} LIBVIRT_1.2.7;
LIBVIRT_1.2.9 {
global:
virNodeAllocPages;
} LIBVIRT_1.2.8;
LIBVIRT_1.2.11 {
global:
virDomainFSInfoFree;
virDomainGetFSInfo;
} LIBVIRT_1.2.9;
LIBVIRT_1.2.12 {
global:
virDomainDefineXMLFlags;
} LIBVIRT_1.2.11;
LIBVIRT_1.2.14 {
global:
virDomainIOThreadInfoFree;
virDomainGetIOThreadInfo;
virDomainPinIOThread;
virDomainInterfaceAddresses;
virDomainInterfaceFree;
} LIBVIRT_1.2.12;
LIBVIRT_1.2.15 {
global:
virDomainAddIOThread;
virDomainDelIOThread;
} LIBVIRT_1.2.14;
LIBVIRT_1.2.16 {
global:
virDomainSetUserPassword;
} LIBVIRT_1.2.15;
LIBVIRT_1.2.17 {
global:
virTypedParamsAddStringList;
} LIBVIRT_1.2.16;
LIBVIRT_1.2.19 {
global:
virDomainRename;
} LIBVIRT_1.2.17;
LIBVIRT_1.3.3 {
global:
virDomainMigrateStartPostCopy;
virDomainGetPerfEvents;
virDomainSetPerfEvents;
} LIBVIRT_1.2.19;
LIBVIRT_2.0.0 {
global:
virConnectStoragePoolEventRegisterAny;
virConnectStoragePoolEventDeregisterAny;
virDomainGetGuestVcpus;
virDomainSetGuestVcpus;
} LIBVIRT_1.3.3;
LIBVIRT_2.2.0 {
global:
virConnectNodeDeviceEventRegisterAny;
virConnectNodeDeviceEventDeregisterAny;
} LIBVIRT_2.0.0;
LIBVIRT_3.0.0 {
global:
virStorageVolGetInfoFlags;
virConnectSecretEventRegisterAny;
virConnectSecretEventDeregisterAny;
} LIBVIRT_2.2.0;
LIBVIRT_3.1.0 {
global:
virDomainSetBlockThreshold;
virDomainSetVcpu;
} LIBVIRT_3.0.0;
LIBVIRT_3.4.0 {
global:
virStreamRecvFlags;
virStreamRecvHole;
virStreamSendHole;
virStreamSparseRecvAll;
virStreamSparseSendAll;
} LIBVIRT_3.1.0;
LIBVIRT_3.7.0 {
global:
virDomainMigrateGetMaxDowntime;
virDomainManagedSaveGetXMLDesc;
virDomainManagedSaveDefineXML;
} LIBVIRT_3.4.0;
LIBVIRT_3.9.0 {
global:
virDomainSetLifecycleAction;
} LIBVIRT_3.7.0;
LIBVIRT_4.1.0 {
global:
virStoragePoolLookupByTargetPath;
} LIBVIRT_3.9.0;
LIBVIRT_4.4.0 {
global:
virDomainDetachDeviceAlias;
virConnectCompareHypervisorCPU;
virConnectBaselineHypervisorCPU;
} LIBVIRT_4.1.0;
LIBVIRT_4.5.0 {
global:
virGetLastErrorCode;
virGetLastErrorDomain;
virNodeGetSEVInfo;
virDomainGetLaunchSecurityInfo;
virNWFilterBindingLookupByPortDev;
virConnectListAllNWFilterBindings;
virNWFilterBindingCreateXML;
virNWFilterBindingGetXMLDesc;
virNWFilterBindingDelete;
virNWFilterBindingRef;
virNWFilterBindingFree;
virNWFilterBindingGetPortDev;
virNWFilterBindingGetFilterName;
} LIBVIRT_4.4.0;
LIBVIRT_4.10.0 {
global:
virDomainSetIOThreadParams;
} LIBVIRT_4.5.0;
LIBVIRT_5.2.0 {
global:
virConnectGetStoragePoolCapabilities;
} LIBVIRT_4.10.0;
LIBVIRT_5.5.0 {
global:
virNetworkListAllPorts;
virNetworkPortLookupByUUID;
virNetworkPortLookupByUUIDString;
virNetworkPortCreateXML;
virNetworkPortGetNetwork;
virNetworkPortGetParameters;
virNetworkPortGetXMLDesc;
virNetworkPortGetUUID;
virNetworkPortGetUUIDString;
virNetworkPortDelete;
virNetworkPortFree;
virNetworkPortRef;
virNetworkPortSetParameters;
} LIBVIRT_5.2.0;
backup: Introduce virDomainCheckpoint APIs Introduce a bunch of new public APIs related to backup checkpoints. Checkpoints are modeled heavily after virDomainSnapshotPtr (both represent a point in time of the guest), although a snapshot exists with the intent of rolling back to that state, while a checkpoint exists to make it possible to create an incremental backup at a later time. We may have a future hypervisor that can completely manage checkpoints without libvirt metadata, but the first two planned hypervisors (qemu and test) both always use libvirt for tracking metadata relations between checkpoints, so for now, I've deferred the counterpart of virDomainSnapshotHasMetadata for a separate API addition at a later date if there is ever a need for it. Note that until we allow snapshots and checkpoints to exist simultaneously on the same domain (although the actual prevention of this will be in a separate patch for the sake of an easier revert down the road), that it is not possible to branch out to create more than one checkpoint child to a given parent, although it may become possible later when we revert to a snapshot that coincides with a checkpoint. This also means that for now, the decision of which checkpoint becomes the parent of a newly created one is the only checkpoint with no child (so while there are APIs for dealing with a current snapshot, we do not need those for checkpoints). We may end up exposing a notion of a current checkpoint later, but it's easier to add stuff when proven needed than to blindly support it now and wish we hadn't exposed it. The following map shows the API relations to snapshots, with new APIs on the right: Operate on a domain object to create/redefine a child: virDomainSnapshotCreateXML virDomainCheckpointCreateXML Operate on a child object for lifetime management: virDomainSnapshotDelete virDomainCheckpointDelete virDomainSnapshotFree virDomainCheckpointFree virDomainSnapshotRef virDomainCheckpointRef Operate on a child object to learn more about it: virDomainSnapshotGetXMLDesc virDomainCheckpointGetXMLDesc virDomainSnapshotGetConnect virDomainCheckpointGetConnect virDomainSnapshotGetDomain virDomainCheckpointGetDomain virDomainSnapshotGetName virDomainCheckpiontGetName virDomainSnapshotGetParent virDomainCheckpiontGetParent virDomainSnapshotHasMetadata (deferred for later) virDomainSnapshotIsCurrent (no counterpart, see note above) Operate on a domain object to list all children: virDomainSnapshotNum (no counterparts, these are the old virDomainSnapshotListNames racy interfaces) virDomainSnapshotListAllSnapshots virDomainListAllCheckpoints Operate on a child object to list descendents: virDomainSnapshotNumChildren (no counterparts, these are the old virDomainSnapshotListChildrenNames racy interfaces) virDomainSnapshotListAllChildren virDomainCheckpointListAllChildren Operate on a domain to locate a particular child: virDomainSnapshotLookupByName virDomainCheckpointLookupByName virDomainSnapshotCurrent (no counterpart, see note above) virDomainHasCurrentSnapshot (no counterpart, old racy interface) Operate on a snapshot to roll back to earlier state: virDomainSnapshotRevert (no counterpart, instead checkpoints are used in incremental backups via XML to virDomainBackupBegin) Signed-off-by: Eric Blake <eblake@redhat.com> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
2019-03-13 19:35:26 +00:00
LIBVIRT_5.6.0 {
global:
virDomainCheckpointCreateXML;
virDomainCheckpointDelete;
virDomainCheckpointFree;
virDomainCheckpointGetConnect;
virDomainCheckpointGetDomain;
virDomainCheckpointGetName;
virDomainCheckpointGetParent;
virDomainCheckpointGetXMLDesc;
virDomainCheckpointListAllChildren;
virDomainCheckpointLookupByName;
virDomainCheckpointRef;
virDomainListAllCheckpoints;
} LIBVIRT_5.5.0;
LIBVIRT_5.7.0 {
global:
virDomainGetGuestInfo;
} LIBVIRT_5.6.0;
LIBVIRT_5.8.0 {
virConnectSetIdentity;
} LIBVIRT_5.7.0;
# .... define new API here using predicted next version number ....