External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-05 01:22:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Extend previous check to validate driver struct field names

Browse Source 
Ensure that the driver struct field names match the public
API names. For an API virXXXX we must have a driver struct
field xXXXX. ie strip the leading 'vir' and lowercase any
leading uppercase letters.

Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2013-04-22 18:26:01 +01:00
parent 2601e0f2cc
commit abe038cfc0
55 changed files with 1192 additions and 1184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
daemon/remote.c
View File

@ -3732,7 +3732,7 @@ static int remoteDispatchConnectSupportsFeature(virNetServerPtr server ATTRIBUTE
break;
default:
if ((supported = virDrvSupportsFeature(priv->conn, args->feature)) < 0)
if ((supported = virConnectSupportsFeature(priv->conn, args->feature)) < 0)
goto cleanup;
break;
}

2
docs/apibuild.py
View File

@ -50,6 +50,7 @@ ignored_words = {
}
ignored_functions = {
"virConnectSupportsFeature": "private function for remote access",
"virDomainMigrateFinish": "private function for migration",
"virDomainMigrateFinish2": "private function for migration",
"virDomainMigratePerform": "private function for migration",
@ -62,7 +63,6 @@ ignored_functions = {
"virDomainMigratePrepare3": "private function for migration",
"virDomainMigrateConfirm3": "private function for migration",
"virDomainMigratePrepareTunnel3": "private function for tunnelled migration",
"virDrvSupportsFeature": "private function for remote access",
"DllMain": "specific function for Win32",
"virTypedParameterArrayValidate": "internal function in virtypedparam.c",
"virTypedParameterAssign": "internal function in virtypedparam.c",

16
docs/hvsupport.pl
View File

@ -190,17 +190,13 @@ while (defined($line = <FILE>)) {
$groups{$ingrp} = { apis => {}, drivers => {} };
}
} elsif ($ingrp) {
if ($line =~ /^\s*vir(?:Drv|DevMon)(\w+)\s+(\w+);\s*$/) {
if ($line =~ /^\s*vir(?:Drv)(\w+)\s+(\w+);\s*$/) {
my $field = $2;
my $name = $1;
my $api;
if (exists $apis{"vir$name"}) {
$api = "vir$name";
} elsif (exists $apis{"virConnect$name"}) {
$api = "virConnect$name";
} elsif (exists $apis{"virNode$name"}) {
$api = "virNode$name";
} else {
die "driver $name does not have a public API";
}
@ -290,24 +286,24 @@ $groups{virDriver}->{apis}->{"domainMigrate"} = "virDomainMigrate";
my $openAuthVers = (0 * 1000 * 1000) + (4 * 1000) + 0;
foreach my $drv (keys %{$groups{"virDriver"}->{drivers}}) {
my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"open"};
my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
my $openVers;
if ($openVersStr =~ /(\d+)\.(\d+)\.(\d+)/) {
$openVers = ($1 * 1000 * 1000) + ($2 * 1000) + $3;
}
# virConnectOpenReadOnly always matches virConnectOpen version
$groups{"virDriver"}->{drivers}->{$drv}->{"openReadOnly"} =
$groups{"virDriver"}->{drivers}->{$drv}->{"open"};
$groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenReadOnly"} =
$groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
# virConnectOpenAuth is always 0.4.0 if the driver existed
# before this time, otherwise it matches the version of
# the driver's virConnectOpen entry
if ($openVersStr eq "Y" ||
$openVers >= $openAuthVers) {
$groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = $openVersStr;
$groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = $openVersStr;
} else {
$groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = "0.4.0";
$groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = "0.4.0";
}
}

13
src/check-drivername.pl
View File

@ -62,6 +62,19 @@ while (<DRVFILE>) {
my $name = $1;
print "Bogus name $1\n";
$status = 1;
} elsif (/^\s*(virDrv\w+)\s+(\w+);\s*/) {
my $drv = $1;
my $field = $2;
my $tmp = $drv;
$tmp =~ s/virDrv//;
$tmp =~ s/^NWFilter/nwfilter/;
$tmp =~ s/^(\w)/lc $1/e;
unless ($tmp eq $field) {
print "Driver struct field $field should be named $tmp\n";
$status = 1;
}
}
}

14
src/datatypes.c
View File

@ -144,19 +144,19 @@ virConnectDispose(void *obj)
virConnectPtr conn = obj;
if (conn->networkDriver)
conn->networkDriver->close(conn);
conn->networkDriver->connectClose(conn);
if (conn->interfaceDriver)
conn->interfaceDriver->close(conn);
conn->interfaceDriver->connectClose(conn);
if (conn->storageDriver)
conn->storageDriver->close(conn);
conn->storageDriver->connectClose(conn);
if (conn->deviceMonitor)
conn->deviceMonitor->close(conn);
conn->deviceMonitor->connectClose(conn);
if (conn->secretDriver)
conn->secretDriver->close(conn);
conn->secretDriver->connectClose(conn);
if (conn->nwfilterDriver)
conn->nwfilterDriver->close(conn);
conn->nwfilterDriver->connectClose(conn);
if (conn->driver)
conn->driver->close(conn);
conn->driver->connectClose(conn);
virMutexLock(&conn->lock);

258
src/driver.h
View File

@ -62,9 +62,9 @@ typedef enum {
* != 0 Feature is supported.
* 0 Feature is not supported.
*/
# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
((drv)->supports_feature ? \
(drv)->supports_feature((conn), (feature)) > 0 : 0)
# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
((drv)->connectSupportsFeature ? \
(drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
typedef virDrvOpenStatus
(*virDrvConnectOpen) (virConnectPtr conn,
@ -956,20 +956,20 @@ typedef int
struct _virDriver {
int no; /* the number virDrvNo */
const char *name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectSupportsFeature supports_feature;
virDrvConnectGetType type;
virDrvConnectGetVersion version;
virDrvConnectGetLibVersion libvirtVersion;
virDrvConnectGetHostname getHostname;
virDrvConnectGetSysinfo getSysinfo;
virDrvConnectGetMaxVcpus getMaxVcpus;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectSupportsFeature connectSupportsFeature;
virDrvConnectGetType connectGetType;
virDrvConnectGetVersion connectGetVersion;
virDrvConnectGetLibVersion connectGetLibVersion;
virDrvConnectGetHostname connectGetHostname;
virDrvConnectGetSysinfo connectGetSysinfo;
virDrvConnectGetMaxVcpus connectGetMaxVcpus;
virDrvNodeGetInfo nodeGetInfo;
virDrvConnectGetCapabilities getCapabilities;
virDrvConnectListDomains listDomains;
virDrvConnectNumOfDomains numOfDomains;
virDrvConnectListAllDomains listAllDomains;
virDrvConnectGetCapabilities connectGetCapabilities;
virDrvConnectListDomains connectListDomains;
virDrvConnectNumOfDomains connectNumOfDomains;
virDrvConnectListAllDomains connectListAllDomains;
virDrvDomainCreateXML domainCreateXML;
virDrvDomainLookupByID domainLookupByID;
virDrvDomainLookupByUUID domainLookupByUUID;
@ -1021,10 +1021,10 @@ struct _virDriver {
virDrvDomainGetSecurityLabelList domainGetSecurityLabelList;
virDrvNodeGetSecurityModel nodeGetSecurityModel;
virDrvDomainGetXMLDesc domainGetXMLDesc;
virDrvConnectDomainXMLFromNative domainXMLFromNative;
virDrvConnectDomainXMLToNative domainXMLToNative;
virDrvConnectListDefinedDomains listDefinedDomains;
virDrvConnectNumOfDefinedDomains numOfDefinedDomains;
virDrvConnectDomainXMLFromNative connectDomainXMLFromNative;
virDrvConnectDomainXMLToNative connectDomainXMLToNative;
virDrvConnectListDefinedDomains connectListDefinedDomains;
virDrvConnectNumOfDefinedDomains connectNumOfDefinedDomains;
virDrvDomainCreate domainCreate;
virDrvDomainCreateWithFlags domainCreateWithFlags;
virDrvDomainDefineXML domainDefineXML;
@ -1059,21 +1059,21 @@ struct _virDriver {
virDrvNodeGetMemoryStats nodeGetMemoryStats;
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
virDrvNodeGetFreeMemory nodeGetFreeMemory;
virDrvConnectDomainEventRegister domainEventRegister;
virDrvConnectDomainEventDeregister domainEventDeregister;
virDrvConnectDomainEventRegister connectDomainEventRegister;
virDrvConnectDomainEventDeregister connectDomainEventDeregister;
virDrvDomainMigratePrepare2 domainMigratePrepare2;
virDrvDomainMigrateFinish2 domainMigrateFinish2;
virDrvNodeDeviceDettach nodeDeviceDettach;
virDrvNodeDeviceReAttach nodeDeviceReAttach;
virDrvNodeDeviceReset nodeDeviceReset;
virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
virDrvConnectIsEncrypted isEncrypted;
virDrvConnectIsSecure isSecure;
virDrvConnectIsEncrypted connectIsEncrypted;
virDrvConnectIsSecure connectIsSecure;
virDrvDomainIsActive domainIsActive;
virDrvDomainIsPersistent domainIsPersistent;
virDrvDomainIsUpdated domainIsUpdated;
virDrvConnectCompareCPU cpuCompare;
virDrvConnectBaselineCPU cpuBaseline;
virDrvConnectCompareCPU connectCompareCPU;
virDrvConnectBaselineCPU connectBaselineCPU;
virDrvDomainGetJobInfo domainGetJobInfo;
virDrvDomainGetJobStats domainGetJobStats;
virDrvDomainAbortJob domainAbortJob;
@ -1082,8 +1082,8 @@ struct _virDriver {
virDrvDomainMigrateSetCompressionCache domainMigrateSetCompressionCache;
virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed;
virDrvDomainMigrateSetMaxSpeed domainMigrateSetMaxSpeed;
virDrvConnectDomainEventRegisterAny domainEventRegisterAny;
virDrvConnectDomainEventDeregisterAny domainEventDeregisterAny;
virDrvConnectDomainEventRegisterAny connectDomainEventRegisterAny;
virDrvConnectDomainEventDeregisterAny connectDomainEventDeregisterAny;
virDrvDomainManagedSave domainManagedSave;
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
@ -1103,9 +1103,9 @@ struct _virDriver {
virDrvDomainSnapshotHasMetadata domainSnapshotHasMetadata;
virDrvDomainRevertToSnapshot domainRevertToSnapshot;
virDrvDomainSnapshotDelete domainSnapshotDelete;
virDrvDomainQemuMonitorCommand qemuDomainMonitorCommand;
virDrvDomainQemuAttach qemuDomainAttach;
virDrvDomainQemuAgentCommand qemuDomainArbitraryAgentCommand;
virDrvDomainQemuMonitorCommand domainQemuMonitorCommand;
virDrvDomainQemuAttach domainQemuAttach;
virDrvDomainQemuAgentCommand domainQemuAgentCommand;
virDrvDomainOpenConsole domainOpenConsole;
virDrvDomainOpenChannel domainOpenChannel;
virDrvDomainOpenGraphics domainOpenGraphics;
@ -1123,8 +1123,8 @@ struct _virDriver {
virDrvDomainBlockPull domainBlockPull;
virDrvDomainBlockRebase domainBlockRebase;
virDrvDomainBlockCommit domainBlockCommit;
virDrvConnectSetKeepAlive setKeepAlive;
virDrvConnectIsAlive isAlive;
virDrvConnectSetKeepAlive connectSetKeepAlive;
virDrvConnectIsAlive connectIsAlive;
virDrvNodeSuspendForDuration nodeSuspendForDuration;
virDrvDomainSetBlockIoTune domainSetBlockIoTune;
virDrvDomainGetBlockIoTune domainGetBlockIoTune;
@ -1215,13 +1215,13 @@ typedef virNetworkDriver *virNetworkDriverPtr;
*/
struct _virNetworkDriver {
const char * name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectNumOfNetworks numOfNetworks;
virDrvConnectListNetworks listNetworks;
virDrvConnectNumOfDefinedNetworks numOfDefinedNetworks;
virDrvConnectListDefinedNetworks listDefinedNetworks;
virDrvConnectListAllNetworks listAllNetworks;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectNumOfNetworks connectNumOfNetworks;
virDrvConnectListNetworks connectListNetworks;
virDrvConnectNumOfDefinedNetworks connectNumOfDefinedNetworks;
virDrvConnectListDefinedNetworks connectListDefinedNetworks;
virDrvConnectListAllNetworks connectListAllNetworks;
virDrvNetworkLookupByUUID networkLookupByUUID;
virDrvNetworkLookupByName networkLookupByName;
virDrvNetworkCreateXML networkCreateXML;
@ -1307,13 +1307,13 @@ typedef virInterfaceDriver *virInterfaceDriverPtr;
*/
struct _virInterfaceDriver {
const char *name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectNumOfInterfaces numOfInterfaces;
virDrvConnectListInterfaces listInterfaces;
virDrvConnectNumOfDefinedInterfaces numOfDefinedInterfaces;
virDrvConnectListDefinedInterfaces listDefinedInterfaces;
virDrvConnectListAllInterfaces listAllInterfaces;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectNumOfInterfaces connectNumOfInterfaces;
virDrvConnectListInterfaces connectListInterfaces;
virDrvConnectNumOfDefinedInterfaces connectNumOfDefinedInterfaces;
virDrvConnectListDefinedInterfaces connectListDefinedInterfaces;
virDrvConnectListAllInterfaces connectListAllInterfaces;
virDrvInterfaceLookupByName interfaceLookupByName;
virDrvInterfaceLookupByMACString interfaceLookupByMACString;
virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
@ -1484,50 +1484,50 @@ typedef virStorageDriver *virStorageDriverPtr;
*/
struct _virStorageDriver {
const char * name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectNumOfStoragePools numOfPools;
virDrvConnectListStoragePools listPools;
virDrvConnectNumOfDefinedStoragePools numOfDefinedPools;
virDrvConnectListDefinedStoragePools listDefinedPools;
virDrvConnectListAllStoragePools listAllPools;
virDrvConnectFindStoragePoolSources findPoolSources;
virDrvStoragePoolLookupByName poolLookupByName;
virDrvStoragePoolLookupByUUID poolLookupByUUID;
virDrvStoragePoolLookupByVolume poolLookupByVolume;
virDrvStoragePoolCreateXML poolCreateXML;
virDrvStoragePoolDefineXML poolDefineXML;
virDrvStoragePoolBuild poolBuild;
virDrvStoragePoolUndefine poolUndefine;
virDrvStoragePoolCreate poolCreate;
virDrvStoragePoolDestroy poolDestroy;
virDrvStoragePoolDelete poolDelete;
virDrvStoragePoolRefresh poolRefresh;
virDrvStoragePoolGetInfo poolGetInfo;
virDrvStoragePoolGetXMLDesc poolGetXMLDesc;
virDrvStoragePoolGetAutostart poolGetAutostart;
virDrvStoragePoolSetAutostart poolSetAutostart;
virDrvStoragePoolNumOfVolumes poolNumOfVolumes;
virDrvStoragePoolListVolumes poolListVolumes;
virDrvStoragePoolListAllVolumes poolListAllVolumes;
virDrvConnectNumOfStoragePools connectNumOfStoragePools;
virDrvConnectListStoragePools connectListStoragePools;
virDrvConnectNumOfDefinedStoragePools connectNumOfDefinedStoragePools;
virDrvConnectListDefinedStoragePools connectListDefinedStoragePools;
virDrvConnectListAllStoragePools connectListAllStoragePools;
virDrvConnectFindStoragePoolSources connectFindStoragePoolSources;
virDrvStoragePoolLookupByName storagePoolLookupByName;
virDrvStoragePoolLookupByUUID storagePoolLookupByUUID;
virDrvStoragePoolLookupByVolume storagePoolLookupByVolume;
virDrvStoragePoolCreateXML storagePoolCreateXML;
virDrvStoragePoolDefineXML storagePoolDefineXML;
virDrvStoragePoolBuild storagePoolBuild;
virDrvStoragePoolUndefine storagePoolUndefine;
virDrvStoragePoolCreate storagePoolCreate;
virDrvStoragePoolDestroy storagePoolDestroy;
virDrvStoragePoolDelete storagePoolDelete;
virDrvStoragePoolRefresh storagePoolRefresh;
virDrvStoragePoolGetInfo storagePoolGetInfo;
virDrvStoragePoolGetXMLDesc storagePoolGetXMLDesc;
virDrvStoragePoolGetAutostart storagePoolGetAutostart;
virDrvStoragePoolSetAutostart storagePoolSetAutostart;
virDrvStoragePoolNumOfVolumes storagePoolNumOfVolumes;
virDrvStoragePoolListVolumes storagePoolListVolumes;
virDrvStoragePoolListAllVolumes storagePoolListAllVolumes;
virDrvStorageVolLookupByName volLookupByName;
virDrvStorageVolLookupByKey volLookupByKey;
virDrvStorageVolLookupByPath volLookupByPath;
virDrvStorageVolCreateXML volCreateXML;
virDrvStorageVolCreateXMLFrom volCreateXMLFrom;
virDrvStorageVolDownload volDownload;
virDrvStorageVolUpload volUpload;
virDrvStorageVolDelete volDelete;
virDrvStorageVolWipe volWipe;
virDrvStorageVolWipePattern volWipePattern;
virDrvStorageVolGetInfo volGetInfo;
virDrvStorageVolGetXMLDesc volGetXMLDesc;
virDrvStorageVolGetPath volGetPath;
virDrvStorageVolResize volResize;
virDrvStoragePoolIsActive poolIsActive;
virDrvStoragePoolIsPersistent poolIsPersistent;
virDrvStorageVolLookupByName storageVolLookupByName;
virDrvStorageVolLookupByKey storageVolLookupByKey;
virDrvStorageVolLookupByPath storageVolLookupByPath;
virDrvStorageVolCreateXML storageVolCreateXML;
virDrvStorageVolCreateXMLFrom storageVolCreateXMLFrom;
virDrvStorageVolDownload storageVolDownload;
virDrvStorageVolUpload storageVolUpload;
virDrvStorageVolDelete storageVolDelete;
virDrvStorageVolWipe storageVolWipe;
virDrvStorageVolWipePattern storageVolWipePattern;
virDrvStorageVolGetInfo storageVolGetInfo;
virDrvStorageVolGetXMLDesc storageVolGetXMLDesc;
virDrvStorageVolGetPath storageVolGetPath;
virDrvStorageVolResize storageVolResize;
virDrvStoragePoolIsActive storagePoolIsActive;
virDrvStoragePoolIsPersistent storagePoolIsPersistent;
};
# ifdef WITH_LIBVIRTD
@ -1544,10 +1544,10 @@ typedef virStateDriver *virStateDriverPtr;
struct _virStateDriver {
const char *name;
virDrvStateInitialize initialize;
virDrvStateCleanup cleanup;
virDrvStateReload reload;
virDrvStateStop stop;
virDrvStateInitialize stateInitialize;
virDrvStateCleanup stateCleanup;
virDrvStateReload stateReload;
virDrvStateStop stateStop;
};
# endif
@ -1601,19 +1601,19 @@ typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
*/
struct _virDeviceMonitor {
const char * name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvNodeNumOfDevices numOfDevices;
virDrvNodeListDevices listDevices;
virDrvConnectListAllNodeDevices listAllNodeDevices;
virDrvNodeDeviceLookupByName deviceLookupByName;
virDrvNodeDeviceLookupSCSIHostByWWN deviceLookupSCSIHostByWWN;
virDrvNodeDeviceGetXMLDesc deviceGetXMLDesc;
virDrvNodeDeviceGetParent deviceGetParent;
virDrvNodeDeviceNumOfCaps deviceNumOfCaps;
virDrvNodeDeviceListCaps deviceListCaps;
virDrvNodeDeviceCreateXML deviceCreateXML;
virDrvNodeDeviceDestroy deviceDestroy;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvNodeNumOfDevices nodeNumOfDevices;
virDrvNodeListDevices nodeListDevices;
virDrvConnectListAllNodeDevices connectListAllNodeDevices;
virDrvNodeDeviceLookupByName nodeDeviceLookupByName;
virDrvNodeDeviceLookupSCSIHostByWWN nodeDeviceLookupSCSIHostByWWN;
virDrvNodeDeviceGetXMLDesc nodeDeviceGetXMLDesc;
virDrvNodeDeviceGetParent nodeDeviceGetParent;
virDrvNodeDeviceNumOfCaps nodeDeviceNumOfCaps;
virDrvNodeDeviceListCaps nodeDeviceListCaps;
virDrvNodeDeviceCreateXML nodeDeviceCreateXML;
virDrvNodeDeviceDestroy nodeDeviceDestroy;
};
enum {
@ -1674,19 +1674,19 @@ typedef virSecretDriver *virSecretDriverPtr;
*/
struct _virSecretDriver {
const char *name;
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectNumOfSecrets numOfSecrets;
virDrvConnectListSecrets listSecrets;
virDrvConnectListAllSecrets listAllSecrets;
virDrvSecretLookupByUUID lookupByUUID;
virDrvSecretLookupByUsage lookupByUsage;
virDrvSecretDefineXML defineXML;
virDrvSecretGetXMLDesc getXMLDesc;
virDrvSecretSetValue setValue;
virDrvSecretGetValue getValue;
virDrvSecretUndefine undefine;
virDrvConnectNumOfSecrets connectNumOfSecrets;
virDrvConnectListSecrets connectListSecrets;
virDrvConnectListAllSecrets connectListAllSecrets;
virDrvSecretLookupByUUID secretLookupByUUID;
virDrvSecretLookupByUsage secretLookupByUsage;
virDrvSecretDefineXML secretDefineXML;
virDrvSecretGetXMLDesc secretGetXMLDesc;
virDrvSecretSetValue secretSetValue;
virDrvSecretGetValue secretGetValue;
virDrvSecretUndefine secretUndefine;
};
@ -1716,9 +1716,9 @@ typedef int (*virDrvStreamAbort)(virStreamPtr st);
struct _virStreamDriver {
virDrvStreamSend streamSend;
virDrvStreamRecv streamRecv;
virDrvStreamEventAddCallback streamAddCallback;
virDrvStreamEventUpdateCallback streamUpdateCallback;
virDrvStreamEventRemoveCallback streamRemoveCallback;
virDrvStreamEventAddCallback streamEventAddCallback;
virDrvStreamEventUpdateCallback streamEventUpdateCallback;
virDrvStreamEventRemoveCallback streamEventRemoveCallback;
virDrvStreamFinish streamFinish;
virDrvStreamAbort streamAbort;
};
@ -1766,17 +1766,17 @@ typedef virNWFilterDriver *virNWFilterDriverPtr;
*/
struct _virNWFilterDriver {
const char * name; /* the name of the driver */
virDrvConnectOpen open;
virDrvConnectClose close;
virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose;
virDrvConnectNumOfNWFilters numOfNWFilters;
virDrvConnectListNWFilters listNWFilters;
virDrvConnectListAllNWFilters listAllNWFilters;
virDrvConnectNumOfNWFilters connectNumOfNWFilters;
virDrvConnectListNWFilters connectListNWFilters;
virDrvConnectListAllNWFilters connectListAllNWFilters;
virDrvNWFilterLookupByName nwfilterLookupByName;
virDrvNWFilterLookupByUUID nwfilterLookupByUUID;
virDrvNWFilterDefineXML defineXML;
virDrvNWFilterUndefine undefine;
virDrvNWFilterGetXMLDesc getXMLDesc;
virDrvNWFilterDefineXML nwfilterDefineXML;
virDrvNWFilterUndefine nwfilterUndefine;
virDrvNWFilterGetXMLDesc nwfilterGetXMLDesc;
};

4
src/esx/esx_device_monitor.c
View File

@ -69,8 +69,8 @@ esxDeviceClose(virConnectPtr conn)
static virDeviceMonitor esxDeviceMonitor = {
.name = "ESX",
.open = esxDeviceOpen, /* 0.7.6 */
.close = esxDeviceClose, /* 0.7.6 */
.connectOpen = esxDeviceOpen, /* 0.7.6 */
.connectClose = esxDeviceClose, /* 0.7.6 */
};

34
src/esx/esx_driver.c
View File

@ -5236,17 +5236,17 @@ no_memory:
static virDriver esxDriver = {
.no = VIR_DRV_ESX,
.name = "ESX",
.open = esxOpen, /* 0.7.0 */
.close = esxClose, /* 0.7.0 */
.supports_feature = esxSupportsFeature, /* 0.7.0 */
.type = esxGetType, /* 0.7.0 */
.version = esxGetVersion, /* 0.7.0 */
.getHostname = esxGetHostname, /* 0.7.0 */
.connectOpen = esxOpen, /* 0.7.0 */
.connectClose = esxClose, /* 0.7.0 */
.connectSupportsFeature = esxSupportsFeature, /* 0.7.0 */
.connectGetType = esxGetType, /* 0.7.0 */
.connectGetVersion = esxGetVersion, /* 0.7.0 */
.connectGetHostname = esxGetHostname, /* 0.7.0 */
.nodeGetInfo = esxNodeGetInfo, /* 0.7.0 */
.getCapabilities = esxGetCapabilities, /* 0.7.1 */
.listDomains = esxListDomains, /* 0.7.0 */
.numOfDomains = esxNumberOfDomains, /* 0.7.0 */
.listAllDomains = esxListAllDomains, /* 0.10.2 */
.connectGetCapabilities = esxGetCapabilities, /* 0.7.1 */
.connectListDomains = esxListDomains, /* 0.7.0 */
.connectNumOfDomains = esxNumberOfDomains, /* 0.7.0 */
.connectListAllDomains = esxListAllDomains, /* 0.10.2 */
.domainLookupByID = esxDomainLookupByID, /* 0.7.0 */
.domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */
.domainLookupByName = esxDomainLookupByName, /* 0.7.0 */
@ -5270,10 +5270,10 @@ static virDriver esxDriver = {
.domainGetVcpusFlags = esxDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = esxDomainGetMaxVcpus, /* 0.7.0 */
.domainGetXMLDesc = esxDomainGetXMLDesc, /* 0.7.0 */
.domainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
.domainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
.listDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
.numOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
.connectDomainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
.connectDomainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
.connectListDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
.connectNumOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
.domainCreate = esxDomainCreate, /* 0.7.0 */
.domainCreateWithFlags = esxDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = esxDomainDefineXML, /* 0.7.2 */
@ -5290,8 +5290,8 @@ static virDriver esxDriver = {
.domainMigratePerform = esxDomainMigratePerform, /* 0.7.0 */
.domainMigrateFinish = esxDomainMigrateFinish, /* 0.7.0 */
.nodeGetFreeMemory = esxNodeGetFreeMemory, /* 0.7.2 */
.isEncrypted = esxIsEncrypted, /* 0.7.3 */
.isSecure = esxIsSecure, /* 0.7.3 */
.connectIsEncrypted = esxIsEncrypted, /* 0.7.3 */
.connectIsSecure = esxIsSecure, /* 0.7.3 */
.domainIsActive = esxDomainIsActive, /* 0.7.3 */
.domainIsPersistent = esxDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = esxDomainIsUpdated, /* 0.8.6 */
@ -5309,7 +5309,7 @@ static virDriver esxDriver = {
.domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */
.domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */
.domainSnapshotDelete = esxDomainSnapshotDelete, /* 0.8.0 */
.isAlive = esxIsAlive, /* 0.9.8 */
.connectIsAlive = esxIsAlive, /* 0.9.8 */
};

12
src/esx/esx_interface_driver.c
View File

@ -298,12 +298,12 @@ esxInterfaceIsActive(virInterfacePtr iface ATTRIBUTE_UNUSED)
static virInterfaceDriver esxInterfaceDriver = {
.name = "ESX",
.open = esxInterfaceOpen, /* 0.7.6 */
.close = esxInterfaceClose, /* 0.7.6 */
.numOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
.listInterfaces = esxListInterfaces, /* 0.10.0 */
.numOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
.listDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
.connectOpen = esxInterfaceOpen, /* 0.7.6 */
.connectClose = esxInterfaceClose, /* 0.7.6 */
.connectNumOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
.connectListInterfaces = esxListInterfaces, /* 0.10.0 */
.connectNumOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
.connectListDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
.interfaceLookupByName = esxInterfaceLookupByName, /* 0.10.0 */
.interfaceLookupByMACString = esxInterfaceLookupByMACString, /* 0.10.0 */
.interfaceGetXMLDesc = esxInterfaceGetXMLDesc, /* 0.10.0 */

12
src/esx/esx_network_driver.c
View File

@ -933,12 +933,12 @@ esxNetworkIsPersistent(virNetworkPtr network ATTRIBUTE_UNUSED)
static virNetworkDriver esxNetworkDriver = {
.name = "ESX",
.open = esxNetworkOpen, /* 0.7.6 */
.close = esxNetworkClose, /* 0.7.6 */
.numOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
.listNetworks = esxListNetworks, /* 0.10.0 */
.numOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
.listDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
.connectOpen = esxNetworkOpen, /* 0.7.6 */
.connectClose = esxNetworkClose, /* 0.7.6 */
.connectNumOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
.connectListNetworks = esxListNetworks, /* 0.10.0 */
.connectNumOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
.connectListDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
.networkLookupByUUID = esxNetworkLookupByUUID, /* 0.10.0 */
.networkLookupByName = esxNetworkLookupByName, /* 0.10.0 */
.networkDefineXML = esxNetworkDefineXML, /* 0.10.0 */

4
src/esx/esx_nwfilter_driver.c
View File

@ -69,8 +69,8 @@ esxNWFilterClose(virConnectPtr conn)
static virNWFilterDriver esxNWFilterDriver = {
.name = "ESX",
.open = esxNWFilterOpen, /* 0.8.1 */
.close = esxNWFilterClose, /* 0.8.1 */
.connectOpen = esxNWFilterOpen, /* 0.8.1 */
.connectClose = esxNWFilterClose, /* 0.8.1 */
};

4
src/esx/esx_secret_driver.c
View File

@ -67,8 +67,8 @@ esxSecretClose(virConnectPtr conn)
static virSecretDriver esxSecretDriver = {
.name = "ESX",
.open = esxSecretOpen, /* 0.7.6 */
.close = esxSecretClose, /* 0.7.6 */
.connectOpen = esxSecretOpen, /* 0.7.6 */
.connectClose = esxSecretClose, /* 0.7.6 */
};

36
src/esx/esx_storage_backend_iscsi.c
View File

@ -753,22 +753,22 @@ esxStorageBackendISCSIVolumeGetPath(virStorageVolPtr volume)
virStorageDriver esxStorageBackendISCSI = {
.numOfPools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
.listPools = esxStorageBackendISCSIListPools, /* 1.0.1 */
.poolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
.poolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
.poolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
.poolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
.poolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
.poolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
.poolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
.volLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
.volLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
.volLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
.volCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
.volCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
.volGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
.volDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
.volWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
.volGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
.connectNumOfStoragePools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
.connectListStoragePools = esxStorageBackendISCSIListPools, /* 1.0.1 */
.storagePoolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
.storagePoolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
.storagePoolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
.storagePoolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
.storagePoolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
.storagePoolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
.storagePoolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
.storageVolLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
.storageVolLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
.storageVolLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
.storageVolCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
.storageVolCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
.storageVolGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
.storageVolDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
.storageVolWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
.storageVolGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
};

38
src/esx/esx_storage_backend_vmfs.c
View File

@ -1515,23 +1515,23 @@ esxStorageBackendVMFSVolumeGetPath(virStorageVolPtr volume)
virStorageDriver esxStorageBackendVMFS = {
.numOfPools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
.listPools = esxStorageBackendVMFSListPools, /* 0.8.2 */
.poolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
.poolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
.poolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
.poolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
.poolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
.poolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
.volLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
.volLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
.volLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
.volCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
.volCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
.volDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
.volWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
.volGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
.volGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
.volGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
.connectNumOfStoragePools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
.connectListStoragePools = esxStorageBackendVMFSListPools, /* 0.8.2 */
.storagePoolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
.storagePoolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
.storagePoolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
.storagePoolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
.storagePoolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
.storagePoolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
.storagePoolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
.storageVolLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
.storageVolLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
.storageVolLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
.storageVolCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
.storageVolCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
.storageVolDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
.storageVolWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
.storageVolGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
.storageVolGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
.storageVolGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
};

96
src/esx/esx_storage_driver.c
View File

@ -95,7 +95,7 @@ esxNumberOfStoragePools(virConnectPtr conn)
}
for (i = 0; i < LAST_BACKEND; ++i) {
tmp = backends[i]->numOfPools(conn);
tmp = backends[i]->connectNumOfStoragePools(conn);
if (tmp < 0) {
return -1;
@ -127,7 +127,7 @@ esxListStoragePools(virConnectPtr conn, char **const names, int maxnames)
}
for (i = 0; i < LAST_BACKEND; ++i) {
tmp = backends[i]->listPools(conn, &names[count], maxnames - count);
tmp = backends[i]->connectListStoragePools(conn, &names[count], maxnames - count);
if (tmp < 0) {
goto cleanup;
@ -186,7 +186,7 @@ esxStoragePoolLookupByName(virConnectPtr conn, const char *name)
}
for (i = 0; i < LAST_BACKEND; ++i) {
pool = backends[i]->poolLookupByName(conn, name);
pool = backends[i]->storagePoolLookupByName(conn, name);
if (pool != NULL) {
return pool;
@ -215,7 +215,7 @@ esxStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
/* invoke backend drive method to search all known pools */
for (i = 0; i < LAST_BACKEND; ++i) {
pool = backends[i]->poolLookupByUUID(conn, uuid);
pool = backends[i]->storagePoolLookupByUUID(conn, uuid);
if (pool != NULL) {
return pool;
@ -252,7 +252,7 @@ esxStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
return -1;
}
return backend->poolRefresh(pool, flags);
return backend->storagePoolRefresh(pool, flags);
}
@ -271,7 +271,7 @@ esxStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
return -1;
}
return backend->poolGetInfo(pool, info);
return backend->storagePoolGetInfo(pool, info);
}
@ -288,7 +288,7 @@ esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
return NULL;
}
return backend->poolGetXMLDesc(pool, flags);
return backend->storagePoolGetXMLDesc(pool, flags);
}
@ -335,7 +335,7 @@ esxStoragePoolNumberOfStorageVolumes(virStoragePoolPtr pool)
return -1;
}
return backend->poolNumOfVolumes(pool);
return backend->storagePoolNumOfVolumes(pool);
}
@ -353,7 +353,7 @@ esxStoragePoolListStorageVolumes(virStoragePoolPtr pool, char **const names,
return -1;
}
return backend->poolListVolumes(pool, names, maxnames);
return backend->storagePoolListVolumes(pool, names, maxnames);
}
@ -370,7 +370,7 @@ esxStorageVolumeLookupByName(virStoragePoolPtr pool, const char *name)
return NULL;
}
return backend->volLookupByName(pool, name);
return backend->storageVolLookupByName(pool, name);
}
@ -393,9 +393,9 @@ esxStorageVolumeLookupByPath(virConnectPtr conn, const char *path)
* iSCSI LUNs device path follows normal linux path convention
*/
if (STRPREFIX(path, "[")) {
return backends[VMFS]->volLookupByPath(conn, path);
return backends[VMFS]->storageVolLookupByPath(conn, path);
} else if (STRPREFIX(path, "/")) {
return backends[ISCSI]->volLookupByPath(conn, path);
return backends[ISCSI]->storageVolLookupByPath(conn, path);
} else {
virReportError(VIR_ERR_INVALID_ARG,
_("Unexpected volume path format: %s"), path);
@ -418,7 +418,7 @@ esxStorageVolumeLookupByKey(virConnectPtr conn, const char *key)
}
for (i = 0; i < LAST_BACKEND; ++i) {
volume = backends[i]->volLookupByKey(conn, key);
volume = backends[i]->storageVolLookupByKey(conn, key);
if (volume != NULL) {
return volume;
@ -447,7 +447,7 @@ esxStorageVolumeCreateXML(virStoragePoolPtr pool, const char *xmldesc,
return NULL;
}
return backend->volCreateXML(pool, xmldesc, flags);
return backend->storageVolCreateXML(pool, xmldesc, flags);
}
@ -465,7 +465,7 @@ esxStorageVolumeCreateXMLFrom(virStoragePoolPtr pool, const char *xmldesc,
return NULL;
}
return backend->volCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
return backend->storageVolCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
}
@ -482,7 +482,7 @@ esxStorageVolumeDelete(virStorageVolPtr volume, unsigned int flags)
return -1;
}
return backend->volDelete(volume, flags);
return backend->storageVolDelete(volume, flags);
}
@ -499,7 +499,7 @@ esxStorageVolumeWipe(virStorageVolPtr volume, unsigned int flags)
return -1;
}
return backend->volWipe(volume, flags);
return backend->storageVolWipe(volume, flags);
}
@ -516,7 +516,7 @@ esxStorageVolumeGetInfo(virStorageVolPtr volume, virStorageVolInfoPtr info)
return -1;
}
return backend->volGetInfo(volume, info);
return backend->storageVolGetInfo(volume, info);
}
@ -533,7 +533,7 @@ esxStorageVolumeGetXMLDesc(virStorageVolPtr volume, unsigned int flags)
return NULL;
}
return backend->volGetXMLDesc(volume, flags);
return backend->storageVolGetXMLDesc(volume, flags);
}
@ -550,7 +550,7 @@ esxStorageVolumeGetPath(virStorageVolPtr volume)
return NULL;
}
return backend->volGetPath(volume);
return backend->storageVolGetPath(volume);
}
@ -575,34 +575,34 @@ esxStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
static virStorageDriver esxStorageDriver = {
.name = "ESX",
.open = esxStorageOpen, /* 0.7.6 */
.close = esxStorageClose, /* 0.7.6 */
.numOfPools = esxNumberOfStoragePools, /* 0.8.2 */
.listPools = esxListStoragePools, /* 0.8.2 */
.numOfDefinedPools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
.listDefinedPools = esxListDefinedStoragePools, /* 0.8.2 */
.poolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
.poolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
.poolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
.poolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
.poolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
.poolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
.poolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
.poolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
.poolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
.volLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
.volLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
.volLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
.volCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
.volCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
.volDelete = esxStorageVolumeDelete, /* 0.8.7 */
.volWipe = esxStorageVolumeWipe, /* 0.8.7 */
.volGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
.volGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
.volGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
.poolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
.poolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
.connectOpen = esxStorageOpen, /* 0.7.6 */
.connectClose = esxStorageClose, /* 0.7.6 */
.connectNumOfStoragePools = esxNumberOfStoragePools, /* 0.8.2 */
.connectListStoragePools = esxListStoragePools, /* 0.8.2 */
.connectNumOfDefinedStoragePools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
.connectListDefinedStoragePools = esxListDefinedStoragePools, /* 0.8.2 */
.storagePoolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
.storagePoolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
.storagePoolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
.storagePoolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
.storagePoolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
.storagePoolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
.storagePoolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
.storagePoolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
.storagePoolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
.storagePoolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
.storageVolLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
.storageVolLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
.storageVolLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
.storageVolCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
.storageVolCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
.storageVolDelete = esxStorageVolumeDelete, /* 0.8.7 */
.storageVolWipe = esxStorageVolumeWipe, /* 0.8.7 */
.storageVolGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
.storageVolGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
.storageVolGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
.storagePoolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
.storagePoolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
};

6
src/fdstream.c
View File

@ -455,9 +455,9 @@ static virStreamDriver virFDStreamDrv = {
.streamRecv = virFDStreamRead,
.streamFinish = virFDStreamClose,
.streamAbort = virFDStreamAbort,
.streamAddCallback = virFDStreamAddCallback,
.streamUpdateCallback = virFDStreamUpdateCallback,
.streamRemoveCallback = virFDStreamRemoveCallback
.streamEventAddCallback = virFDStreamAddCallback,
.streamEventUpdateCallback = virFDStreamUpdateCallback,
.streamEventRemoveCallback = virFDStreamRemoveCallback
};
static int virFDStreamOpenInternal(virStreamPtr st,

4
src/hyperv/hyperv_device_monitor.c
View File

@ -66,8 +66,8 @@ hypervDeviceClose(virConnectPtr conn)
static virDeviceMonitor hypervDeviceMonitor = {
"Hyper-V",
.open = hypervDeviceOpen, /* 0.9.5 */
.close = hypervDeviceClose, /* 0.9.5 */
.connectOpen = hypervDeviceOpen, /* 0.9.5 */
.connectClose = hypervDeviceClose, /* 0.9.5 */
};

24
src/hyperv/hyperv_driver.c
View File

@ -1398,14 +1398,14 @@ no_memory:
static virDriver hypervDriver = {
.no = VIR_DRV_HYPERV,
.name = "Hyper-V",
.open = hypervOpen, /* 0.9.5 */
.close = hypervClose, /* 0.9.5 */
.type = hypervGetType, /* 0.9.5 */
.getHostname = hypervGetHostname, /* 0.9.5 */
.connectOpen = hypervOpen, /* 0.9.5 */
.connectClose = hypervClose, /* 0.9.5 */
.connectGetType = hypervGetType, /* 0.9.5 */
.connectGetHostname = hypervGetHostname, /* 0.9.5 */
.nodeGetInfo = hypervNodeGetInfo, /* 0.9.5 */
.listDomains = hypervListDomains, /* 0.9.5 */
.numOfDomains = hypervNumberOfDomains, /* 0.9.5 */
.listAllDomains = hypervListAllDomains, /* 0.10.2 */
.connectListDomains = hypervListDomains, /* 0.9.5 */
.connectNumOfDomains = hypervNumberOfDomains, /* 0.9.5 */
.connectListAllDomains = hypervListAllDomains, /* 0.10.2 */
.domainLookupByID = hypervDomainLookupByID, /* 0.9.5 */
.domainLookupByUUID = hypervDomainLookupByUUID, /* 0.9.5 */
.domainLookupByName = hypervDomainLookupByName, /* 0.9.5 */
@ -1417,19 +1417,19 @@ static virDriver hypervDriver = {
.domainGetInfo = hypervDomainGetInfo, /* 0.9.5 */
.domainGetState = hypervDomainGetState, /* 0.9.5 */
.domainGetXMLDesc = hypervDomainGetXMLDesc, /* 0.9.5 */
.listDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
.numOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
.connectListDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
.connectNumOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
.domainCreate = hypervDomainCreate, /* 0.9.5 */
.domainCreateWithFlags = hypervDomainCreateWithFlags, /* 0.9.5 */
.isEncrypted = hypervIsEncrypted, /* 0.9.5 */
.isSecure = hypervIsSecure, /* 0.9.5 */
.connectIsEncrypted = hypervIsEncrypted, /* 0.9.5 */
.connectIsSecure = hypervIsSecure, /* 0.9.5 */
.domainIsActive = hypervDomainIsActive, /* 0.9.5 */
.domainIsPersistent = hypervDomainIsPersistent, /* 0.9.5 */
.domainIsUpdated = hypervDomainIsUpdated, /* 0.9.5 */
.domainManagedSave = hypervDomainManagedSave, /* 0.9.5 */
.domainHasManagedSaveImage = hypervDomainHasManagedSaveImage, /* 0.9.5 */
.domainManagedSaveRemove = hypervDomainManagedSaveRemove, /* 0.9.5 */
.isAlive = hypervIsAlive, /* 0.9.8 */
.connectIsAlive = hypervIsAlive, /* 0.9.8 */
};

4
src/hyperv/hyperv_interface_driver.c
View File

@ -66,8 +66,8 @@ hypervInterfaceClose(virConnectPtr conn)
static virInterfaceDriver hypervInterfaceDriver = {
.name = "Hyper-V",
.open = hypervInterfaceOpen, /* 0.9.5 */
.close = hypervInterfaceClose, /* 0.9.5 */
.connectOpen = hypervInterfaceOpen, /* 0.9.5 */
.connectClose = hypervInterfaceClose, /* 0.9.5 */
};

4
src/hyperv/hyperv_network_driver.c
View File

@ -66,8 +66,8 @@ hypervNetworkClose(virConnectPtr conn)
static virNetworkDriver hypervNetworkDriver = {
.name = "Hyper-V",
.open = hypervNetworkOpen, /* 0.9.5 */
.close = hypervNetworkClose, /* 0.9.5 */
.connectOpen = hypervNetworkOpen, /* 0.9.5 */
.connectClose = hypervNetworkClose, /* 0.9.5 */
};

4
src/hyperv/hyperv_nwfilter_driver.c
View File

@ -66,8 +66,8 @@ hypervNWFilterClose(virConnectPtr conn)
static virNWFilterDriver hypervNWFilterDriver = {
.name = "Hyper-V",
.open = hypervNWFilterOpen, /* 0.9.5 */
.close = hypervNWFilterClose, /* 0.9.5 */
.connectOpen = hypervNWFilterOpen, /* 0.9.5 */
.connectClose = hypervNWFilterClose, /* 0.9.5 */
};

4
src/hyperv/hyperv_secret_driver.c
View File

@ -66,8 +66,8 @@ hypervSecretClose(virConnectPtr conn)
static virSecretDriver hypervSecretDriver = {
.name = "Hyper-V",
.open = hypervSecretOpen, /* 0.9.5 */
.close = hypervSecretClose, /* 0.9.5 */
.connectOpen = hypervSecretOpen, /* 0.9.5 */
.connectClose = hypervSecretClose, /* 0.9.5 */
};

4
src/hyperv/hyperv_storage_driver.c
View File

@ -66,8 +66,8 @@ hypervStorageClose(virConnectPtr conn)
static virStorageDriver hypervStorageDriver = {
.name = "Hyper-V",
.open = hypervStorageOpen, /* 0.9.5*/
.close = hypervStorageClose, /* 0.9.5 */
.connectOpen = hypervStorageOpen, /* 0.9.5*/
.connectClose = hypervStorageClose, /* 0.9.5 */
};

14
src/interface/interface_backend_netcf.c
View File

@ -784,13 +784,13 @@ static int interfaceChangeRollback(virConnectPtr conn, unsigned int flags)
static virInterfaceDriver interfaceDriver = {
"netcf",
.open = interfaceOpenInterface, /* 0.7.0 */
.close = interfaceCloseInterface, /* 0.7.0 */
.numOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
.listInterfaces = interfaceListInterfaces, /* 0.7.0 */
.numOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
.listDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
.listAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
.connectOpen = interfaceOpenInterface, /* 0.7.0 */
.connectClose = interfaceCloseInterface, /* 0.7.0 */
.connectNumOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
.connectListInterfaces = interfaceListInterfaces, /* 0.7.0 */
.connectNumOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
.connectListDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
.connectListAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
.interfaceLookupByName = interfaceLookupByName, /* 0.7.0 */
.interfaceLookupByMACString = interfaceLookupByMACString, /* 0.7.0 */
.interfaceGetXMLDesc = interfaceGetXMLDesc, /* 0.7.0 */

14
src/interface/interface_backend_udev.c
View File

@ -1149,13 +1149,13 @@ cleanup:
static virInterfaceDriver udevIfaceDriver = {
"udev",
.open = udevIfaceOpenInterface, /* 1.0.0 */
.close = udevIfaceCloseInterface, /* 1.0.0 */
.numOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
.listInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
.numOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
.listDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
.listAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
.connectOpen = udevIfaceOpenInterface, /* 1.0.0 */
.connectClose = udevIfaceCloseInterface, /* 1.0.0 */
.connectNumOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
.connectListInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
.connectNumOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
.connectListDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
.connectListAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
.interfaceLookupByName = udevIfaceLookupByName, /* 1.0.0 */
.interfaceLookupByMACString = udevIfaceLookupByMACString, /* 1.0.0 */
.interfaceIsActive = udevIfaceIsActive, /* 1.0.0 */

14
src/libvirt-qemu.c
View File

@ -95,9 +95,9 @@ virDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd,
goto error;
}
if (conn->driver->qemuDomainMonitorCommand) {
if (conn->driver->domainQemuMonitorCommand) {
int ret;
ret = conn->driver->qemuDomainMonitorCommand(domain, cmd, result,
ret = conn->driver->domainQemuMonitorCommand(domain, cmd, result,
flags);
if (ret < 0)
goto error;
@ -170,9 +170,9 @@ virDomainQemuAttach(virConnectPtr conn,
goto error;
}
if (conn->driver->qemuDomainAttach) {
if (conn->driver->domainQemuAttach) {
virDomainPtr ret;
ret = conn->driver->qemuDomainAttach(conn, pid_value, flags);
ret = conn->driver->domainQemuAttach(conn, pid_value, flags);
if (!ret)
goto error;
return ret;
@ -227,9 +227,9 @@ virDomainQemuAgentCommand(virDomainPtr domain,
conn = domain->conn;
if (conn->driver->qemuDomainArbitraryAgentCommand) {
return conn->driver->qemuDomainArbitraryAgentCommand(domain, cmd,
timeout, flags);
if (conn->driver->domainQemuAgentCommand) {
return conn->driver->domainQemuAgentCommand(domain, cmd,
timeout, flags);
}
virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);

469
src/libvirt.c
View File

File diff suppressed because it is too large Load Diff

2
src/libvirt_internal.h
View File

@ -113,7 +113,7 @@ enum {
};
int virDrvSupportsFeature (virConnectPtr conn, int feature);
int virConnectSupportsFeature(virConnectPtr conn, int feature);
int virDomainMigratePrepare (virConnectPtr dconn,
char **cookie,

2
src/libvirt_private.syms
View File

@ -700,6 +700,7 @@ virFDStreamOpenFile;
# libvirt_internal.h
virConnectSupportsFeature;
virDomainMigrateBegin3;
virDomainMigrateConfirm3;
virDomainMigrateFinish;
@ -712,7 +713,6 @@ virDomainMigratePrepare2;
virDomainMigratePrepare3;
virDomainMigratePrepareTunnel;
virDomainMigratePrepareTunnel3;
virDrvSupportsFeature;
virRegisterDeviceMonitor;
virRegisterDriver;
virRegisterInterfaceDriver;

44
src/libxl/libxl_driver.c
View File

@ -4195,17 +4195,17 @@ libxlListAllDomains(virConnectPtr conn,
static virDriver libxlDriver = {
.no = VIR_DRV_LIBXL,
.name = "xenlight",
.open = libxlOpen, /* 0.9.0 */
.close = libxlClose, /* 0.9.0 */
.type = libxlGetType, /* 0.9.0 */
.version = libxlGetVersion, /* 0.9.0 */
.getHostname = virGetHostname, /* 0.9.0 */
.getMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
.connectOpen = libxlOpen, /* 0.9.0 */
.connectClose = libxlClose, /* 0.9.0 */
.connectGetType = libxlGetType, /* 0.9.0 */
.connectGetVersion = libxlGetVersion, /* 0.9.0 */
.connectGetHostname = virGetHostname, /* 0.9.0 */
.connectGetMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
.nodeGetInfo = libxlNodeGetInfo, /* 0.9.0 */
.getCapabilities = libxlGetCapabilities, /* 0.9.0 */
.listDomains = libxlListDomains, /* 0.9.0 */
.numOfDomains = libxlNumDomains, /* 0.9.0 */
.listAllDomains = libxlListAllDomains, /* 0.9.13 */
.connectGetCapabilities = libxlGetCapabilities, /* 0.9.0 */
.connectListDomains = libxlListDomains, /* 0.9.0 */
.connectNumOfDomains = libxlNumDomains, /* 0.9.0 */
.connectListAllDomains = libxlListAllDomains, /* 0.9.13 */
.domainCreateXML = libxlDomainCreateXML, /* 0.9.0 */
.domainLookupByID = libxlDomainLookupByID, /* 0.9.0 */
.domainLookupByUUID = libxlDomainLookupByUUID, /* 0.9.0 */
@ -4235,10 +4235,10 @@ static virDriver libxlDriver = {
.domainPinVcpu = libxlDomainPinVcpu, /* 0.9.0 */
.domainGetVcpus = libxlDomainGetVcpus, /* 0.9.0 */
.domainGetXMLDesc = libxlDomainGetXMLDesc, /* 0.9.0 */
.domainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
.domainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
.listDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
.numOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
.connectDomainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
.connectDomainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
.connectListDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
.connectNumOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
.domainCreate = libxlDomainCreate, /* 0.9.0 */
.domainCreateWithFlags = libxlDomainCreateWithFlags, /* 0.9.0 */
.domainDefineXML = libxlDomainDefineXML, /* 0.9.0 */
@ -4257,24 +4257,24 @@ static virDriver libxlDriver = {
.domainSetSchedulerParameters = libxlDomainSetSchedulerParameters, /* 0.9.0 */
.domainSetSchedulerParametersFlags = libxlDomainSetSchedulerParametersFlags, /* 0.9.2 */
.nodeGetFreeMemory = libxlNodeGetFreeMemory, /* 0.9.0 */
.domainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
.domainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
.connectDomainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
.connectDomainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
.domainManagedSave = libxlDomainManagedSave, /* 0.9.2 */
.domainHasManagedSaveImage = libxlDomainHasManagedSaveImage, /* 0.9.2 */
.domainManagedSaveRemove = libxlDomainManagedSaveRemove, /* 0.9.2 */
.domainIsActive = libxlDomainIsActive, /* 0.9.0 */
.domainIsPersistent = libxlDomainIsPersistent, /* 0.9.0 */
.domainIsUpdated = libxlDomainIsUpdated, /* 0.9.0 */
.domainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
.domainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
.isAlive = libxlIsAlive, /* 0.9.8 */
.connectDomainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
.connectDomainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
.connectIsAlive = libxlIsAlive, /* 0.9.8 */
};
static virStateDriver libxlStateDriver = {
.name = "LIBXL",
.initialize = libxlStartup,
.cleanup = libxlShutdown,
.reload = libxlReload,
.stateInitialize = libxlStartup,
.stateCleanup = libxlShutdown,
.stateReload = libxlReload,
};

42
src/lxc/lxc_driver.c
View File

@ -4399,16 +4399,16 @@ lxcGetSysinfo(virConnectPtr conn, unsigned int flags)
static virDriver lxcDriver = {
.no = VIR_DRV_LXC,
.name = LXC_DRIVER_NAME,
.open = lxcOpen, /* 0.4.2 */
.close = lxcClose, /* 0.4.2 */
.version = lxcVersion, /* 0.4.6 */
.getHostname = virGetHostname, /* 0.6.3 */
.getSysinfo = lxcGetSysinfo, /* 1.0.5 */
.connectOpen = lxcOpen, /* 0.4.2 */
.connectClose = lxcClose, /* 0.4.2 */
.connectGetVersion = lxcVersion, /* 0.4.6 */
.connectGetHostname = virGetHostname, /* 0.6.3 */
.connectGetSysinfo = lxcGetSysinfo, /* 1.0.5 */
.nodeGetInfo = nodeGetInfo, /* 0.6.5 */
.getCapabilities = lxcGetCapabilities, /* 0.6.5 */
.listDomains = lxcListDomains, /* 0.4.2 */
.numOfDomains = lxcNumDomains, /* 0.4.2 */
.listAllDomains = lxcListAllDomains, /* 0.9.13 */
.connectGetCapabilities = lxcGetCapabilities, /* 0.6.5 */
.connectListDomains = lxcListDomains, /* 0.4.2 */
.connectNumOfDomains = lxcNumDomains, /* 0.4.2 */
.connectListAllDomains = lxcListAllDomains, /* 0.9.13 */
.domainCreateXML = lxcDomainCreateAndStart, /* 0.4.4 */
.domainLookupByID = lxcDomainLookupByID, /* 0.4.2 */
.domainLookupByUUID = lxcDomainLookupByUUID, /* 0.4.2 */
@ -4430,8 +4430,8 @@ static virDriver lxcDriver = {
.domainGetSecurityLabel = lxcDomainGetSecurityLabel, /* 0.9.10 */
.nodeGetSecurityModel = lxcNodeGetSecurityModel, /* 0.9.10 */
.domainGetXMLDesc = lxcDomainGetXMLDesc, /* 0.4.2 */
.listDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
.numOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
.connectListDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
.connectNumOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
.domainCreate = lxcDomainStart, /* 0.4.4 */
.domainCreateWithFlags = lxcDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = lxcDomainDefine, /* 0.4.2 */
@ -4455,17 +4455,17 @@ static virDriver lxcDriver = {
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.6.5 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.6.5 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
.domainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
.domainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
.isEncrypted = lxcIsEncrypted, /* 0.7.3 */
.isSecure = lxcIsSecure, /* 0.7.3 */
.connectDomainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
.connectDomainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
.connectIsEncrypted = lxcIsEncrypted, /* 0.7.3 */
.connectIsSecure = lxcIsSecure, /* 0.7.3 */
.domainIsActive = lxcDomainIsActive, /* 0.7.3 */
.domainIsPersistent = lxcDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = lxcDomainIsUpdated, /* 0.8.6 */
.domainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
.connectDomainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
.domainOpenConsole = lxcDomainOpenConsole, /* 0.8.6 */
.isAlive = lxcIsAlive, /* 0.9.8 */
.connectIsAlive = lxcIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
@ -4478,9 +4478,9 @@ static virDriver lxcDriver = {
static virStateDriver lxcStateDriver = {
.name = LXC_DRIVER_NAME,
.initialize = lxcStartup,
.cleanup = lxcShutdown,
.reload = lxcReload,
.stateInitialize = lxcStartup,
.stateCleanup = lxcShutdown,
.stateReload = lxcReload,
};
int lxcRegister(void)

20
src/network/bridge_driver.c
View File

@ -3592,13 +3592,13 @@ cleanup:
static virNetworkDriver networkDriver = {
"Network",
.open = networkOpenNetwork, /* 0.2.0 */
.close = networkCloseNetwork, /* 0.2.0 */
.numOfNetworks = networkNumNetworks, /* 0.2.0 */
.listNetworks = networkListNetworks, /* 0.2.0 */
.numOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
.listDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
.listAllNetworks = networkListAllNetworks, /* 0.10.2 */
.connectOpen = networkOpenNetwork, /* 0.2.0 */
.connectClose = networkCloseNetwork, /* 0.2.0 */
.connectNumOfNetworks = networkNumNetworks, /* 0.2.0 */
.connectListNetworks = networkListNetworks, /* 0.2.0 */
.connectNumOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
.connectListDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
.connectListAllNetworks = networkListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */
.networkLookupByName = networkLookupByName, /* 0.2.0 */
.networkCreateXML = networkCreate, /* 0.2.0 */
@ -3617,9 +3617,9 @@ static virNetworkDriver networkDriver = {
static virStateDriver networkStateDriver = {
.name = "Network",
.initialize = networkStartup,
.cleanup = networkShutdown,
.reload = networkReload,
.stateInitialize = networkStartup,
.stateCleanup = networkShutdown,
.stateReload = networkReload,
};
int networkRegister(void) {

32
src/node_device/node_device_hal.c
View File

@ -763,27 +763,27 @@ static int halNodeDrvClose(virConnectPtr conn ATTRIBUTE_UNUSED)
static virDeviceMonitor halDeviceMonitor = {
.name = "halDeviceMonitor",
.open = halNodeDrvOpen, /* 0.5.0 */
.close = halNodeDrvClose, /* 0.5.0 */
.numOfDevices = nodeNumOfDevices, /* 0.5.0 */
.listDevices = nodeListDevices, /* 0.5.0 */
.listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.deviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
.deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
.deviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
.deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
.deviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
.deviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
.deviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
.connectOpen = halNodeDrvOpen, /* 0.5.0 */
.connectClose = halNodeDrvClose, /* 0.5.0 */
.nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */
.nodeListDevices = nodeListDevices, /* 0.5.0 */
.connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
.nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
.nodeDeviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
.nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
.nodeDeviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
.nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
.nodeDeviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
};
static virStateDriver halStateDriver = {
.name = "HAL",
.initialize = halDeviceMonitorStartup, /* 0.5.0 */
.cleanup = halDeviceMonitorShutdown, /* 0.5.0 */
.reload = halDeviceMonitorReload, /* 0.5.0 */
.stateInitialize = halDeviceMonitorStartup, /* 0.5.0 */
.stateCleanup = halDeviceMonitorShutdown, /* 0.5.0 */
.stateReload = halDeviceMonitorReload, /* 0.5.0 */
};
int halNodeRegister(void)

32
src/node_device/node_device_udev.c
View File

@ -1793,26 +1793,26 @@ static int udevNodeDrvClose(virConnectPtr conn)
static virDeviceMonitor udevDeviceMonitor = {
.name = "udevDeviceMonitor",
.open = udevNodeDrvOpen, /* 0.7.3 */
.close = udevNodeDrvClose, /* 0.7.3 */
.numOfDevices = nodeNumOfDevices, /* 0.7.3 */
.listDevices = nodeListDevices, /* 0.7.3 */
.listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.deviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
.deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
.deviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
.deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
.deviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
.deviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
.deviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
.connectOpen = udevNodeDrvOpen, /* 0.7.3 */
.connectClose = udevNodeDrvClose, /* 0.7.3 */
.nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
.nodeListDevices = nodeListDevices, /* 0.7.3 */
.connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
.nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
.nodeDeviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
.nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
.nodeDeviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
.nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
.nodeDeviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
};
static virStateDriver udevStateDriver = {
.name = "udev",
.initialize = udevDeviceMonitorStartup, /* 0.7.3 */
.cleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
.reload = udevDeviceMonitorReload, /* 0.7.3 */
.stateInitialize = udevDeviceMonitorStartup, /* 0.7.3 */
.stateCleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
.stateReload = udevDeviceMonitorReload, /* 0.7.3 */
};
int udevNodeRegister(void)

22
src/nwfilter/nwfilter_driver.c
View File

@ -659,24 +659,24 @@ nwfilterTeardownFilter(virDomainNetDefPtr net) {
static virNWFilterDriver nwfilterDriver = {
.name = "nwfilter",
.open = nwfilterOpen, /* 0.8.0 */
.close = nwfilterClose, /* 0.8.0 */
.numOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
.listNWFilters = nwfilterListNWFilters, /* 0.8.0 */
.listAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
.connectOpen = nwfilterOpen, /* 0.8.0 */
.connectClose = nwfilterClose, /* 0.8.0 */
.connectNumOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
.connectListNWFilters = nwfilterListNWFilters, /* 0.8.0 */
.connectListAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
.nwfilterLookupByName = nwfilterLookupByName, /* 0.8.0 */
.nwfilterLookupByUUID = nwfilterLookupByUUID, /* 0.8.0 */
.defineXML = nwfilterDefine, /* 0.8.0 */
.undefine = nwfilterUndefine, /* 0.8.0 */
.getXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
.nwfilterDefineXML = nwfilterDefine, /* 0.8.0 */
.nwfilterUndefine = nwfilterUndefine, /* 0.8.0 */
.nwfilterGetXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
};
static virStateDriver stateDriver = {
.name = "NWFilter",
.initialize = nwfilterDriverStartup,
.cleanup = nwfilterDriverShutdown,
.reload = nwfilterDriverReload,
.stateInitialize = nwfilterDriverStartup,
.stateCleanup = nwfilterDriverShutdown,
.stateReload = nwfilterDriverReload,
};

30
src/openvz/openvz_driver.c
View File

@ -2166,22 +2166,22 @@ openvzListAllDomains(virConnectPtr conn,
static virDriver openvzDriver = {
.no = VIR_DRV_OPENVZ,
.name = "OPENVZ",
.open = openvzOpen, /* 0.3.1 */
.close = openvzClose, /* 0.3.1 */
.type = openvzGetType, /* 0.3.1 */
.version = openvzGetVersion, /* 0.5.0 */
.getHostname = virGetHostname, /* 0.9.12 */
.getMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
.connectOpen = openvzOpen, /* 0.3.1 */
.connectClose = openvzClose, /* 0.3.1 */
.connectGetType = openvzGetType, /* 0.3.1 */
.connectGetVersion = openvzGetVersion, /* 0.5.0 */
.connectGetHostname = virGetHostname, /* 0.9.12 */
.connectGetMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
.nodeGetInfo = nodeGetInfo, /* 0.3.2 */
.nodeGetCPUStats = nodeGetCPUStats, /* 0.9.12 */
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.12 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.9.12 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.9.12 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
.getCapabilities = openvzGetCapabilities, /* 0.4.6 */
.listDomains = openvzListDomains, /* 0.3.1 */
.numOfDomains = openvzNumDomains, /* 0.3.1 */
.listAllDomains = openvzListAllDomains, /* 0.9.13 */
.connectGetCapabilities = openvzGetCapabilities, /* 0.4.6 */
.connectListDomains = openvzListDomains, /* 0.3.1 */
.connectNumOfDomains = openvzNumDomains, /* 0.3.1 */
.connectListAllDomains = openvzListAllDomains, /* 0.9.13 */
.domainCreateXML = openvzDomainCreateXML, /* 0.3.3 */
.domainLookupByID = openvzDomainLookupByID, /* 0.3.1 */
.domainLookupByUUID = openvzDomainLookupByUUID, /* 0.3.1 */
@ -2203,8 +2203,8 @@ static virDriver openvzDriver = {
.domainGetVcpusFlags = openvzDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = openvzDomainGetMaxVcpus, /* 0.4.6 */
.domainGetXMLDesc = openvzDomainGetXMLDesc, /* 0.4.6 */
.listDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
.numOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
.connectListDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
.connectNumOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
.domainCreate = openvzDomainCreate, /* 0.3.1 */
.domainCreateWithFlags = openvzDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = openvzDomainDefineXML, /* 0.3.3 */
@ -2213,12 +2213,12 @@ static virDriver openvzDriver = {
.domainGetAutostart = openvzDomainGetAutostart, /* 0.4.6 */
.domainSetAutostart = openvzDomainSetAutostart, /* 0.4.6 */
.domainInterfaceStats = openvzDomainInterfaceStats, /* 0.9.12 */
.isEncrypted = openvzIsEncrypted, /* 0.7.3 */
.isSecure = openvzIsSecure, /* 0.7.3 */
.connectIsEncrypted = openvzIsEncrypted, /* 0.7.3 */
.connectIsSecure = openvzIsSecure, /* 0.7.3 */
.domainIsActive = openvzDomainIsActive, /* 0.7.3 */
.domainIsPersistent = openvzDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = openvzDomainIsUpdated, /* 0.8.6 */
.isAlive = openvzIsAlive, /* 0.9.8 */
.connectIsAlive = openvzIsAlive, /* 0.9.8 */
.domainUpdateDeviceFlags = openvzDomainUpdateDeviceFlags, /* 0.9.13 */
.domainGetHostname = openvzDomainGetHostname, /* 0.10.0 */
};

20
src/parallels/parallels_driver.c
View File

@ -2390,17 +2390,17 @@ parallelsDomainDefineXML(virConnectPtr conn, const char *xml)
static virDriver parallelsDriver = {
.no = VIR_DRV_PARALLELS,
.name = "Parallels",
.open = parallelsOpen, /* 0.10.0 */
.close = parallelsClose, /* 0.10.0 */
.version = parallelsGetVersion, /* 0.10.0 */
.getHostname = virGetHostname, /* 0.10.0 */
.connectOpen = parallelsOpen, /* 0.10.0 */
.connectClose = parallelsClose, /* 0.10.0 */
.connectGetVersion = parallelsGetVersion, /* 0.10.0 */
.connectGetHostname = virGetHostname, /* 0.10.0 */
.nodeGetInfo = nodeGetInfo, /* 0.10.0 */
.getCapabilities = parallelsGetCapabilities, /* 0.10.0 */
.listDomains = parallelsListDomains, /* 0.10.0 */
.numOfDomains = parallelsNumOfDomains, /* 0.10.0 */
.listDefinedDomains = parallelsListDefinedDomains, /* 0.10.0 */
.numOfDefinedDomains = parallelsNumOfDefinedDomains, /* 0.10.0 */
.listAllDomains = parallelsListAllDomains, /* 0.10.0 */
.connectGetCapabilities = parallelsGetCapabilities, /* 0.10.0 */
.connectListDomains = parallelsListDomains, /* 0.10.0 */
.connectNumOfDomains = parallelsNumOfDomains, /* 0.10.0 */
.connectListDefinedDomains = parallelsListDefinedDomains, /* 0.10.0 */
.connectNumOfDefinedDomains = parallelsNumOfDefinedDomains, /* 0.10.0 */
.connectListAllDomains = parallelsListAllDomains, /* 0.10.0 */
.domainLookupByID = parallelsLookupDomainByID, /* 0.10.0 */
.domainLookupByUUID = parallelsLookupDomainByUUID, /* 0.10.0 */
.domainLookupByName = parallelsLookupDomainByName, /* 0.10.0 */

14
src/parallels/parallels_network.c
View File

@ -614,13 +614,13 @@ cleanup:
}
static virNetworkDriver parallelsNetworkDriver = {
"Parallels",
.open = parallelsOpenNetwork, /* 1.0.1 */
.close = parallelsCloseNetwork, /* 1.0.1 */
.numOfNetworks = parallelsNumNetworks, /* 1.0.1 */
.listNetworks = parallelsListNetworks, /* 1.0.1 */
.numOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
.listDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
.listAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
.connectOpen = parallelsOpenNetwork, /* 1.0.1 */
.connectClose = parallelsCloseNetwork, /* 1.0.1 */
.connectNumOfNetworks = parallelsNumNetworks, /* 1.0.1 */
.connectListNetworks = parallelsListNetworks, /* 1.0.1 */
.connectNumOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
.connectListDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
.connectListAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
.networkLookupByUUID = parallelsNetworkLookupByUUID, /* 1.0.1 */
.networkLookupByName = parallelsNetworkLookupByName, /* 1.0.1 */
.networkGetXMLDesc = parallelsNetworkGetXMLDesc, /* 1.0.1 */

62
src/parallels/parallels_storage.c
View File

@ -1671,39 +1671,39 @@ cleanup:
static virStorageDriver parallelsStorageDriver = {
.name = "Parallels",
.open = parallelsStorageOpen, /* 0.10.0 */
.close = parallelsStorageClose, /* 0.10.0 */
.connectOpen = parallelsStorageOpen, /* 0.10.0 */
.connectClose = parallelsStorageClose, /* 0.10.0 */
.numOfPools = parallelsStorageNumPools, /* 0.10.0 */
.listPools = parallelsStorageListPools, /* 0.10.0 */
.numOfDefinedPools = parallelsStorageNumDefinedPools, /* 0.10.0 */
.listDefinedPools = parallelsStorageListDefinedPools, /* 0.10.0 */
.poolLookupByName = parallelsStoragePoolLookupByName, /* 0.10.0 */
.poolLookupByUUID = parallelsStoragePoolLookupByUUID, /* 0.10.0 */
.poolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
.poolDefineXML = parallelsStoragePoolDefine, /* 0.10.0 */
.poolUndefine = parallelsStoragePoolUndefine, /* 0.10.0 */
.poolCreate = parallelsStoragePoolStart, /* 0.10.0 */
.poolDestroy = parallelsStoragePoolDestroy, /* 0.10.0 */
.poolRefresh = parallelsStoragePoolRefresh, /* 0.10.0 */
.poolGetInfo = parallelsStoragePoolGetInfo, /* 0.10.0 */
.poolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
.poolGetAutostart = parallelsStoragePoolGetAutostart, /* 0.10.0 */
.poolSetAutostart = parallelsStoragePoolSetAutostart, /* 0.10.0 */
.poolNumOfVolumes = parallelsStoragePoolNumVolumes, /* 0.10.0 */
.poolListVolumes = parallelsStoragePoolListVolumes, /* 0.10.0 */
.connectNumOfStoragePools = parallelsStorageNumPools, /* 0.10.0 */
.connectListStoragePools = parallelsStorageListPools, /* 0.10.0 */
.connectNumOfDefinedStoragePools = parallelsStorageNumDefinedPools, /* 0.10.0 */
.connectListDefinedStoragePools = parallelsStorageListDefinedPools, /* 0.10.0 */
.storagePoolLookupByName = parallelsStoragePoolLookupByName, /* 0.10.0 */
.storagePoolLookupByUUID = parallelsStoragePoolLookupByUUID, /* 0.10.0 */
.storagePoolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
.storagePoolDefineXML = parallelsStoragePoolDefine, /* 0.10.0 */
.storagePoolUndefine = parallelsStoragePoolUndefine, /* 0.10.0 */
.storagePoolCreate = parallelsStoragePoolStart, /* 0.10.0 */
.storagePoolDestroy = parallelsStoragePoolDestroy, /* 0.10.0 */
.storagePoolRefresh = parallelsStoragePoolRefresh, /* 0.10.0 */
.storagePoolGetInfo = parallelsStoragePoolGetInfo, /* 0.10.0 */
.storagePoolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
.storagePoolGetAutostart = parallelsStoragePoolGetAutostart, /* 0.10.0 */
.storagePoolSetAutostart = parallelsStoragePoolSetAutostart, /* 0.10.0 */
.storagePoolNumOfVolumes = parallelsStoragePoolNumVolumes, /* 0.10.0 */
.storagePoolListVolumes = parallelsStoragePoolListVolumes, /* 0.10.0 */
.volLookupByName = parallelsStorageVolumeLookupByName, /* 0.10.0 */
.volLookupByKey = parallelsStorageVolumeLookupByKey, /* 0.10.0 */
.volLookupByPath = parallelsStorageVolumeLookupByPath, /* 0.10.0 */
.volCreateXML = parallelsStorageVolumeCreateXML, /* 0.10.0 */
.volCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom, /* 0.10.0 */
.volDelete = parallelsStorageVolumeDelete, /* 0.10.0 */
.volGetInfo = parallelsStorageVolumeGetInfo, /* 0.10.0 */
.volGetXMLDesc = parallelsStorageVolumeGetXMLDesc, /* 0.10.0 */
.volGetPath = parallelsStorageVolumeGetPath, /* 0.10.0 */
.poolIsActive = parallelsStoragePoolIsActive, /* 0.10.0 */
.poolIsPersistent = parallelsStoragePoolIsPersistent, /* 0.10.0 */
.storageVolLookupByName = parallelsStorageVolumeLookupByName, /* 0.10.0 */
.storageVolLookupByKey = parallelsStorageVolumeLookupByKey, /* 0.10.0 */
.storageVolLookupByPath = parallelsStorageVolumeLookupByPath, /* 0.10.0 */
.storageVolCreateXML = parallelsStorageVolumeCreateXML, /* 0.10.0 */
.storageVolCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom, /* 0.10.0 */
.storageVolDelete = parallelsStorageVolumeDelete, /* 0.10.0 */
.storageVolGetInfo = parallelsStorageVolumeGetInfo, /* 0.10.0 */
.storageVolGetXMLDesc = parallelsStorageVolumeGetXMLDesc, /* 0.10.0 */
.storageVolGetPath = parallelsStorageVolumeGetPath, /* 0.10.0 */
.storagePoolIsActive = parallelsStoragePoolIsActive, /* 0.10.0 */
.storagePoolIsPersistent = parallelsStoragePoolIsPersistent, /* 0.10.0 */
};
int

60
src/phyp/phyp_driver.c
View File

@ -3764,11 +3764,11 @@ phypVIOSDriverClose(virConnectPtr conn ATTRIBUTE_UNUSED)
static virDriver phypDriver = {
.no = VIR_DRV_PHYP,
.name = "PHYP",
.open = phypOpen, /* 0.7.0 */
.close = phypClose, /* 0.7.0 */
.getCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
.listDomains = phypListDomains, /* 0.7.0 */
.numOfDomains = phypNumDomains, /* 0.7.0 */
.connectOpen = phypOpen, /* 0.7.0 */
.connectClose = phypClose, /* 0.7.0 */
.connectGetCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
.connectListDomains = phypListDomains, /* 0.7.0 */
.connectNumOfDomains = phypNumDomains, /* 0.7.0 */
.domainCreateXML = phypDomainCreateAndStart, /* 0.7.3 */
.domainLookupByID = phypDomainLookupByID, /* 0.7.0 */
.domainLookupByName = phypDomainLookupByName, /* 0.7.0 */
@ -3784,43 +3784,43 @@ static virDriver phypDriver = {
.domainGetVcpusFlags = phypDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = phypGetLparCPUMAX, /* 0.7.3 */
.domainGetXMLDesc = phypDomainGetXMLDesc, /* 0.7.0 */
.listDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
.numOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
.connectListDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
.connectNumOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
.domainAttachDevice = phypAttachDevice, /* 0.8.2 */
.isEncrypted = phypIsEncrypted, /* 0.7.3 */
.isSecure = phypIsSecure, /* 0.7.3 */
.connectIsEncrypted = phypIsEncrypted, /* 0.7.3 */
.connectIsSecure = phypIsSecure, /* 0.7.3 */
.domainIsUpdated = phypIsUpdated, /* 0.8.6 */
.isAlive = phypIsAlive, /* 0.9.8 */
.connectIsAlive = phypIsAlive, /* 0.9.8 */
};
static virStorageDriver phypStorageDriver = {
.name = "PHYP",
.open = phypVIOSDriverOpen, /* 0.8.2 */
.close = phypVIOSDriverClose, /* 0.8.2 */
.connectOpen = phypVIOSDriverOpen, /* 0.8.2 */
.connectClose = phypVIOSDriverClose, /* 0.8.2 */
.numOfPools = phypNumOfStoragePools, /* 0.8.2 */
.listPools = phypListStoragePools, /* 0.8.2 */
.poolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
.poolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
.poolDestroy = phypDestroyStoragePool, /* 0.8.2 */
.poolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
.poolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
.poolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
.connectNumOfStoragePools = phypNumOfStoragePools, /* 0.8.2 */
.connectListStoragePools = phypListStoragePools, /* 0.8.2 */
.storagePoolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
.storagePoolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
.storagePoolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
.storagePoolDestroy = phypDestroyStoragePool, /* 0.8.2 */
.storagePoolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
.storagePoolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
.storagePoolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
.volLookupByName = phypVolumeLookupByName, /* 0.8.2 */
.volLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
.volCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
.volGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
.volGetPath = phypVolumeGetPath, /* 0.8.2 */
.storageVolLookupByName = phypVolumeLookupByName, /* 0.8.2 */
.storageVolLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
.storageVolCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
.storageVolGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
.storageVolGetPath = phypVolumeGetPath, /* 0.8.2 */
};
static virInterfaceDriver phypInterfaceDriver = {
.name = "PHYP",
.open = phypVIOSDriverOpen, /* 0.9.1 */
.close = phypVIOSDriverClose, /* 0.9.1 */
.numOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
.listInterfaces = phypListInterfaces, /* 0.9.1 */
.connectOpen = phypVIOSDriverOpen, /* 0.9.1 */
.connectClose = phypVIOSDriverClose, /* 0.9.1 */
.connectNumOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
.connectListInterfaces = phypListInterfaces, /* 0.9.1 */
.interfaceLookupByName = phypInterfaceLookupByName, /* 0.9.1 */
.interfaceDefineXML = phypInterfaceDefineXML, /* 0.9.1 */
.interfaceDestroy = phypInterfaceDestroy, /* 0.9.1 */

8
src/qemu/qemu_command.c
View File

@ -2076,8 +2076,8 @@ qemuBuildRBDString(virConnectPtr conn,
if (sec) {
char *base64 = NULL;
secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"),
@ -2522,8 +2522,8 @@ qemuBuildDriveURIString(virConnectPtr conn,
}
if (sec) {
secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"),

64
src/qemu/qemu_driver.c
View File

@ -14626,19 +14626,19 @@ cleanup:
static virDriver qemuDriver = {
.no = VIR_DRV_QEMU,
.name = QEMU_DRIVER_NAME,
.open = qemuOpen, /* 0.2.0 */
.close = qemuClose, /* 0.2.0 */
.supports_feature = qemuSupportsFeature, /* 0.5.0 */
.type = qemuGetType, /* 0.2.0 */
.version = qemuGetVersion, /* 0.2.0 */
.getHostname = virGetHostname, /* 0.3.3 */
.getSysinfo = qemuGetSysinfo, /* 0.8.8 */
.getMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
.connectOpen = qemuOpen, /* 0.2.0 */
.connectClose = qemuClose, /* 0.2.0 */
.connectSupportsFeature = qemuSupportsFeature, /* 0.5.0 */
.connectGetType = qemuGetType, /* 0.2.0 */
.connectGetVersion = qemuGetVersion, /* 0.2.0 */
.connectGetHostname = virGetHostname, /* 0.3.3 */
.connectGetSysinfo = qemuGetSysinfo, /* 0.8.8 */
.connectGetMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
.nodeGetInfo = nodeGetInfo, /* 0.2.0 */
.getCapabilities = qemuGetCapabilities, /* 0.2.1 */
.listDomains = qemuListDomains, /* 0.2.0 */
.numOfDomains = qemuNumDomains, /* 0.2.0 */
.listAllDomains = qemuListAllDomains, /* 0.9.13 */
.connectGetCapabilities = qemuGetCapabilities, /* 0.2.1 */
.connectListDomains = qemuListDomains, /* 0.2.0 */
.connectNumOfDomains = qemuNumDomains, /* 0.2.0 */
.connectListAllDomains = qemuListAllDomains, /* 0.9.13 */
.domainCreateXML = qemuDomainCreate, /* 0.2.0 */
.domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */
.domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */
@ -14685,10 +14685,10 @@ static virDriver qemuDriver = {
.domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */
.nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */
.domainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
.listDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
.numOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
.connectDomainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
.connectDomainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
.connectListDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
.connectNumOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
.domainCreate = qemuDomainStart, /* 0.2.0 */
.domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = qemuDomainDefine, /* 0.2.0 */
@ -14719,21 +14719,21 @@ static virDriver qemuDriver = {
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.4.4 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */
.domainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
.connectDomainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
.connectDomainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
.domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */
.domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */
.nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */
.domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */
.isEncrypted = qemuIsEncrypted, /* 0.7.3 */
.isSecure = qemuIsSecure, /* 0.7.3 */
.connectIsEncrypted = qemuIsEncrypted, /* 0.7.3 */
.connectIsSecure = qemuIsSecure, /* 0.7.3 */
.domainIsActive = qemuDomainIsActive, /* 0.7.3 */
.domainIsPersistent = qemuDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = qemuDomainIsUpdated, /* 0.8.6 */
.cpuCompare = qemuCPUCompare, /* 0.7.5 */
.cpuBaseline = qemuCPUBaseline, /* 0.7.7 */
.connectCompareCPU = qemuCPUCompare, /* 0.7.5 */
.connectBaselineCPU = qemuCPUBaseline, /* 0.7.7 */
.domainGetJobInfo = qemuDomainGetJobInfo, /* 0.7.7 */
.domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */
.domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */
@ -14742,8 +14742,8 @@ static virDriver qemuDriver = {
.domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */
.domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */
.domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */
.domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
.connectDomainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
.domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */
.domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */
.domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */
@ -14763,9 +14763,9 @@ static virDriver qemuDriver = {
.domainSnapshotHasMetadata = qemuDomainSnapshotHasMetadata, /* 0.9.13 */
.domainRevertToSnapshot = qemuDomainRevertToSnapshot, /* 0.8.0 */
.domainSnapshotDelete = qemuDomainSnapshotDelete, /* 0.8.0 */
.qemuDomainMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
.qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
.qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainQemuMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
.domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
.domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainOpenConsole = qemuDomainOpenConsole, /* 0.8.6 */
.domainOpenGraphics = qemuDomainOpenGraphics, /* 0.9.7 */
.domainInjectNMI = qemuDomainInjectNMI, /* 0.9.2 */
@ -14782,7 +14782,7 @@ static virDriver qemuDriver = {
.domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */
.domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */
.domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */
.isAlive = qemuIsAlive, /* 0.9.8 */
.connectIsAlive = qemuIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */
.domainGetBlockIoTune = qemuDomainGetBlockIoTune, /* 0.9.8 */
@ -14806,10 +14806,10 @@ static virDriver qemuDriver = {
static virStateDriver qemuStateDriver = {
.name = "QEMU",
.initialize = qemuStartup,
.cleanup = qemuShutdown,
.reload = qemuReload,
.stop = qemuStop,
.stateInitialize = qemuStartup,
.stateCleanup = qemuShutdown,
.stateReload = qemuReload,
.stateStop = qemuStop,
};
int qemuRegister(void) {

12
src/qemu/qemu_process.c
View File

@ -429,8 +429,8 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
}
if (conn->secretDriver == NULL ||
conn->secretDriver->lookupByUUID == NULL ||
conn->secretDriver->getValue == NULL) {
conn->secretDriver->secretLookupByUUID == NULL ||
conn->secretDriver->secretGetValue == NULL) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("secret storage not supported"));
goto cleanup;
@ -445,12 +445,12 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
goto cleanup;
}
secret = conn->secretDriver->lookupByUUID(conn,
enc->secrets[0]->uuid);
secret = conn->secretDriver->secretLookupByUUID(conn,
enc->secrets[0]->uuid);
if (secret == NULL)
goto cleanup;
data = conn->secretDriver->getValue(secret, &size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
data = conn->secretDriver->secretGetValue(secret, &size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
virObjectUnref(secret);
if (data == NULL)
goto cleanup;

246
src/remote/remote_driver.c
View File

@ -4949,9 +4949,9 @@ static virStreamDriver remoteStreamDrv = {
.streamSend = remoteStreamSend,
.streamFinish = remoteStreamFinish,
.streamAbort = remoteStreamAbort,
.streamAddCallback = remoteStreamEventAddCallback,
.streamUpdateCallback = remoteStreamEventUpdateCallback,
.streamRemoveCallback = remoteStreamEventRemoveCallback,
.streamEventAddCallback = remoteStreamEventAddCallback,
.streamEventUpdateCallback = remoteStreamEventUpdateCallback,
.streamEventRemoveCallback = remoteStreamEventRemoveCallback,
};
@ -6120,20 +6120,20 @@ unsigned long remoteVersion(void)
static virDriver remote_driver = {
.no = VIR_DRV_REMOTE,
.name = "remote",
.open = remoteOpen, /* 0.3.0 */
.close = remoteClose, /* 0.3.0 */
.supports_feature = remoteConnectSupportsFeature, /* 0.3.0 */
.type = remoteConnectGetType, /* 0.3.0 */
.version = remoteConnectGetVersion, /* 0.3.0 */
.libvirtVersion = remoteConnectGetLibVersion, /* 0.7.3 */
.getHostname = remoteConnectGetHostname, /* 0.3.0 */
.getSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
.getMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
.connectOpen = remoteOpen, /* 0.3.0 */
.connectClose = remoteClose, /* 0.3.0 */
.connectSupportsFeature = remoteConnectSupportsFeature, /* 0.3.0 */
.connectGetType = remoteConnectGetType, /* 0.3.0 */
.connectGetVersion = remoteConnectGetVersion, /* 0.3.0 */
.connectGetLibVersion = remoteConnectGetLibVersion, /* 0.7.3 */
.connectGetHostname = remoteConnectGetHostname, /* 0.3.0 */
.connectGetSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
.connectGetMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
.nodeGetInfo = remoteNodeGetInfo, /* 0.3.0 */
.getCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
.listDomains = remoteConnectListDomains, /* 0.3.0 */
.numOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
.listAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
.connectGetCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
.connectListDomains = remoteConnectListDomains, /* 0.3.0 */
.connectNumOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
.connectListAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
.domainCreateXML = remoteDomainCreateXML, /* 0.3.0 */
.domainLookupByID = remoteDomainLookupByID, /* 0.3.0 */
.domainLookupByUUID = remoteDomainLookupByUUID, /* 0.3.0 */
@ -6182,10 +6182,10 @@ static virDriver remote_driver = {
.domainGetSecurityLabelList = remoteDomainGetSecurityLabelList, /* 0.10.0 */
.nodeGetSecurityModel = remoteNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = remoteDomainGetXMLDesc, /* 0.3.0 */
.domainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
.listDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
.numOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
.connectDomainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
.connectDomainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
.connectListDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
.connectNumOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
.domainCreate = remoteDomainCreate, /* 0.3.0 */
.domainCreateWithFlags = remoteDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = remoteDomainDefineXML, /* 0.3.0 */
@ -6220,21 +6220,21 @@ static virDriver remote_driver = {
.nodeGetMemoryStats = remoteNodeGetMemoryStats, /* 0.9.3 */
.nodeGetCellsFreeMemory = remoteNodeGetCellsFreeMemory, /* 0.3.3 */
.nodeGetFreeMemory = remoteNodeGetFreeMemory, /* 0.3.3 */
.domainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
.connectDomainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
.connectDomainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
.domainMigratePrepare2 = remoteDomainMigratePrepare2, /* 0.5.0 */
.domainMigrateFinish2 = remoteDomainMigrateFinish2, /* 0.5.0 */
.nodeDeviceDettach = remoteNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = remoteNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = remoteNodeDeviceReset, /* 0.6.1 */
.domainMigratePrepareTunnel = remoteDomainMigratePrepareTunnel, /* 0.7.2 */
.isEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
.isSecure = remoteConnectIsSecure, /* 0.7.3 */
.connectIsEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
.connectIsSecure = remoteConnectIsSecure, /* 0.7.3 */
.domainIsActive = remoteDomainIsActive, /* 0.7.3 */
.domainIsPersistent = remoteDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = remoteDomainIsUpdated, /* 0.8.6 */
.cpuCompare = remoteConnectCompareCPU, /* 0.7.5 */
.cpuBaseline = remoteConnectBaselineCPU, /* 0.7.7 */
.connectCompareCPU = remoteConnectCompareCPU, /* 0.7.5 */
.connectBaselineCPU = remoteConnectBaselineCPU, /* 0.7.7 */
.domainGetJobInfo = remoteDomainGetJobInfo, /* 0.7.7 */
.domainGetJobStats = remoteDomainGetJobStats, /* 1.0.3 */
.domainAbortJob = remoteDomainAbortJob, /* 0.7.7 */
@ -6243,8 +6243,8 @@ static virDriver remote_driver = {
.domainMigrateSetCompressionCache = remoteDomainMigrateSetCompressionCache, /* 1.0.3 */
.domainMigrateSetMaxSpeed = remoteDomainMigrateSetMaxSpeed, /* 0.9.0 */
.domainMigrateGetMaxSpeed = remoteDomainMigrateGetMaxSpeed, /* 0.9.5 */
.domainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
.connectDomainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
.domainManagedSave = remoteDomainManagedSave, /* 0.8.0 */
.domainHasManagedSaveImage = remoteDomainHasManagedSaveImage, /* 0.8.0 */
.domainManagedSaveRemove = remoteDomainManagedSaveRemove, /* 0.8.0 */
@ -6264,9 +6264,9 @@ static virDriver remote_driver = {
.domainSnapshotIsCurrent = remoteDomainSnapshotIsCurrent, /* 0.9.13 */
.domainSnapshotHasMetadata = remoteDomainSnapshotHasMetadata, /* 0.9.13 */
.domainSnapshotDelete = remoteDomainSnapshotDelete, /* 0.8.0 */
.qemuDomainMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
.qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
.qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainQemuMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
.domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
.domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainOpenConsole = remoteDomainOpenConsole, /* 0.8.6 */
.domainOpenChannel = remoteDomainOpenChannel, /* 1.0.2 */
.domainOpenGraphics = remoteDomainOpenGraphics, /* 0.9.7 */
@ -6285,8 +6285,8 @@ static virDriver remote_driver = {
.domainBlockPull = remoteDomainBlockPull, /* 0.9.4 */
.domainBlockRebase = remoteDomainBlockRebase, /* 0.9.10 */
.domainBlockCommit = remoteDomainBlockCommit, /* 0.10.2 */
.setKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
.isAlive = remoteIsAlive, /* 0.9.8 */
.connectSetKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
.connectIsAlive = remoteIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = remoteNodeSuspendForDuration, /* 0.9.8 */
.domainSetBlockIoTune = remoteDomainSetBlockIoTune, /* 0.9.8 */
.domainGetBlockIoTune = remoteDomainGetBlockIoTune, /* 0.9.8 */
@ -6306,13 +6306,13 @@ static virDriver remote_driver = {
static virNetworkDriver network_driver = {
.name = "remote",
.open = remoteNetworkOpen, /* 0.3.0 */
.close = remoteNetworkClose, /* 0.3.0 */
.numOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
.listNetworks = remoteConnectListNetworks, /* 0.3.0 */
.numOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
.listDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
.listAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
.connectOpen = remoteNetworkOpen, /* 0.3.0 */
.connectClose = remoteNetworkClose, /* 0.3.0 */
.connectNumOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
.connectListNetworks = remoteConnectListNetworks, /* 0.3.0 */
.connectNumOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
.connectListDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
.connectListAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = remoteNetworkLookupByUUID, /* 0.3.0 */
.networkLookupByName = remoteNetworkLookupByName, /* 0.3.0 */
.networkCreateXML = remoteNetworkCreateXML, /* 0.3.0 */
@ -6331,13 +6331,13 @@ static virNetworkDriver network_driver = {
static virInterfaceDriver interface_driver = {
.name = "remote",
.open = remoteInterfaceOpen, /* 0.7.2 */
.close = remoteInterfaceClose, /* 0.7.2 */
.numOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
.listInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
.numOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
.listDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
.listAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
.connectOpen = remoteInterfaceOpen, /* 0.7.2 */
.connectClose = remoteInterfaceClose, /* 0.7.2 */
.connectNumOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
.connectListInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
.connectNumOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
.connectListDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
.connectListAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
.interfaceLookupByName = remoteInterfaceLookupByName, /* 0.7.2 */
.interfaceLookupByMACString = remoteInterfaceLookupByMACString, /* 0.7.2 */
.interfaceGetXMLDesc = remoteInterfaceGetXMLDesc, /* 0.7.2 */
@ -6353,103 +6353,103 @@ static virInterfaceDriver interface_driver = {
static virStorageDriver storage_driver = {
.name = "remote",
.open = remoteStorageOpen, /* 0.4.1 */
.close = remoteStorageClose, /* 0.4.1 */
.numOfPools = remoteConnectNumOfStoragePools, /* 0.4.1 */
.listPools = remoteConnectListStoragePools, /* 0.4.1 */
.numOfDefinedPools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
.listDefinedPools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
.listAllPools = remoteConnectListAllStoragePools, /* 0.10.2 */
.findPoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
.poolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
.poolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
.poolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
.poolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
.poolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
.poolBuild = remoteStoragePoolBuild, /* 0.4.1 */
.poolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
.poolCreate = remoteStoragePoolCreate, /* 0.4.1 */
.poolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
.poolDelete = remoteStoragePoolDelete, /* 0.4.1 */
.poolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
.poolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
.poolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
.poolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
.poolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
.poolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
.poolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
.poolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
.connectOpen = remoteStorageOpen, /* 0.4.1 */
.connectClose = remoteStorageClose, /* 0.4.1 */
.connectNumOfStoragePools = remoteConnectNumOfStoragePools, /* 0.4.1 */
.connectListStoragePools = remoteConnectListStoragePools, /* 0.4.1 */
.connectNumOfDefinedStoragePools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
.connectListDefinedStoragePools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
.connectListAllStoragePools = remoteConnectListAllStoragePools, /* 0.10.2 */
.connectFindStoragePoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
.storagePoolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
.storagePoolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
.storagePoolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
.storagePoolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
.storagePoolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
.storagePoolBuild = remoteStoragePoolBuild, /* 0.4.1 */
.storagePoolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
.storagePoolCreate = remoteStoragePoolCreate, /* 0.4.1 */
.storagePoolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
.storagePoolDelete = remoteStoragePoolDelete, /* 0.4.1 */
.storagePoolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
.storagePoolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
.storagePoolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
.storagePoolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
.storagePoolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
.storagePoolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
.storagePoolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
.storagePoolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
.volLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
.volLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
.volLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
.volCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
.volCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
.volDownload = remoteStorageVolDownload, /* 0.9.0 */
.volUpload = remoteStorageVolUpload, /* 0.9.0 */
.volDelete = remoteStorageVolDelete, /* 0.4.1 */
.volWipe = remoteStorageVolWipe, /* 0.8.0 */
.volWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
.volGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
.volGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
.volGetPath = remoteStorageVolGetPath, /* 0.4.1 */
.volResize = remoteStorageVolResize, /* 0.9.10 */
.poolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
.poolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
.storageVolLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
.storageVolLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
.storageVolLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
.storageVolCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
.storageVolCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
.storageVolDownload = remoteStorageVolDownload, /* 0.9.0 */
.storageVolUpload = remoteStorageVolUpload, /* 0.9.0 */
.storageVolDelete = remoteStorageVolDelete, /* 0.4.1 */
.storageVolWipe = remoteStorageVolWipe, /* 0.8.0 */
.storageVolWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
.storageVolGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
.storageVolGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
.storageVolGetPath = remoteStorageVolGetPath, /* 0.4.1 */
.storageVolResize = remoteStorageVolResize, /* 0.9.10 */
.storagePoolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
.storagePoolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
};
static virSecretDriver secret_driver = {
.name = "remote",
.open = remoteSecretOpen, /* 0.7.1 */
.close = remoteSecretClose, /* 0.7.1 */
.numOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
.listSecrets = remoteConnectListSecrets, /* 0.7.1 */
.listAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
.lookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
.lookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
.defineXML = remoteSecretDefineXML, /* 0.7.1 */
.getXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
.setValue = remoteSecretSetValue, /* 0.7.1 */
.getValue = remoteSecretGetValue, /* 0.7.1 */
.undefine = remoteSecretUndefine /* 0.7.1 */
.connectOpen = remoteSecretOpen, /* 0.7.1 */
.connectClose = remoteSecretClose, /* 0.7.1 */
.connectNumOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
.connectListSecrets = remoteConnectListSecrets, /* 0.7.1 */
.connectListAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
.secretLookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
.secretLookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
.secretDefineXML = remoteSecretDefineXML, /* 0.7.1 */
.secretGetXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
.secretSetValue = remoteSecretSetValue, /* 0.7.1 */
.secretGetValue = remoteSecretGetValue, /* 0.7.1 */
.secretUndefine = remoteSecretUndefine /* 0.7.1 */
};
static virDeviceMonitor dev_monitor = {
.name = "remote",
.open = remoteDevMonOpen, /* 0.5.0 */
.close = remoteDevMonClose, /* 0.5.0 */
.numOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
.listDevices = remoteNodeListDevices, /* 0.5.0 */
.listAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */
.deviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
.deviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.deviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
.deviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
.deviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
.deviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
.deviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
.deviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
.connectOpen = remoteDevMonOpen, /* 0.5.0 */
.connectClose = remoteDevMonClose, /* 0.5.0 */
.nodeNumOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
.nodeListDevices = remoteNodeListDevices, /* 0.5.0 */
.connectListAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */
.nodeDeviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
.nodeDeviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.nodeDeviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
.nodeDeviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
.nodeDeviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
.nodeDeviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
.nodeDeviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
.nodeDeviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
};
static virNWFilterDriver nwfilter_driver = {
.name = "remote",
.open = remoteNWFilterOpen, /* 0.8.0 */
.close = remoteNWFilterClose, /* 0.8.0 */
.connectOpen = remoteNWFilterOpen, /* 0.8.0 */
.connectClose = remoteNWFilterClose, /* 0.8.0 */
.nwfilterLookupByUUID = remoteNWFilterLookupByUUID, /* 0.8.0 */
.nwfilterLookupByName = remoteNWFilterLookupByName, /* 0.8.0 */
.getXMLDesc = remoteNWFilterGetXMLDesc, /* 0.8.0 */
.defineXML = remoteNWFilterDefineXML, /* 0.8.0 */
.undefine = remoteNWFilterUndefine, /* 0.8.0 */
.numOfNWFilters = remoteConnectNumOfNWFilters, /* 0.8.0 */
.listNWFilters = remoteConnectListNWFilters, /* 0.8.0 */
.listAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */
.nwfilterGetXMLDesc = remoteNWFilterGetXMLDesc, /* 0.8.0 */
.nwfilterDefineXML = remoteNWFilterDefineXML, /* 0.8.0 */
.nwfilterUndefine = remoteNWFilterUndefine, /* 0.8.0 */
.connectNumOfNWFilters = remoteConnectNumOfNWFilters, /* 0.8.0 */
.connectListNWFilters = remoteConnectListNWFilters, /* 0.8.0 */
.connectListAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */
};
#ifdef WITH_LIBVIRTD
static virStateDriver state_driver = {
.name = "Remote",
.initialize = remoteStartup,
.stateInitialize = remoteStartup,
};
#endif

30
src/secret/secret_driver.c
View File

@ -1157,25 +1157,25 @@ secretDriverReload(void)
static virSecretDriver secretDriver = {
.name = "secret",
.open = secretOpen, /* 0.7.1 */
.close = secretClose, /* 0.7.1 */
.numOfSecrets = secretNumOfSecrets, /* 0.7.1 */
.listSecrets = secretListSecrets, /* 0.7.1 */
.listAllSecrets = secretListAllSecrets, /* 0.10.2 */
.lookupByUUID = secretLookupByUUID, /* 0.7.1 */
.lookupByUsage = secretLookupByUsage, /* 0.7.1 */
.defineXML = secretDefineXML, /* 0.7.1 */
.getXMLDesc = secretGetXMLDesc, /* 0.7.1 */
.setValue = secretSetValue, /* 0.7.1 */
.getValue = secretGetValue, /* 0.7.1 */
.undefine = secretUndefine, /* 0.7.1 */
.connectOpen = secretOpen, /* 0.7.1 */
.connectClose = secretClose, /* 0.7.1 */
.connectNumOfSecrets = secretNumOfSecrets, /* 0.7.1 */
.connectListSecrets = secretListSecrets, /* 0.7.1 */
.connectListAllSecrets = secretListAllSecrets, /* 0.10.2 */
.secretLookupByUUID = secretLookupByUUID, /* 0.7.1 */
.secretLookupByUsage = secretLookupByUsage, /* 0.7.1 */
.secretDefineXML = secretDefineXML, /* 0.7.1 */
.secretGetXMLDesc = secretGetXMLDesc, /* 0.7.1 */
.secretSetValue = secretSetValue, /* 0.7.1 */
.secretGetValue = secretGetValue, /* 0.7.1 */
.secretUndefine = secretUndefine, /* 0.7.1 */
};
static virStateDriver stateDriver = {
.name = "Secret",
.initialize = secretDriverStartup,
.cleanup = secretDriverCleanup,
.reload = secretDriverReload,
.stateInitialize = secretDriverStartup,
.stateCleanup = secretDriverCleanup,
.stateReload = secretDriverReload,
};
int

16
src/storage/storage_backend.c
View File

@ -432,7 +432,7 @@ virStorageGenerateSecretUUID(virConnectPtr conn,
_("unable to generate uuid"));
return -1;
}
tmp = conn->secretDriver->lookupByUUID(conn, uuid);
tmp = conn->secretDriver->secretLookupByUUID(conn, uuid);
if (tmp == NULL)
return 0;
@ -459,9 +459,9 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
int ret = -1;
if (conn->secretDriver == NULL ||
conn->secretDriver->lookupByUUID == NULL ||
conn->secretDriver->defineXML == NULL ||
conn->secretDriver->setValue == NULL) {
conn->secretDriver->secretLookupByUUID == NULL ||
conn->secretDriver->secretDefineXML == NULL ||
conn->secretDriver->secretSetValue == NULL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("secret storage not supported"));
goto cleanup;
@ -497,7 +497,7 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
if (xml == NULL)
goto cleanup;
secret = conn->secretDriver->defineXML(conn, xml, 0);
secret = conn->secretDriver->secretDefineXML(conn, xml, 0);
if (secret == NULL) {
VIR_FREE(xml);
goto cleanup;
@ -507,7 +507,7 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
if (virStorageGenerateQcowPassphrase(value) < 0)
goto cleanup;
if (conn->secretDriver->setValue(secret, value, sizeof(value), 0) < 0)
if (conn->secretDriver->secretSetValue(secret, value, sizeof(value), 0) < 0)
goto cleanup;
enc_secret->type = VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE;
@ -522,8 +522,8 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
cleanup:
if (secret != NULL) {
if (ret != 0 &&
conn->secretDriver->undefine != NULL)
conn->secretDriver->undefine(secret);
conn->secretDriver->secretUndefine != NULL)
conn->secretDriver->secretUndefine(secret);
virSecretFree(secret);
}
virBufferFreeAndReset(&buf);

90
src/storage/storage_driver.c
View File

@ -2369,58 +2369,58 @@ storageListAllPools(virConnectPtr conn,
static virStorageDriver storageDriver = {
.name = "storage",
.open = storageOpen, /* 0.4.0 */
.close = storageClose, /* 0.4.0 */
.numOfPools = storageNumPools, /* 0.4.0 */
.listPools = storageListPools, /* 0.4.0 */
.numOfDefinedPools = storageNumDefinedPools, /* 0.4.0 */
.listDefinedPools = storageListDefinedPools, /* 0.4.0 */
.listAllPools = storageListAllPools, /* 0.10.2 */
.findPoolSources = storageFindPoolSources, /* 0.4.0 */
.poolLookupByName = storagePoolLookupByName, /* 0.4.0 */
.poolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
.poolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
.poolCreateXML = storagePoolCreate, /* 0.4.0 */
.poolDefineXML = storagePoolDefine, /* 0.4.0 */
.poolBuild = storagePoolBuild, /* 0.4.0 */
.poolUndefine = storagePoolUndefine, /* 0.4.0 */
.poolCreate = storagePoolStart, /* 0.4.0 */
.poolDestroy = storagePoolDestroy, /* 0.4.0 */
.poolDelete = storagePoolDelete, /* 0.4.0 */
.poolRefresh = storagePoolRefresh, /* 0.4.0 */
.poolGetInfo = storagePoolGetInfo, /* 0.4.0 */
.poolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
.poolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
.poolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
.poolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
.poolListVolumes = storagePoolListVolumes, /* 0.4.0 */
.poolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
.connectOpen = storageOpen, /* 0.4.0 */
.connectClose = storageClose, /* 0.4.0 */
.connectNumOfStoragePools = storageNumPools, /* 0.4.0 */
.connectListStoragePools = storageListPools, /* 0.4.0 */
.connectNumOfDefinedStoragePools = storageNumDefinedPools, /* 0.4.0 */
.connectListDefinedStoragePools = storageListDefinedPools, /* 0.4.0 */
.connectListAllStoragePools = storageListAllPools, /* 0.10.2 */
.connectFindStoragePoolSources = storageFindPoolSources, /* 0.4.0 */
.storagePoolLookupByName = storagePoolLookupByName, /* 0.4.0 */
.storagePoolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
.storagePoolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
.storagePoolCreateXML = storagePoolCreate, /* 0.4.0 */
.storagePoolDefineXML = storagePoolDefine, /* 0.4.0 */
.storagePoolBuild = storagePoolBuild, /* 0.4.0 */
.storagePoolUndefine = storagePoolUndefine, /* 0.4.0 */
.storagePoolCreate = storagePoolStart, /* 0.4.0 */
.storagePoolDestroy = storagePoolDestroy, /* 0.4.0 */
.storagePoolDelete = storagePoolDelete, /* 0.4.0 */
.storagePoolRefresh = storagePoolRefresh, /* 0.4.0 */
.storagePoolGetInfo = storagePoolGetInfo, /* 0.4.0 */
.storagePoolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
.storagePoolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
.storagePoolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
.storagePoolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
.storagePoolListVolumes = storagePoolListVolumes, /* 0.4.0 */
.storagePoolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
.volLookupByName = storageVolumeLookupByName, /* 0.4.0 */
.volLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
.volLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
.volCreateXML = storageVolumeCreateXML, /* 0.4.0 */
.volCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
.volDownload = storageVolumeDownload, /* 0.9.0 */
.volUpload = storageVolumeUpload, /* 0.9.0 */
.volDelete = storageVolumeDelete, /* 0.4.0 */
.volWipe = storageVolumeWipe, /* 0.8.0 */
.volWipePattern = storageVolumeWipePattern, /* 0.9.10 */
.volGetInfo = storageVolumeGetInfo, /* 0.4.0 */
.volGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
.volGetPath = storageVolumeGetPath, /* 0.4.0 */
.volResize = storageVolumeResize, /* 0.9.10 */
.storageVolLookupByName = storageVolumeLookupByName, /* 0.4.0 */
.storageVolLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
.storageVolLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
.storageVolCreateXML = storageVolumeCreateXML, /* 0.4.0 */
.storageVolCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
.storageVolDownload = storageVolumeDownload, /* 0.9.0 */
.storageVolUpload = storageVolumeUpload, /* 0.9.0 */
.storageVolDelete = storageVolumeDelete, /* 0.4.0 */
.storageVolWipe = storageVolumeWipe, /* 0.8.0 */
.storageVolWipePattern = storageVolumeWipePattern, /* 0.9.10 */
.storageVolGetInfo = storageVolumeGetInfo, /* 0.4.0 */
.storageVolGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
.storageVolGetPath = storageVolumeGetPath, /* 0.4.0 */
.storageVolResize = storageVolumeResize, /* 0.9.10 */
.poolIsActive = storagePoolIsActive, /* 0.7.3 */
.poolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
.storagePoolIsActive = storagePoolIsActive, /* 0.7.3 */
.storagePoolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
};
static virStateDriver stateDriver = {
.name = "Storage",
.initialize = storageDriverStartup,
.cleanup = storageDriverShutdown,
.reload = storageDriverReload,
.stateInitialize = storageDriverStartup,
.stateCleanup = storageDriverShutdown,
.stateReload = storageDriverReload,
};
int storageRegister(void) {

166
src/test/test_driver.c
View File

@ -5793,16 +5793,16 @@ testDomainScreenshot(virDomainPtr dom ATTRIBUTE_UNUSED,
static virDriver testDriver = {
.no = VIR_DRV_TEST,
.name = "Test",
.open = testOpen, /* 0.1.1 */
.close = testClose, /* 0.1.1 */
.version = testGetVersion, /* 0.1.1 */
.getHostname = virGetHostname, /* 0.6.3 */
.getMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
.connectOpen = testOpen, /* 0.1.1 */
.connectClose = testClose, /* 0.1.1 */
.connectGetVersion = testGetVersion, /* 0.1.1 */
.connectGetHostname = virGetHostname, /* 0.6.3 */
.connectGetMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
.nodeGetInfo = testNodeGetInfo, /* 0.1.1 */
.getCapabilities = testGetCapabilities, /* 0.2.1 */
.listDomains = testListDomains, /* 0.1.1 */
.numOfDomains = testNumOfDomains, /* 0.1.1 */
.listAllDomains = testListAllDomains, /* 0.9.13 */
.connectGetCapabilities = testGetCapabilities, /* 0.2.1 */
.connectListDomains = testListDomains, /* 0.1.1 */
.connectNumOfDomains = testNumOfDomains, /* 0.1.1 */
.connectListAllDomains = testListAllDomains, /* 0.9.13 */
.domainCreateXML = testDomainCreateXML, /* 0.1.4 */
.domainLookupByID = testLookupDomainByID, /* 0.1.1 */
.domainLookupByUUID = testLookupDomainByUUID, /* 0.1.1 */
@ -5831,8 +5831,8 @@ static virDriver testDriver = {
.domainGetVcpus = testDomainGetVcpus, /* 0.7.3 */
.domainGetMaxVcpus = testDomainGetMaxVcpus, /* 0.7.3 */
.domainGetXMLDesc = testDomainGetXMLDesc, /* 0.1.4 */
.listDefinedDomains = testListDefinedDomains, /* 0.1.11 */
.numOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
.connectListDefinedDomains = testListDefinedDomains, /* 0.1.11 */
.connectNumOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
.domainCreate = testDomainCreate, /* 0.1.11 */
.domainCreateWithFlags = testDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = testDomainDefineXML, /* 0.1.11 */
@ -5848,29 +5848,29 @@ static virDriver testDriver = {
.domainBlockStats = testDomainBlockStats, /* 0.7.0 */
.domainInterfaceStats = testDomainInterfaceStats, /* 0.7.0 */
.nodeGetCellsFreeMemory = testNodeGetCellsFreeMemory, /* 0.4.2 */
.domainEventRegister = testDomainEventRegister, /* 0.6.0 */
.domainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
.isEncrypted = testIsEncrypted, /* 0.7.3 */
.isSecure = testIsSecure, /* 0.7.3 */
.connectDomainEventRegister = testDomainEventRegister, /* 0.6.0 */
.connectDomainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
.connectIsEncrypted = testIsEncrypted, /* 0.7.3 */
.connectIsSecure = testIsSecure, /* 0.7.3 */
.domainIsActive = testDomainIsActive, /* 0.7.3 */
.domainIsPersistent = testDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = testDomainIsUpdated, /* 0.8.6 */
.domainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
.isAlive = testIsAlive, /* 0.9.8 */
.connectDomainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
.connectIsAlive = testIsAlive, /* 0.9.8 */
.nodeGetCPUMap = testNodeGetCPUMap, /* 1.0.0 */
.domainScreenshot = testDomainScreenshot, /* 1.0.5 */
};
static virNetworkDriver testNetworkDriver = {
"Test",
.open = testOpenNetwork, /* 0.3.2 */
.close = testCloseNetwork, /* 0.3.2 */
.numOfNetworks = testNumNetworks, /* 0.3.2 */
.listNetworks = testListNetworks, /* 0.3.2 */
.numOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
.listDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
.listAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
.connectOpen = testOpenNetwork, /* 0.3.2 */
.connectClose = testCloseNetwork, /* 0.3.2 */
.connectNumOfNetworks = testNumNetworks, /* 0.3.2 */
.connectListNetworks = testListNetworks, /* 0.3.2 */
.connectNumOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
.connectListDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
.connectListAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = testLookupNetworkByUUID, /* 0.3.2 */
.networkLookupByName = testLookupNetworkByName, /* 0.3.2 */
.networkCreateXML = testNetworkCreate, /* 0.3.2 */
@ -5889,12 +5889,12 @@ static virNetworkDriver testNetworkDriver = {
static virInterfaceDriver testInterfaceDriver = {
"Test", /* name */
.open = testOpenInterface, /* 0.7.0 */
.close = testCloseInterface, /* 0.7.0 */
.numOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
.listInterfaces = testListInterfaces, /* 0.7.0 */
.numOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
.listDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
.connectOpen = testOpenInterface, /* 0.7.0 */
.connectClose = testCloseInterface, /* 0.7.0 */
.connectNumOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
.connectListInterfaces = testListInterfaces, /* 0.7.0 */
.connectNumOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
.connectListDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
.interfaceLookupByName = testLookupInterfaceByName, /* 0.7.0 */
.interfaceLookupByMACString = testLookupInterfaceByMACString, /* 0.7.0 */
.interfaceGetXMLDesc = testInterfaceGetXMLDesc, /* 0.7.0 */
@ -5911,74 +5911,74 @@ static virInterfaceDriver testInterfaceDriver = {
static virStorageDriver testStorageDriver = {
.name = "Test",
.open = testStorageOpen, /* 0.4.1 */
.close = testStorageClose, /* 0.4.1 */
.connectOpen = testStorageOpen, /* 0.4.1 */
.connectClose = testStorageClose, /* 0.4.1 */
.numOfPools = testStorageNumPools, /* 0.5.0 */
.listPools = testStorageListPools, /* 0.5.0 */
.numOfDefinedPools = testStorageNumDefinedPools, /* 0.5.0 */
.listDefinedPools = testStorageListDefinedPools, /* 0.5.0 */
.listAllPools = testStorageListAllPools, /* 0.10.2 */
.findPoolSources = testStorageFindPoolSources, /* 0.5.0 */
.poolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
.poolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
.poolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
.poolCreateXML = testStoragePoolCreate, /* 0.5.0 */
.poolDefineXML = testStoragePoolDefine, /* 0.5.0 */
.poolBuild = testStoragePoolBuild, /* 0.5.0 */
.poolUndefine = testStoragePoolUndefine, /* 0.5.0 */
.poolCreate = testStoragePoolStart, /* 0.5.0 */
.poolDestroy = testStoragePoolDestroy, /* 0.5.0 */
.poolDelete = testStoragePoolDelete, /* 0.5.0 */
.poolRefresh = testStoragePoolRefresh, /* 0.5.0 */
.poolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
.poolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
.poolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
.poolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
.poolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
.poolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
.poolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
.connectNumOfStoragePools = testStorageNumPools, /* 0.5.0 */
.connectListStoragePools = testStorageListPools, /* 0.5.0 */
.connectNumOfDefinedStoragePools = testStorageNumDefinedPools, /* 0.5.0 */
.connectListDefinedStoragePools = testStorageListDefinedPools, /* 0.5.0 */
.connectListAllStoragePools = testStorageListAllPools, /* 0.10.2 */
.connectFindStoragePoolSources = testStorageFindPoolSources, /* 0.5.0 */
.storagePoolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
.storagePoolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
.storagePoolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
.storagePoolCreateXML = testStoragePoolCreate, /* 0.5.0 */
.storagePoolDefineXML = testStoragePoolDefine, /* 0.5.0 */
.storagePoolBuild = testStoragePoolBuild, /* 0.5.0 */
.storagePoolUndefine = testStoragePoolUndefine, /* 0.5.0 */
.storagePoolCreate = testStoragePoolStart, /* 0.5.0 */
.storagePoolDestroy = testStoragePoolDestroy, /* 0.5.0 */
.storagePoolDelete = testStoragePoolDelete, /* 0.5.0 */
.storagePoolRefresh = testStoragePoolRefresh, /* 0.5.0 */
.storagePoolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
.storagePoolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
.storagePoolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
.storagePoolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
.storagePoolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
.storagePoolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
.storagePoolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
.volLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
.volLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
.volLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
.volCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
.volCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
.volDelete = testStorageVolumeDelete, /* 0.5.0 */
.volGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
.volGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
.volGetPath = testStorageVolumeGetPath, /* 0.5.0 */
.poolIsActive = testStoragePoolIsActive, /* 0.7.3 */
.poolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
.storageVolLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
.storageVolLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
.storageVolLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
.storageVolCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
.storageVolCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
.storageVolDelete = testStorageVolumeDelete, /* 0.5.0 */
.storageVolGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
.storageVolGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
.storageVolGetPath = testStorageVolumeGetPath, /* 0.5.0 */
.storagePoolIsActive = testStoragePoolIsActive, /* 0.7.3 */
.storagePoolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
};
static virDeviceMonitor testDevMonitor = {
.name = "Test",
.open = testDevMonOpen, /* 0.6.0 */
.close = testDevMonClose, /* 0.6.0 */
.connectOpen = testDevMonOpen, /* 0.6.0 */
.connectClose = testDevMonClose, /* 0.6.0 */
.numOfDevices = testNodeNumOfDevices, /* 0.7.2 */
.listDevices = testNodeListDevices, /* 0.7.2 */
.deviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
.deviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
.deviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
.deviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
.deviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
.deviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
.deviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
.nodeNumOfDevices = testNodeNumOfDevices, /* 0.7.2 */
.nodeListDevices = testNodeListDevices, /* 0.7.2 */
.nodeDeviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
.nodeDeviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
.nodeDeviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
.nodeDeviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
.nodeDeviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
.nodeDeviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
.nodeDeviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
};
static virSecretDriver testSecretDriver = {
.name = "Test",
.open = testSecretOpen, /* 0.7.1 */
.close = testSecretClose, /* 0.7.1 */
.connectOpen = testSecretOpen, /* 0.7.1 */
.connectClose = testSecretClose, /* 0.7.1 */
};
static virNWFilterDriver testNWFilterDriver = {
.name = "Test",
.open = testNWFilterOpen, /* 0.8.0 */
.close = testNWFilterClose, /* 0.8.0 */
.connectOpen = testNWFilterOpen, /* 0.8.0 */
.connectClose = testNWFilterClose, /* 0.8.0 */
};
/**

42
src/uml/uml_driver.c
View File

@ -2593,16 +2593,16 @@ static int umlListAllDomains(virConnectPtr conn,
static virDriver umlDriver = {
.no = VIR_DRV_UML,
.name = "UML",
.open = umlOpen, /* 0.5.0 */
.close = umlClose, /* 0.5.0 */
.type = umlGetType, /* 0.5.0 */
.version = umlGetVersion, /* 0.5.0 */
.getHostname = virGetHostname, /* 0.5.0 */
.connectOpen = umlOpen, /* 0.5.0 */
.connectClose = umlClose, /* 0.5.0 */
.connectGetType = umlGetType, /* 0.5.0 */
.connectGetVersion = umlGetVersion, /* 0.5.0 */
.connectGetHostname = virGetHostname, /* 0.5.0 */
.nodeGetInfo = nodeGetInfo, /* 0.5.0 */
.getCapabilities = umlGetCapabilities, /* 0.5.0 */
.listDomains = umlListDomains, /* 0.5.0 */
.numOfDomains = umlNumDomains, /* 0.5.0 */
.listAllDomains = umlListAllDomains, /* 0.9.13 */
.connectGetCapabilities = umlGetCapabilities, /* 0.5.0 */
.connectListDomains = umlListDomains, /* 0.5.0 */
.connectNumOfDomains = umlNumDomains, /* 0.5.0 */
.connectListAllDomains = umlListAllDomains, /* 0.9.13 */
.domainCreateXML = umlDomainCreate, /* 0.5.0 */
.domainLookupByID = umlDomainLookupByID, /* 0.5.0 */
.domainLookupByUUID = umlDomainLookupByUUID, /* 0.5.0 */
@ -2618,8 +2618,8 @@ static virDriver umlDriver = {
.domainGetInfo = umlDomainGetInfo, /* 0.5.0 */
.domainGetState = umlDomainGetState, /* 0.9.2 */
.domainGetXMLDesc = umlDomainGetXMLDesc, /* 0.5.0 */
.listDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
.numOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
.connectListDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
.connectNumOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
.domainCreate = umlDomainStart, /* 0.5.0 */
.domainCreateWithFlags = umlDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = umlDomainDefine, /* 0.5.0 */
@ -2637,17 +2637,17 @@ static virDriver umlDriver = {
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.5.0 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.5.0 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
.domainEventRegister = umlDomainEventRegister, /* 0.9.4 */
.domainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
.isEncrypted = umlIsEncrypted, /* 0.7.3 */
.isSecure = umlIsSecure, /* 0.7.3 */
.connectDomainEventRegister = umlDomainEventRegister, /* 0.9.4 */
.connectDomainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
.connectIsEncrypted = umlIsEncrypted, /* 0.7.3 */
.connectIsSecure = umlIsSecure, /* 0.7.3 */
.domainIsActive = umlDomainIsActive, /* 0.7.3 */
.domainIsPersistent = umlDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = umlDomainIsUpdated, /* 0.8.6 */
.domainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
.domainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
.connectDomainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
.connectDomainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
.domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
.isAlive = umlIsAlive, /* 0.9.8 */
.connectIsAlive = umlIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
@ -2655,9 +2655,9 @@ static virDriver umlDriver = {
static virStateDriver umlStateDriver = {
.name = "UML",
.initialize = umlStartup,
.cleanup = umlShutdown,
.reload = umlReload,
.stateInitialize = umlStartup,
.stateCleanup = umlShutdown,
.stateReload = umlReload,
};
int umlRegister(void) {

2
src/vbox/vbox_driver.c
View File

@ -184,5 +184,5 @@ static virDrvOpenStatus vboxOpenDummy(virConnectPtr conn,
static virDriver vboxDriverDummy = {
VIR_DRV_VBOX,
"VBOX",
.open = vboxOpenDummy,
.connectOpen = vboxOpenDummy,
};

94
src/vbox/vbox_tmpl.c
View File

@ -9405,16 +9405,16 @@ no_memory:
virDriver NAME(Driver) = {
.no = VIR_DRV_VBOX,
.name = "VBOX",
.open = vboxOpen, /* 0.6.3 */
.close = vboxClose, /* 0.6.3 */
.version = vboxGetVersion, /* 0.6.3 */
.getHostname = virGetHostname, /* 0.6.3 */
.getMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
.connectOpen = vboxOpen, /* 0.6.3 */
.connectClose = vboxClose, /* 0.6.3 */
.connectGetVersion = vboxGetVersion, /* 0.6.3 */
.connectGetHostname = virGetHostname, /* 0.6.3 */
.connectGetMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
.nodeGetInfo = nodeGetInfo, /* 0.6.3 */
.getCapabilities = vboxGetCapabilities, /* 0.6.3 */
.listDomains = vboxListDomains, /* 0.6.3 */
.numOfDomains = vboxNumOfDomains, /* 0.6.3 */
.listAllDomains = vboxListAllDomains, /* 0.9.13 */
.connectGetCapabilities = vboxGetCapabilities, /* 0.6.3 */
.connectListDomains = vboxListDomains, /* 0.6.3 */
.connectNumOfDomains = vboxNumOfDomains, /* 0.6.3 */
.connectListAllDomains = vboxListAllDomains, /* 0.9.13 */
.domainCreateXML = vboxDomainCreateXML, /* 0.6.3 */
.domainLookupByID = vboxDomainLookupByID, /* 0.6.3 */
.domainLookupByUUID = vboxDomainLookupByUUID, /* 0.6.3 */
@ -9436,8 +9436,8 @@ virDriver NAME(Driver) = {
.domainGetVcpusFlags = vboxDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = vboxDomainGetMaxVcpus, /* 0.7.1 */
.domainGetXMLDesc = vboxDomainGetXMLDesc, /* 0.6.3 */
.listDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
.numOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
.connectListDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
.connectNumOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
.domainCreate = vboxDomainCreate, /* 0.6.3 */
.domainCreateWithFlags = vboxDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = vboxDomainDefineXML, /* 0.6.3 */
@ -9454,17 +9454,17 @@ virDriver NAME(Driver) = {
.domainScreenshot = vboxDomainScreenshot, /* 0.9.2 */
#endif
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
.domainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
.domainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
.connectDomainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
.connectDomainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
#endif
.isEncrypted = vboxIsEncrypted, /* 0.7.3 */
.isSecure = vboxIsSecure, /* 0.7.3 */
.connectIsEncrypted = vboxIsEncrypted, /* 0.7.3 */
.connectIsSecure = vboxIsSecure, /* 0.7.3 */
.domainIsActive = vboxDomainIsActive, /* 0.7.3 */
.domainIsPersistent = vboxDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = vboxDomainIsUpdated, /* 0.8.6 */
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
.domainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
.connectDomainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
#endif
.domainSnapshotCreateXML = vboxDomainSnapshotCreateXML, /* 0.8.0 */
.domainSnapshotGetXMLDesc = vboxDomainSnapshotGetXMLDesc, /* 0.8.0 */
@ -9478,43 +9478,43 @@ virDriver NAME(Driver) = {
.domainSnapshotHasMetadata = vboxDomainSnapshotHasMetadata, /* 0.9.13 */
.domainRevertToSnapshot = vboxDomainRevertToSnapshot, /* 0.8.0 */
.domainSnapshotDelete = vboxDomainSnapshotDelete, /* 0.8.0 */
.isAlive = vboxIsAlive, /* 0.9.8 */
.connectIsAlive = vboxIsAlive, /* 0.9.8 */
};
virNetworkDriver NAME(NetworkDriver) = {
"VBOX",
.open = vboxNetworkOpen, /* 0.6.4 */
.close = vboxNetworkClose, /* 0.6.4 */
.numOfNetworks = vboxNumOfNetworks, /* 0.6.4 */
.listNetworks = vboxListNetworks, /* 0.6.4 */
.numOfDefinedNetworks = vboxNumOfDefinedNetworks, /* 0.6.4 */
.listDefinedNetworks = vboxListDefinedNetworks, /* 0.6.4 */
.networkLookupByUUID = vboxNetworkLookupByUUID, /* 0.6.4 */
.networkLookupByName = vboxNetworkLookupByName, /* 0.6.4 */
.networkCreateXML = vboxNetworkCreateXML, /* 0.6.4 */
.networkDefineXML = vboxNetworkDefineXML, /* 0.6.4 */
.networkUndefine = vboxNetworkUndefine, /* 0.6.4 */
.networkCreate = vboxNetworkCreate, /* 0.6.4 */
.networkDestroy = vboxNetworkDestroy, /* 0.6.4 */
.networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
.connectOpen = vboxNetworkOpen, /* 0.6.4 */
.connectClose = vboxNetworkClose, /* 0.6.4 */
.connectNumOfNetworks = vboxNumOfNetworks, /* 0.6.4 */
.connectListNetworks = vboxListNetworks, /* 0.6.4 */
.connectNumOfDefinedNetworks = vboxNumOfDefinedNetworks, /* 0.6.4 */
.connectListDefinedNetworks = vboxListDefinedNetworks, /* 0.6.4 */
.networkLookupByUUID = vboxNetworkLookupByUUID, /* 0.6.4 */
.networkLookupByName = vboxNetworkLookupByName, /* 0.6.4 */
.networkCreateXML = vboxNetworkCreateXML, /* 0.6.4 */
.networkDefineXML = vboxNetworkDefineXML, /* 0.6.4 */
.networkUndefine = vboxNetworkUndefine, /* 0.6.4 */
.networkCreate = vboxNetworkCreate, /* 0.6.4 */
.networkDestroy = vboxNetworkDestroy, /* 0.6.4 */
.networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
};
virStorageDriver NAME(StorageDriver) = {
.name = "VBOX",
.open = vboxStorageOpen, /* 0.7.1 */
.close = vboxStorageClose, /* 0.7.1 */
.numOfPools = vboxStorageNumOfPools, /* 0.7.1 */
.listPools = vboxStorageListPools, /* 0.7.1 */
.poolLookupByName = vboxStoragePoolLookupByName, /* 0.7.1 */
.poolNumOfVolumes = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
.poolListVolumes = vboxStoragePoolListVolumes, /* 0.7.1 */
.connectOpen = vboxStorageOpen, /* 0.7.1 */
.connectClose = vboxStorageClose, /* 0.7.1 */
.connectNumOfStoragePools = vboxStorageNumOfPools, /* 0.7.1 */
.connectListStoragePools = vboxStorageListPools, /* 0.7.1 */
.storagePoolLookupByName = vboxStoragePoolLookupByName, /* 0.7.1 */
.storagePoolNumOfVolumes = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
.storagePoolListVolumes = vboxStoragePoolListVolumes, /* 0.7.1 */
.volLookupByName = vboxStorageVolLookupByName, /* 0.7.1 */
.volLookupByKey = vboxStorageVolLookupByKey, /* 0.7.1 */
.volLookupByPath = vboxStorageVolLookupByPath, /* 0.7.1 */
.volCreateXML = vboxStorageVolCreateXML, /* 0.7.1 */
.volDelete = vboxStorageVolDelete, /* 0.7.1 */
.volGetInfo = vboxStorageVolGetInfo, /* 0.7.1 */
.volGetXMLDesc = vboxStorageVolGetXMLDesc, /* 0.7.1 */
.volGetPath = vboxStorageVolGetPath /* 0.7.1 */
.storageVolLookupByName = vboxStorageVolLookupByName, /* 0.7.1 */
.storageVolLookupByKey = vboxStorageVolLookupByKey, /* 0.7.1 */
.storageVolLookupByPath = vboxStorageVolLookupByPath, /* 0.7.1 */
.storageVolCreateXML = vboxStorageVolCreateXML, /* 0.7.1 */
.storageVolDelete = vboxStorageVolDelete, /* 0.7.1 */
.storageVolGetInfo = vboxStorageVolGetInfo, /* 0.7.1 */
.storageVolGetXMLDesc = vboxStorageVolGetXMLDesc, /* 0.7.1 */
.storageVolGetPath = vboxStorageVolGetPath /* 0.7.1 */
};

22
src/vmware/vmware_driver.c
View File

@ -1120,13 +1120,13 @@ vmwareListAllDomains(virConnectPtr conn,
static virDriver vmwareDriver = {
.no = VIR_DRV_VMWARE,
.name = "VMWARE",
.open = vmwareOpen, /* 0.8.7 */
.close = vmwareClose, /* 0.8.7 */
.type = vmwareGetType, /* 0.8.7 */
.version = vmwareGetVersion, /* 0.8.7 */
.listDomains = vmwareListDomains, /* 0.8.7 */
.numOfDomains = vmwareNumDomains, /* 0.8.7 */
.listAllDomains = vmwareListAllDomains, /* 0.9.13 */
.connectOpen = vmwareOpen, /* 0.8.7 */
.connectClose = vmwareClose, /* 0.8.7 */
.connectGetType = vmwareGetType, /* 0.8.7 */
.connectGetVersion = vmwareGetVersion, /* 0.8.7 */
.connectListDomains = vmwareListDomains, /* 0.8.7 */
.connectNumOfDomains = vmwareNumDomains, /* 0.8.7 */
.connectListAllDomains = vmwareListAllDomains, /* 0.9.13 */
.domainCreateXML = vmwareDomainCreateXML, /* 0.8.7 */
.domainLookupByID = vmwareDomainLookupByID, /* 0.8.7 */
.domainLookupByUUID = vmwareDomainLookupByUUID, /* 0.8.7 */
@ -1142,9 +1142,9 @@ static virDriver vmwareDriver = {
.domainGetInfo = vmwareDomainGetInfo, /* 0.8.7 */
.domainGetState = vmwareDomainGetState, /* 0.9.2 */
.domainGetXMLDesc = vmwareDomainGetXMLDesc, /* 0.8.7 */
.domainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
.listDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
.numOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
.connectDomainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
.connectListDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
.connectNumOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
.domainCreate = vmwareDomainCreate, /* 0.8.7 */
.domainCreateWithFlags = vmwareDomainCreateWithFlags, /* 0.8.7 */
.domainDefineXML = vmwareDomainDefineXML, /* 0.8.7 */
@ -1152,7 +1152,7 @@ static virDriver vmwareDriver = {
.domainUndefineFlags = vmwareDomainUndefineFlags, /* 0.9.4 */
.domainIsActive = vmwareDomainIsActive, /* 0.8.7 */
.domainIsPersistent = vmwareDomainIsPersistent, /* 0.8.7 */
.isAlive = vmwareIsAlive, /* 0.9.8 */
.connectIsAlive = vmwareIsAlive, /* 0.9.8 */
};
int

44
src/xen/xen_driver.c
View File

@ -213,7 +213,7 @@ xenInitialize(bool privileged ATTRIBUTE_UNUSED,
static virStateDriver state_driver = {
.name = "Xen",
.initialize = xenInitialize,
.stateInitialize = xenInitialize,
};
#endif
@ -2330,17 +2330,17 @@ cleanup:
static virDriver xenUnifiedDriver = {
.no = VIR_DRV_XEN_UNIFIED,
.name = "Xen",
.open = xenUnifiedOpen, /* 0.0.3 */
.close = xenUnifiedClose, /* 0.0.3 */
.supports_feature = xenUnifiedSupportsFeature, /* 0.3.2 */
.type = xenUnifiedType, /* 0.0.3 */
.version = xenUnifiedGetVersion, /* 0.0.3 */
.getHostname = virGetHostname, /* 0.7.3 */
.getMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
.connectOpen = xenUnifiedOpen, /* 0.0.3 */
.connectClose = xenUnifiedClose, /* 0.0.3 */
.connectSupportsFeature = xenUnifiedSupportsFeature, /* 0.3.2 */
.connectGetType = xenUnifiedType, /* 0.0.3 */
.connectGetVersion = xenUnifiedGetVersion, /* 0.0.3 */
.connectGetHostname = virGetHostname, /* 0.7.3 */
.connectGetMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
.nodeGetInfo = xenUnifiedNodeGetInfo, /* 0.1.0 */
.getCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
.listDomains = xenUnifiedListDomains, /* 0.0.3 */
.numOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
.connectGetCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
.connectListDomains = xenUnifiedListDomains, /* 0.0.3 */
.connectNumOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
.domainCreateXML = xenUnifiedDomainCreateXML, /* 0.0.3 */
.domainLookupByID = xenUnifiedDomainLookupByID, /* 0.0.3 */
.domainLookupByUUID = xenUnifiedDomainLookupByUUID, /* 0.0.5 */
@ -2373,10 +2373,10 @@ static virDriver xenUnifiedDriver = {
.domainGetVcpus = xenUnifiedDomainGetVcpus, /* 0.1.4 */
.domainGetMaxVcpus = xenUnifiedDomainGetMaxVcpus, /* 0.2.1 */
.domainGetXMLDesc = xenUnifiedDomainGetXMLDesc, /* 0.0.3 */
.domainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
.listDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
.numOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
.connectDomainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
.connectDomainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
.connectListDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
.connectNumOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
.domainCreate = xenUnifiedDomainCreate, /* 0.1.1 */
.domainCreateWithFlags = xenUnifiedDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenUnifiedDomainDefineXML, /* 0.1.1 */
@ -2402,20 +2402,20 @@ static virDriver xenUnifiedDriver = {
.domainBlockPeek = xenUnifiedDomainBlockPeek, /* 0.4.4 */
.nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, /* 0.3.3 */
.nodeGetFreeMemory = xenUnifiedNodeGetFreeMemory, /* 0.3.3 */
.domainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
.connectDomainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
.connectDomainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
.nodeDeviceDettach = xenUnifiedNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = xenUnifiedNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = xenUnifiedNodeDeviceReset, /* 0.6.1 */
.isEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
.isSecure = xenUnifiedIsSecure, /* 0.7.3 */
.connectIsEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
.connectIsSecure = xenUnifiedIsSecure, /* 0.7.3 */
.domainIsActive = xenUnifiedDomainIsActive, /* 0.7.3 */
.domainIsPersistent = xenUnifiedDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = xenUnifiedDomainIsUpdated, /* 0.8.6 */
.domainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
.connectDomainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
.connectDomainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
.domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */
.isAlive = xenUnifiedIsAlive, /* 0.9.8 */
.connectIsAlive = xenUnifiedIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */

26
src/xenapi/xenapi_driver.c
View File

@ -1934,17 +1934,17 @@ xenapiIsAlive(virConnectPtr conn)
static virDriver xenapiDriver = {
.no = VIR_DRV_XENAPI,
.name = "XenAPI",
.open = xenapiOpen, /* 0.8.0 */
.close = xenapiClose, /* 0.8.0 */
.supports_feature = xenapiSupportsFeature, /* 0.8.0 */
.type = xenapiType, /* 0.8.0 */
.version = xenapiGetVersion, /* 0.8.0 */
.getHostname = xenapiGetHostname, /* 0.8.0 */
.getMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
.connectOpen = xenapiOpen, /* 0.8.0 */
.connectClose = xenapiClose, /* 0.8.0 */
.connectSupportsFeature = xenapiSupportsFeature, /* 0.8.0 */
.connectGetType = xenapiType, /* 0.8.0 */
.connectGetVersion = xenapiGetVersion, /* 0.8.0 */
.connectGetHostname = xenapiGetHostname, /* 0.8.0 */
.connectGetMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
.nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */
.getCapabilities = xenapiGetCapabilities, /* 0.8.0 */
.listDomains = xenapiListDomains, /* 0.8.0 */
.numOfDomains = xenapiNumOfDomains, /* 0.8.0 */
.connectGetCapabilities = xenapiGetCapabilities, /* 0.8.0 */
.connectListDomains = xenapiListDomains, /* 0.8.0 */
.connectNumOfDomains = xenapiNumOfDomains, /* 0.8.0 */
.domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */
.domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */
.domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */
@ -1968,8 +1968,8 @@ static virDriver xenapiDriver = {
.domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */
.domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */
.domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */
.listDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
.numOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
.connectListDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
.connectNumOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
.domainCreate = xenapiDomainCreate, /* 0.8.0 */
.domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */
@ -1981,7 +1981,7 @@ static virDriver xenapiDriver = {
.nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */
.nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */
.domainIsUpdated = xenapiDomainIsUpdated, /* 0.8.6 */
.isAlive = xenapiIsAlive, /* 0.9.8 */
.connectIsAlive = xenapiIsAlive, /* 0.9.8 */
};
/**

22
tests/qemuxml2argvtest.c
View File

@ -60,17 +60,17 @@ fakeSecretClose(virConnectPtr conn ATTRIBUTE_UNUSED)
static virSecretDriver fakeSecretDriver = {
.name = "fake_secret",
.open = NULL,
.close = fakeSecretClose,
.numOfSecrets = NULL,
.listSecrets = NULL,
.lookupByUUID = NULL,
.lookupByUsage = fakeSecretLookupByUsage,
.defineXML = NULL,
.getXMLDesc = NULL,
.setValue = NULL,
.getValue = fakeSecretGetValue,
.undefine = NULL,
.connectOpen = NULL,
.connectClose = fakeSecretClose,
.connectNumOfSecrets = NULL,
.connectListSecrets = NULL,
.secretLookupByUUID = NULL,
.secretLookupByUsage = fakeSecretLookupByUsage,
.secretDefineXML = NULL,
.secretGetXMLDesc = NULL,
.secretSetValue = NULL,
.secretGetValue = fakeSecretGetValue,
.secretUndefine = NULL,
};
typedef enum {