External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-07 18:35:46 +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; break;
default: default:
if ((supported = virDrvSupportsFeature(priv->conn, args->feature)) < 0) if ((supported = virConnectSupportsFeature(priv->conn, args->feature)) < 0)
goto cleanup; goto cleanup;
break; break;
} }

2
docs/apibuild.py
View File

@ -50,6 +50,7 @@ ignored_words = {
} }
ignored_functions = { ignored_functions = {
"virConnectSupportsFeature": "private function for remote access",
"virDomainMigrateFinish": "private function for migration", "virDomainMigrateFinish": "private function for migration",
"virDomainMigrateFinish2": "private function for migration", "virDomainMigrateFinish2": "private function for migration",
"virDomainMigratePerform": "private function for migration", "virDomainMigratePerform": "private function for migration",
@ -62,7 +63,6 @@ ignored_functions = {
"virDomainMigratePrepare3": "private function for migration", "virDomainMigratePrepare3": "private function for migration",
"virDomainMigrateConfirm3": "private function for migration", "virDomainMigrateConfirm3": "private function for migration",
"virDomainMigratePrepareTunnel3": "private function for tunnelled migration", "virDomainMigratePrepareTunnel3": "private function for tunnelled migration",
"virDrvSupportsFeature": "private function for remote access",
"DllMain": "specific function for Win32", "DllMain": "specific function for Win32",
"virTypedParameterArrayValidate": "internal function in virtypedparam.c", "virTypedParameterArrayValidate": "internal function in virtypedparam.c",
"virTypedParameterAssign": "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 => {} }; $groups{$ingrp} = { apis => {}, drivers => {} };
} }
} elsif ($ingrp) { } 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 $field = $2;
my $name = $1; my $name = $1;
my $api; my $api;
if (exists $apis{"vir$name"}) { if (exists $apis{"vir$name"}) {
$api = "vir$name"; $api = "vir$name";
} elsif (exists $apis{"virConnect$name"}) {
$api = "virConnect$name";
} elsif (exists $apis{"virNode$name"}) {
$api = "virNode$name";
} else { } else {
die "driver $name does not have a public API"; 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; my $openAuthVers = (0 * 1000 * 1000) + (4 * 1000) + 0;
foreach my $drv (keys %{$groups{"virDriver"}->{drivers}}) { foreach my $drv (keys %{$groups{"virDriver"}->{drivers}}) {
my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"open"}; my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
my $openVers; my $openVers;
if ($openVersStr =~ /(\d+)\.(\d+)\.(\d+)/) { if ($openVersStr =~ /(\d+)\.(\d+)\.(\d+)/) {
$openVers = ($1 * 1000 * 1000) + ($2 * 1000) + $3; $openVers = ($1 * 1000 * 1000) + ($2 * 1000) + $3;
} }
# virConnectOpenReadOnly always matches virConnectOpen version # virConnectOpenReadOnly always matches virConnectOpen version
$groups{"virDriver"}->{drivers}->{$drv}->{"openReadOnly"} = $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenReadOnly"} =
$groups{"virDriver"}->{drivers}->{$drv}->{"open"}; $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
# virConnectOpenAuth is always 0.4.0 if the driver existed # virConnectOpenAuth is always 0.4.0 if the driver existed
# before this time, otherwise it matches the version of # before this time, otherwise it matches the version of
# the driver's virConnectOpen entry # the driver's virConnectOpen entry
if ($openVersStr eq "Y" || if ($openVersStr eq "Y" ||
$openVers >= $openAuthVers) { $openVers >= $openAuthVers) {
$groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = $openVersStr; $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = $openVersStr;
} else { } 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; my $name = $1;
print "Bogus name $1\n"; print "Bogus name $1\n";
$status = 1; $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; virConnectPtr conn = obj;
if (conn->networkDriver) if (conn->networkDriver)
conn->networkDriver->close(conn); conn->networkDriver->connectClose(conn);
if (conn->interfaceDriver) if (conn->interfaceDriver)
conn->interfaceDriver->close(conn); conn->interfaceDriver->connectClose(conn);
if (conn->storageDriver) if (conn->storageDriver)
conn->storageDriver->close(conn); conn->storageDriver->connectClose(conn);
if (conn->deviceMonitor) if (conn->deviceMonitor)
conn->deviceMonitor->close(conn); conn->deviceMonitor->connectClose(conn);
if (conn->secretDriver) if (conn->secretDriver)
conn->secretDriver->close(conn); conn->secretDriver->connectClose(conn);
if (conn->nwfilterDriver) if (conn->nwfilterDriver)
conn->nwfilterDriver->close(conn); conn->nwfilterDriver->connectClose(conn);
if (conn->driver) if (conn->driver)
conn->driver->close(conn); conn->driver->connectClose(conn);
virMutexLock(&conn->lock); virMutexLock(&conn->lock);

258
src/driver.h
View File

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

4
src/esx/esx_device_monitor.c
View File

@ -69,8 +69,8 @@ esxDeviceClose(virConnectPtr conn)
static virDeviceMonitor esxDeviceMonitor = { static virDeviceMonitor esxDeviceMonitor = {
.name = "ESX", .name = "ESX",
.open = esxDeviceOpen, /* 0.7.6 */ .connectOpen = esxDeviceOpen, /* 0.7.6 */
.close = esxDeviceClose, /* 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 = { static virDriver esxDriver = {
.no = VIR_DRV_ESX, .no = VIR_DRV_ESX,
.name = "ESX", .name = "ESX",
.open = esxOpen, /* 0.7.0 */ .connectOpen = esxOpen, /* 0.7.0 */
.close = esxClose, /* 0.7.0 */ .connectClose = esxClose, /* 0.7.0 */
.supports_feature = esxSupportsFeature, /* 0.7.0 */ .connectSupportsFeature = esxSupportsFeature, /* 0.7.0 */
.type = esxGetType, /* 0.7.0 */ .connectGetType = esxGetType, /* 0.7.0 */
.version = esxGetVersion, /* 0.7.0 */ .connectGetVersion = esxGetVersion, /* 0.7.0 */
.getHostname = esxGetHostname, /* 0.7.0 */ .connectGetHostname = esxGetHostname, /* 0.7.0 */
.nodeGetInfo = esxNodeGetInfo, /* 0.7.0 */ .nodeGetInfo = esxNodeGetInfo, /* 0.7.0 */
.getCapabilities = esxGetCapabilities, /* 0.7.1 */ .connectGetCapabilities = esxGetCapabilities, /* 0.7.1 */
.listDomains = esxListDomains, /* 0.7.0 */ .connectListDomains = esxListDomains, /* 0.7.0 */
.numOfDomains = esxNumberOfDomains, /* 0.7.0 */ .connectNumOfDomains = esxNumberOfDomains, /* 0.7.0 */
.listAllDomains = esxListAllDomains, /* 0.10.2 */ .connectListAllDomains = esxListAllDomains, /* 0.10.2 */
.domainLookupByID = esxDomainLookupByID, /* 0.7.0 */ .domainLookupByID = esxDomainLookupByID, /* 0.7.0 */
.domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */ .domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */
.domainLookupByName = esxDomainLookupByName, /* 0.7.0 */ .domainLookupByName = esxDomainLookupByName, /* 0.7.0 */
@ -5270,10 +5270,10 @@ static virDriver esxDriver = {
.domainGetVcpusFlags = esxDomainGetVcpusFlags, /* 0.8.5 */ .domainGetVcpusFlags = esxDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = esxDomainGetMaxVcpus, /* 0.7.0 */ .domainGetMaxVcpus = esxDomainGetMaxVcpus, /* 0.7.0 */
.domainGetXMLDesc = esxDomainGetXMLDesc, /* 0.7.0 */ .domainGetXMLDesc = esxDomainGetXMLDesc, /* 0.7.0 */
.domainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */ .connectDomainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
.domainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */ .connectDomainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
.listDefinedDomains = esxListDefinedDomains, /* 0.7.0 */ .connectListDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
.numOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */ .connectNumOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
.domainCreate = esxDomainCreate, /* 0.7.0 */ .domainCreate = esxDomainCreate, /* 0.7.0 */
.domainCreateWithFlags = esxDomainCreateWithFlags, /* 0.8.2 */ .domainCreateWithFlags = esxDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = esxDomainDefineXML, /* 0.7.2 */ .domainDefineXML = esxDomainDefineXML, /* 0.7.2 */
@ -5290,8 +5290,8 @@ static virDriver esxDriver = {
.domainMigratePerform = esxDomainMigratePerform, /* 0.7.0 */ .domainMigratePerform = esxDomainMigratePerform, /* 0.7.0 */
.domainMigrateFinish = esxDomainMigrateFinish, /* 0.7.0 */ .domainMigrateFinish = esxDomainMigrateFinish, /* 0.7.0 */
.nodeGetFreeMemory = esxNodeGetFreeMemory, /* 0.7.2 */ .nodeGetFreeMemory = esxNodeGetFreeMemory, /* 0.7.2 */
.isEncrypted = esxIsEncrypted, /* 0.7.3 */ .connectIsEncrypted = esxIsEncrypted, /* 0.7.3 */
.isSecure = esxIsSecure, /* 0.7.3 */ .connectIsSecure = esxIsSecure, /* 0.7.3 */
.domainIsActive = esxDomainIsActive, /* 0.7.3 */ .domainIsActive = esxDomainIsActive, /* 0.7.3 */
.domainIsPersistent = esxDomainIsPersistent, /* 0.7.3 */ .domainIsPersistent = esxDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = esxDomainIsUpdated, /* 0.8.6 */ .domainIsUpdated = esxDomainIsUpdated, /* 0.8.6 */
@ -5309,7 +5309,7 @@ static virDriver esxDriver = {
.domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */ .domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */
.domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */ .domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */
.domainSnapshotDelete = esxDomainSnapshotDelete, /* 0.8.0 */ .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 = { static virInterfaceDriver esxInterfaceDriver = {
.name = "ESX", .name = "ESX",
.open = esxInterfaceOpen, /* 0.7.6 */ .connectOpen = esxInterfaceOpen, /* 0.7.6 */
.close = esxInterfaceClose, /* 0.7.6 */ .connectClose = esxInterfaceClose, /* 0.7.6 */
.numOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */ .connectNumOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
.listInterfaces = esxListInterfaces, /* 0.10.0 */ .connectListInterfaces = esxListInterfaces, /* 0.10.0 */
.numOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */ .connectNumOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
.listDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */ .connectListDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
.interfaceLookupByName = esxInterfaceLookupByName, /* 0.10.0 */ .interfaceLookupByName = esxInterfaceLookupByName, /* 0.10.0 */
.interfaceLookupByMACString = esxInterfaceLookupByMACString, /* 0.10.0 */ .interfaceLookupByMACString = esxInterfaceLookupByMACString, /* 0.10.0 */
.interfaceGetXMLDesc = esxInterfaceGetXMLDesc, /* 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 = { static virNetworkDriver esxNetworkDriver = {
.name = "ESX", .name = "ESX",
.open = esxNetworkOpen, /* 0.7.6 */ .connectOpen = esxNetworkOpen, /* 0.7.6 */
.close = esxNetworkClose, /* 0.7.6 */ .connectClose = esxNetworkClose, /* 0.7.6 */
.numOfNetworks = esxNumberOfNetworks, /* 0.10.0 */ .connectNumOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
.listNetworks = esxListNetworks, /* 0.10.0 */ .connectListNetworks = esxListNetworks, /* 0.10.0 */
.numOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */ .connectNumOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
.listDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */ .connectListDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
.networkLookupByUUID = esxNetworkLookupByUUID, /* 0.10.0 */ .networkLookupByUUID = esxNetworkLookupByUUID, /* 0.10.0 */
.networkLookupByName = esxNetworkLookupByName, /* 0.10.0 */ .networkLookupByName = esxNetworkLookupByName, /* 0.10.0 */
.networkDefineXML = esxNetworkDefineXML, /* 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 = { static virNWFilterDriver esxNWFilterDriver = {
.name = "ESX", .name = "ESX",
.open = esxNWFilterOpen, /* 0.8.1 */ .connectOpen = esxNWFilterOpen, /* 0.8.1 */
.close = esxNWFilterClose, /* 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 = { static virSecretDriver esxSecretDriver = {
.name = "ESX", .name = "ESX",
.open = esxSecretOpen, /* 0.7.6 */ .connectOpen = esxSecretOpen, /* 0.7.6 */
.close = esxSecretClose, /* 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 = { virStorageDriver esxStorageBackendISCSI = {
.numOfPools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */ .connectNumOfStoragePools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
.listPools = esxStorageBackendISCSIListPools, /* 1.0.1 */ .connectListStoragePools = esxStorageBackendISCSIListPools, /* 1.0.1 */
.poolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */ .storagePoolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
.poolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */ .storagePoolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
.poolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */ .storagePoolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
.poolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */ .storagePoolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
.poolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */ .storagePoolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
.poolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */ .storagePoolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
.poolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */ .storagePoolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
.volLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */ .storageVolLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
.volLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */ .storageVolLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
.volLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */ .storageVolLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
.volCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */ .storageVolCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
.volCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */ .storageVolCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
.volGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */ .storageVolGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
.volDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */ .storageVolDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
.volWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */ .storageVolWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
.volGetPath = esxStorageBackendISCSIVolumeGetPath, /* 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 = { virStorageDriver esxStorageBackendVMFS = {
.numOfPools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */ .connectNumOfStoragePools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
.listPools = esxStorageBackendVMFSListPools, /* 0.8.2 */ .connectListStoragePools = esxStorageBackendVMFSListPools, /* 0.8.2 */
.poolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */ .storagePoolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */ .storagePoolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
.poolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */ .storagePoolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
.poolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */ .storagePoolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
.poolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */ .storagePoolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
.poolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */ .storagePoolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
.poolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */ .storagePoolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
.volLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */ .storageVolLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
.volLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */ .storageVolLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
.volLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */ .storageVolLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
.volCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */ .storageVolCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
.volCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */ .storageVolCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
.volDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */ .storageVolDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
.volWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */ .storageVolWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
.volGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */ .storageVolGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
.volGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */ .storageVolGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
.volGetPath = esxStorageBackendVMFSVolumeGetPath, /* 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) { for (i = 0; i < LAST_BACKEND; ++i) {
tmp = backends[i]->numOfPools(conn); tmp = backends[i]->connectNumOfStoragePools(conn);
if (tmp < 0) { if (tmp < 0) {
return -1; return -1;
@ -127,7 +127,7 @@ esxListStoragePools(virConnectPtr conn, char **const names, int maxnames)
} }
for (i = 0; i < LAST_BACKEND; ++i) { 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) { if (tmp < 0) {
goto cleanup; goto cleanup;
@ -186,7 +186,7 @@ esxStoragePoolLookupByName(virConnectPtr conn, const char *name)
} }
for (i = 0; i < LAST_BACKEND; ++i) { for (i = 0; i < LAST_BACKEND; ++i) {
pool = backends[i]->poolLookupByName(conn, name); pool = backends[i]->storagePoolLookupByName(conn, name);
if (pool != NULL) { if (pool != NULL) {
return pool; return pool;
@ -215,7 +215,7 @@ esxStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
/* invoke backend drive method to search all known pools */ /* invoke backend drive method to search all known pools */
for (i = 0; i < LAST_BACKEND; ++i) { for (i = 0; i < LAST_BACKEND; ++i) {
pool = backends[i]->poolLookupByUUID(conn, uuid); pool = backends[i]->storagePoolLookupByUUID(conn, uuid);
if (pool != NULL) { if (pool != NULL) {
return pool; return pool;
@ -252,7 +252,7 @@ esxStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
return -1; return -1;
} }
return backend->poolRefresh(pool, flags); return backend->storagePoolRefresh(pool, flags);
} }
@ -271,7 +271,7 @@ esxStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
return -1; 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 NULL;
} }
return backend->poolGetXMLDesc(pool, flags); return backend->storagePoolGetXMLDesc(pool, flags);
} }
@ -335,7 +335,7 @@ esxStoragePoolNumberOfStorageVolumes(virStoragePoolPtr pool)
return -1; return -1;
} }
return backend->poolNumOfVolumes(pool); return backend->storagePoolNumOfVolumes(pool);
} }
@ -353,7 +353,7 @@ esxStoragePoolListStorageVolumes(virStoragePoolPtr pool, char **const names,
return -1; 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 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 * iSCSI LUNs device path follows normal linux path convention
*/ */
if (STRPREFIX(path, "[")) { if (STRPREFIX(path, "[")) {
return backends[VMFS]->volLookupByPath(conn, path); return backends[VMFS]->storageVolLookupByPath(conn, path);
} else if (STRPREFIX(path, "/")) { } else if (STRPREFIX(path, "/")) {
return backends[ISCSI]->volLookupByPath(conn, path); return backends[ISCSI]->storageVolLookupByPath(conn, path);
} else { } else {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("Unexpected volume path format: %s"), path); _("Unexpected volume path format: %s"), path);
@ -418,7 +418,7 @@ esxStorageVolumeLookupByKey(virConnectPtr conn, const char *key)
} }
for (i = 0; i < LAST_BACKEND; ++i) { for (i = 0; i < LAST_BACKEND; ++i) {
volume = backends[i]->volLookupByKey(conn, key); volume = backends[i]->storageVolLookupByKey(conn, key);
if (volume != NULL) { if (volume != NULL) {
return volume; return volume;
@ -447,7 +447,7 @@ esxStorageVolumeCreateXML(virStoragePoolPtr pool, const char *xmldesc,
return NULL; 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 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 -1;
} }
return backend->volDelete(volume, flags); return backend->storageVolDelete(volume, flags);
} }
@ -499,7 +499,7 @@ esxStorageVolumeWipe(virStorageVolPtr volume, unsigned int flags)
return -1; return -1;
} }
return backend->volWipe(volume, flags); return backend->storageVolWipe(volume, flags);
} }
@ -516,7 +516,7 @@ esxStorageVolumeGetInfo(virStorageVolPtr volume, virStorageVolInfoPtr info)
return -1; 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 NULL;
} }
return backend->volGetXMLDesc(volume, flags); return backend->storageVolGetXMLDesc(volume, flags);
} }
@ -550,7 +550,7 @@ esxStorageVolumeGetPath(virStorageVolPtr volume)
return NULL; return NULL;
} }
return backend->volGetPath(volume); return backend->storageVolGetPath(volume);
} }
@ -575,34 +575,34 @@ esxStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
static virStorageDriver esxStorageDriver = { static virStorageDriver esxStorageDriver = {
.name = "ESX", .name = "ESX",
.open = esxStorageOpen, /* 0.7.6 */ .connectOpen = esxStorageOpen, /* 0.7.6 */
.close = esxStorageClose, /* 0.7.6 */ .connectClose = esxStorageClose, /* 0.7.6 */
.numOfPools = esxNumberOfStoragePools, /* 0.8.2 */ .connectNumOfStoragePools = esxNumberOfStoragePools, /* 0.8.2 */
.listPools = esxListStoragePools, /* 0.8.2 */ .connectListStoragePools = esxListStoragePools, /* 0.8.2 */
.numOfDefinedPools = esxNumberOfDefinedStoragePools, /* 0.8.2 */ .connectNumOfDefinedStoragePools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
.listDefinedPools = esxListDefinedStoragePools, /* 0.8.2 */ .connectListDefinedStoragePools = esxListDefinedStoragePools, /* 0.8.2 */
.poolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */ .storagePoolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */ .storagePoolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
.poolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */ .storagePoolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
.poolRefresh = esxStoragePoolRefresh, /* 0.8.2 */ .storagePoolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
.poolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */ .storagePoolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
.poolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */ .storagePoolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
.poolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */ .storagePoolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
.poolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */ .storagePoolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
.poolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */ .storagePoolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
.poolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */ .storagePoolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
.volLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */ .storageVolLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
.volLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */ .storageVolLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
.volLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */ .storageVolLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
.volCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */ .storageVolCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
.volCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */ .storageVolCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
.volDelete = esxStorageVolumeDelete, /* 0.8.7 */ .storageVolDelete = esxStorageVolumeDelete, /* 0.8.7 */
.volWipe = esxStorageVolumeWipe, /* 0.8.7 */ .storageVolWipe = esxStorageVolumeWipe, /* 0.8.7 */
.volGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */ .storageVolGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
.volGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */ .storageVolGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
.volGetPath = esxStorageVolumeGetPath, /* 0.8.4 */ .storageVolGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
.poolIsActive = esxStoragePoolIsActive, /* 0.8.2 */ .storagePoolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
.poolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */ .storagePoolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
}; };

6
src/fdstream.c
View File

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

4
src/hyperv/hyperv_device_monitor.c
View File

@ -66,8 +66,8 @@ hypervDeviceClose(virConnectPtr conn)
static virDeviceMonitor hypervDeviceMonitor = { static virDeviceMonitor hypervDeviceMonitor = {
"Hyper-V", "Hyper-V",
.open = hypervDeviceOpen, /* 0.9.5 */ .connectOpen = hypervDeviceOpen, /* 0.9.5 */
.close = hypervDeviceClose, /* 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 = { static virDriver hypervDriver = {
.no = VIR_DRV_HYPERV, .no = VIR_DRV_HYPERV,
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervOpen, /* 0.9.5 */ .connectOpen = hypervOpen, /* 0.9.5 */
.close = hypervClose, /* 0.9.5 */ .connectClose = hypervClose, /* 0.9.5 */
.type = hypervGetType, /* 0.9.5 */ .connectGetType = hypervGetType, /* 0.9.5 */
.getHostname = hypervGetHostname, /* 0.9.5 */ .connectGetHostname = hypervGetHostname, /* 0.9.5 */
.nodeGetInfo = hypervNodeGetInfo, /* 0.9.5 */ .nodeGetInfo = hypervNodeGetInfo, /* 0.9.5 */
.listDomains = hypervListDomains, /* 0.9.5 */ .connectListDomains = hypervListDomains, /* 0.9.5 */
.numOfDomains = hypervNumberOfDomains, /* 0.9.5 */ .connectNumOfDomains = hypervNumberOfDomains, /* 0.9.5 */
.listAllDomains = hypervListAllDomains, /* 0.10.2 */ .connectListAllDomains = hypervListAllDomains, /* 0.10.2 */
.domainLookupByID = hypervDomainLookupByID, /* 0.9.5 */ .domainLookupByID = hypervDomainLookupByID, /* 0.9.5 */
.domainLookupByUUID = hypervDomainLookupByUUID, /* 0.9.5 */ .domainLookupByUUID = hypervDomainLookupByUUID, /* 0.9.5 */
.domainLookupByName = hypervDomainLookupByName, /* 0.9.5 */ .domainLookupByName = hypervDomainLookupByName, /* 0.9.5 */
@ -1417,19 +1417,19 @@ static virDriver hypervDriver = {
.domainGetInfo = hypervDomainGetInfo, /* 0.9.5 */ .domainGetInfo = hypervDomainGetInfo, /* 0.9.5 */
.domainGetState = hypervDomainGetState, /* 0.9.5 */ .domainGetState = hypervDomainGetState, /* 0.9.5 */
.domainGetXMLDesc = hypervDomainGetXMLDesc, /* 0.9.5 */ .domainGetXMLDesc = hypervDomainGetXMLDesc, /* 0.9.5 */
.listDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */ .connectListDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
.numOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */ .connectNumOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
.domainCreate = hypervDomainCreate, /* 0.9.5 */ .domainCreate = hypervDomainCreate, /* 0.9.5 */
.domainCreateWithFlags = hypervDomainCreateWithFlags, /* 0.9.5 */ .domainCreateWithFlags = hypervDomainCreateWithFlags, /* 0.9.5 */
.isEncrypted = hypervIsEncrypted, /* 0.9.5 */ .connectIsEncrypted = hypervIsEncrypted, /* 0.9.5 */
.isSecure = hypervIsSecure, /* 0.9.5 */ .connectIsSecure = hypervIsSecure, /* 0.9.5 */
.domainIsActive = hypervDomainIsActive, /* 0.9.5 */ .domainIsActive = hypervDomainIsActive, /* 0.9.5 */
.domainIsPersistent = hypervDomainIsPersistent, /* 0.9.5 */ .domainIsPersistent = hypervDomainIsPersistent, /* 0.9.5 */
.domainIsUpdated = hypervDomainIsUpdated, /* 0.9.5 */ .domainIsUpdated = hypervDomainIsUpdated, /* 0.9.5 */
.domainManagedSave = hypervDomainManagedSave, /* 0.9.5 */ .domainManagedSave = hypervDomainManagedSave, /* 0.9.5 */
.domainHasManagedSaveImage = hypervDomainHasManagedSaveImage, /* 0.9.5 */ .domainHasManagedSaveImage = hypervDomainHasManagedSaveImage, /* 0.9.5 */
.domainManagedSaveRemove = hypervDomainManagedSaveRemove, /* 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 = { static virInterfaceDriver hypervInterfaceDriver = {
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervInterfaceOpen, /* 0.9.5 */ .connectOpen = hypervInterfaceOpen, /* 0.9.5 */
.close = hypervInterfaceClose, /* 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 = { static virNetworkDriver hypervNetworkDriver = {
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervNetworkOpen, /* 0.9.5 */ .connectOpen = hypervNetworkOpen, /* 0.9.5 */
.close = hypervNetworkClose, /* 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 = { static virNWFilterDriver hypervNWFilterDriver = {
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervNWFilterOpen, /* 0.9.5 */ .connectOpen = hypervNWFilterOpen, /* 0.9.5 */
.close = hypervNWFilterClose, /* 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 = { static virSecretDriver hypervSecretDriver = {
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervSecretOpen, /* 0.9.5 */ .connectOpen = hypervSecretOpen, /* 0.9.5 */
.close = hypervSecretClose, /* 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 = { static virStorageDriver hypervStorageDriver = {
.name = "Hyper-V", .name = "Hyper-V",
.open = hypervStorageOpen, /* 0.9.5*/ .connectOpen = hypervStorageOpen, /* 0.9.5*/
.close = hypervStorageClose, /* 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 = { static virInterfaceDriver interfaceDriver = {
"netcf", "netcf",
.open = interfaceOpenInterface, /* 0.7.0 */ .connectOpen = interfaceOpenInterface, /* 0.7.0 */
.close = interfaceCloseInterface, /* 0.7.0 */ .connectClose = interfaceCloseInterface, /* 0.7.0 */
.numOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */ .connectNumOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
.listInterfaces = interfaceListInterfaces, /* 0.7.0 */ .connectListInterfaces = interfaceListInterfaces, /* 0.7.0 */
.numOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */ .connectNumOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
.listDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */ .connectListDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
.listAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */ .connectListAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
.interfaceLookupByName = interfaceLookupByName, /* 0.7.0 */ .interfaceLookupByName = interfaceLookupByName, /* 0.7.0 */
.interfaceLookupByMACString = interfaceLookupByMACString, /* 0.7.0 */ .interfaceLookupByMACString = interfaceLookupByMACString, /* 0.7.0 */
.interfaceGetXMLDesc = interfaceGetXMLDesc, /* 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 = { static virInterfaceDriver udevIfaceDriver = {
"udev", "udev",
.open = udevIfaceOpenInterface, /* 1.0.0 */ .connectOpen = udevIfaceOpenInterface, /* 1.0.0 */
.close = udevIfaceCloseInterface, /* 1.0.0 */ .connectClose = udevIfaceCloseInterface, /* 1.0.0 */
.numOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */ .connectNumOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
.listInterfaces = udevIfaceListInterfaces, /* 1.0.0 */ .connectListInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
.numOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */ .connectNumOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
.listDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */ .connectListDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
.listAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */ .connectListAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
.interfaceLookupByName = udevIfaceLookupByName, /* 1.0.0 */ .interfaceLookupByName = udevIfaceLookupByName, /* 1.0.0 */
.interfaceLookupByMACString = udevIfaceLookupByMACString, /* 1.0.0 */ .interfaceLookupByMACString = udevIfaceLookupByMACString, /* 1.0.0 */
.interfaceIsActive = udevIfaceIsActive, /* 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; goto error;
} }
if (conn->driver->qemuDomainMonitorCommand) { if (conn->driver->domainQemuMonitorCommand) {
int ret; int ret;
ret = conn->driver->qemuDomainMonitorCommand(domain, cmd, result, ret = conn->driver->domainQemuMonitorCommand(domain, cmd, result,
flags); flags);
if (ret < 0) if (ret < 0)
goto error; goto error;
@ -170,9 +170,9 @@ virDomainQemuAttach(virConnectPtr conn,
goto error; goto error;
} }
if (conn->driver->qemuDomainAttach) { if (conn->driver->domainQemuAttach) {
virDomainPtr ret; virDomainPtr ret;
ret = conn->driver->qemuDomainAttach(conn, pid_value, flags); ret = conn->driver->domainQemuAttach(conn, pid_value, flags);
if (!ret) if (!ret)
goto error; goto error;
return ret; return ret;
@ -227,9 +227,9 @@ virDomainQemuAgentCommand(virDomainPtr domain,
conn = domain->conn; conn = domain->conn;
if (conn->driver->qemuDomainArbitraryAgentCommand) { if (conn->driver->domainQemuAgentCommand) {
return conn->driver->qemuDomainArbitraryAgentCommand(domain, cmd, return conn->driver->domainQemuAgentCommand(domain, cmd,
timeout, flags); timeout, flags);
} }
virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); 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, int virDomainMigratePrepare (virConnectPtr dconn,
char **cookie, char **cookie,

2
src/libvirt_private.syms
View File

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

44
src/libxl/libxl_driver.c
View File

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

42
src/lxc/lxc_driver.c
View File

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

20
src/network/bridge_driver.c
View File

@ -3592,13 +3592,13 @@ cleanup:
static virNetworkDriver networkDriver = { static virNetworkDriver networkDriver = {
"Network", "Network",
.open = networkOpenNetwork, /* 0.2.0 */ .connectOpen = networkOpenNetwork, /* 0.2.0 */
.close = networkCloseNetwork, /* 0.2.0 */ .connectClose = networkCloseNetwork, /* 0.2.0 */
.numOfNetworks = networkNumNetworks, /* 0.2.0 */ .connectNumOfNetworks = networkNumNetworks, /* 0.2.0 */
.listNetworks = networkListNetworks, /* 0.2.0 */ .connectListNetworks = networkListNetworks, /* 0.2.0 */
.numOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */ .connectNumOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
.listDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */ .connectListDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
.listAllNetworks = networkListAllNetworks, /* 0.10.2 */ .connectListAllNetworks = networkListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */ .networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */
.networkLookupByName = networkLookupByName, /* 0.2.0 */ .networkLookupByName = networkLookupByName, /* 0.2.0 */
.networkCreateXML = networkCreate, /* 0.2.0 */ .networkCreateXML = networkCreate, /* 0.2.0 */
@ -3617,9 +3617,9 @@ static virNetworkDriver networkDriver = {
static virStateDriver networkStateDriver = { static virStateDriver networkStateDriver = {
.name = "Network", .name = "Network",
.initialize = networkStartup, .stateInitialize = networkStartup,
.cleanup = networkShutdown, .stateCleanup = networkShutdown,
.reload = networkReload, .stateReload = networkReload,
}; };
int networkRegister(void) { 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 = { static virDeviceMonitor halDeviceMonitor = {
.name = "halDeviceMonitor", .name = "halDeviceMonitor",
.open = halNodeDrvOpen, /* 0.5.0 */ .connectOpen = halNodeDrvOpen, /* 0.5.0 */
.close = halNodeDrvClose, /* 0.5.0 */ .connectClose = halNodeDrvClose, /* 0.5.0 */
.numOfDevices = nodeNumOfDevices, /* 0.5.0 */ .nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */
.listDevices = nodeListDevices, /* 0.5.0 */ .nodeListDevices = nodeListDevices, /* 0.5.0 */
.listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */ .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.deviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */ .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
.deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */ .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */ .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
.deviceGetParent = nodeDeviceGetParent, /* 0.5.0 */ .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
.deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */ .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
.deviceListCaps = nodeDeviceListCaps, /* 0.5.0 */ .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
.deviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */ .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
.deviceDestroy = nodeDeviceDestroy, /* 0.6.5 */ .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
}; };
static virStateDriver halStateDriver = { static virStateDriver halStateDriver = {
.name = "HAL", .name = "HAL",
.initialize = halDeviceMonitorStartup, /* 0.5.0 */ .stateInitialize = halDeviceMonitorStartup, /* 0.5.0 */
.cleanup = halDeviceMonitorShutdown, /* 0.5.0 */ .stateCleanup = halDeviceMonitorShutdown, /* 0.5.0 */
.reload = halDeviceMonitorReload, /* 0.5.0 */ .stateReload = halDeviceMonitorReload, /* 0.5.0 */
}; };
int halNodeRegister(void) 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 = { static virDeviceMonitor udevDeviceMonitor = {
.name = "udevDeviceMonitor", .name = "udevDeviceMonitor",
.open = udevNodeDrvOpen, /* 0.7.3 */ .connectOpen = udevNodeDrvOpen, /* 0.7.3 */
.close = udevNodeDrvClose, /* 0.7.3 */ .connectClose = udevNodeDrvClose, /* 0.7.3 */
.numOfDevices = nodeNumOfDevices, /* 0.7.3 */ .nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
.listDevices = nodeListDevices, /* 0.7.3 */ .nodeListDevices = nodeListDevices, /* 0.7.3 */
.listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */ .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
.deviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */ .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
.deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */ .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
.deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */ .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
.deviceGetParent = nodeDeviceGetParent, /* 0.7.3 */ .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
.deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */ .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
.deviceListCaps = nodeDeviceListCaps, /* 0.7.3 */ .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
.deviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */ .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
.deviceDestroy = nodeDeviceDestroy, /* 0.7.3 */ .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
}; };
static virStateDriver udevStateDriver = { static virStateDriver udevStateDriver = {
.name = "udev", .name = "udev",
.initialize = udevDeviceMonitorStartup, /* 0.7.3 */ .stateInitialize = udevDeviceMonitorStartup, /* 0.7.3 */
.cleanup = udevDeviceMonitorShutdown, /* 0.7.3 */ .stateCleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
.reload = udevDeviceMonitorReload, /* 0.7.3 */ .stateReload = udevDeviceMonitorReload, /* 0.7.3 */
}; };
int udevNodeRegister(void) int udevNodeRegister(void)

22
src/nwfilter/nwfilter_driver.c
View File

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

30
src/openvz/openvz_driver.c
View File

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

14
src/parallels/parallels_network.c
View File

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

62
src/parallels/parallels_storage.c
View File

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

60
src/phyp/phyp_driver.c
View File

@ -3764,11 +3764,11 @@ phypVIOSDriverClose(virConnectPtr conn ATTRIBUTE_UNUSED)
static virDriver phypDriver = { static virDriver phypDriver = {
.no = VIR_DRV_PHYP, .no = VIR_DRV_PHYP,
.name = "PHYP", .name = "PHYP",
.open = phypOpen, /* 0.7.0 */ .connectOpen = phypOpen, /* 0.7.0 */
.close = phypClose, /* 0.7.0 */ .connectClose = phypClose, /* 0.7.0 */
.getCapabilities = phypConnectGetCapabilities, /* 0.7.3 */ .connectGetCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
.listDomains = phypListDomains, /* 0.7.0 */ .connectListDomains = phypListDomains, /* 0.7.0 */
.numOfDomains = phypNumDomains, /* 0.7.0 */ .connectNumOfDomains = phypNumDomains, /* 0.7.0 */
.domainCreateXML = phypDomainCreateAndStart, /* 0.7.3 */ .domainCreateXML = phypDomainCreateAndStart, /* 0.7.3 */
.domainLookupByID = phypDomainLookupByID, /* 0.7.0 */ .domainLookupByID = phypDomainLookupByID, /* 0.7.0 */
.domainLookupByName = phypDomainLookupByName, /* 0.7.0 */ .domainLookupByName = phypDomainLookupByName, /* 0.7.0 */
@ -3784,43 +3784,43 @@ static virDriver phypDriver = {
.domainGetVcpusFlags = phypDomainGetVcpusFlags, /* 0.8.5 */ .domainGetVcpusFlags = phypDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = phypGetLparCPUMAX, /* 0.7.3 */ .domainGetMaxVcpus = phypGetLparCPUMAX, /* 0.7.3 */
.domainGetXMLDesc = phypDomainGetXMLDesc, /* 0.7.0 */ .domainGetXMLDesc = phypDomainGetXMLDesc, /* 0.7.0 */
.listDefinedDomains = phypListDefinedDomains, /* 0.7.0 */ .connectListDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
.numOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */ .connectNumOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
.domainAttachDevice = phypAttachDevice, /* 0.8.2 */ .domainAttachDevice = phypAttachDevice, /* 0.8.2 */
.isEncrypted = phypIsEncrypted, /* 0.7.3 */ .connectIsEncrypted = phypIsEncrypted, /* 0.7.3 */
.isSecure = phypIsSecure, /* 0.7.3 */ .connectIsSecure = phypIsSecure, /* 0.7.3 */
.domainIsUpdated = phypIsUpdated, /* 0.8.6 */ .domainIsUpdated = phypIsUpdated, /* 0.8.6 */
.isAlive = phypIsAlive, /* 0.9.8 */ .connectIsAlive = phypIsAlive, /* 0.9.8 */
}; };
static virStorageDriver phypStorageDriver = { static virStorageDriver phypStorageDriver = {
.name = "PHYP", .name = "PHYP",
.open = phypVIOSDriverOpen, /* 0.8.2 */ .connectOpen = phypVIOSDriverOpen, /* 0.8.2 */
.close = phypVIOSDriverClose, /* 0.8.2 */ .connectClose = phypVIOSDriverClose, /* 0.8.2 */
.numOfPools = phypNumOfStoragePools, /* 0.8.2 */ .connectNumOfStoragePools = phypNumOfStoragePools, /* 0.8.2 */
.listPools = phypListStoragePools, /* 0.8.2 */ .connectListStoragePools = phypListStoragePools, /* 0.8.2 */
.poolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */ .storagePoolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
.poolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */ .storagePoolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
.poolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */ .storagePoolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
.poolDestroy = phypDestroyStoragePool, /* 0.8.2 */ .storagePoolDestroy = phypDestroyStoragePool, /* 0.8.2 */
.poolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */ .storagePoolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
.poolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */ .storagePoolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
.poolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */ .storagePoolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
.volLookupByName = phypVolumeLookupByName, /* 0.8.2 */ .storageVolLookupByName = phypVolumeLookupByName, /* 0.8.2 */
.volLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */ .storageVolLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
.volCreateXML = phypStorageVolCreateXML, /* 0.8.2 */ .storageVolCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
.volGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */ .storageVolGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
.volGetPath = phypVolumeGetPath, /* 0.8.2 */ .storageVolGetPath = phypVolumeGetPath, /* 0.8.2 */
}; };
static virInterfaceDriver phypInterfaceDriver = { static virInterfaceDriver phypInterfaceDriver = {
.name = "PHYP", .name = "PHYP",
.open = phypVIOSDriverOpen, /* 0.9.1 */ .connectOpen = phypVIOSDriverOpen, /* 0.9.1 */
.close = phypVIOSDriverClose, /* 0.9.1 */ .connectClose = phypVIOSDriverClose, /* 0.9.1 */
.numOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */ .connectNumOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
.listInterfaces = phypListInterfaces, /* 0.9.1 */ .connectListInterfaces = phypListInterfaces, /* 0.9.1 */
.interfaceLookupByName = phypInterfaceLookupByName, /* 0.9.1 */ .interfaceLookupByName = phypInterfaceLookupByName, /* 0.9.1 */
.interfaceDefineXML = phypInterfaceDefineXML, /* 0.9.1 */ .interfaceDefineXML = phypInterfaceDefineXML, /* 0.9.1 */
.interfaceDestroy = phypInterfaceDestroy, /* 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) { if (sec) {
char *base64 = NULL; char *base64 = NULL;
secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0, secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL); VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) { if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"), _("could not get the value of the secret for username %s"),
@ -2522,8 +2522,8 @@ qemuBuildDriveURIString(virConnectPtr conn,
} }
if (sec) { if (sec) {
secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0, secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
VIR_SECRET_GET_VALUE_INTERNAL_CALL); VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) { if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"), _("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 = { static virDriver qemuDriver = {
.no = VIR_DRV_QEMU, .no = VIR_DRV_QEMU,
.name = QEMU_DRIVER_NAME, .name = QEMU_DRIVER_NAME,
.open = qemuOpen, /* 0.2.0 */ .connectOpen = qemuOpen, /* 0.2.0 */
.close = qemuClose, /* 0.2.0 */ .connectClose = qemuClose, /* 0.2.0 */
.supports_feature = qemuSupportsFeature, /* 0.5.0 */ .connectSupportsFeature = qemuSupportsFeature, /* 0.5.0 */
.type = qemuGetType, /* 0.2.0 */ .connectGetType = qemuGetType, /* 0.2.0 */
.version = qemuGetVersion, /* 0.2.0 */ .connectGetVersion = qemuGetVersion, /* 0.2.0 */
.getHostname = virGetHostname, /* 0.3.3 */ .connectGetHostname = virGetHostname, /* 0.3.3 */
.getSysinfo = qemuGetSysinfo, /* 0.8.8 */ .connectGetSysinfo = qemuGetSysinfo, /* 0.8.8 */
.getMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */ .connectGetMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
.nodeGetInfo = nodeGetInfo, /* 0.2.0 */ .nodeGetInfo = nodeGetInfo, /* 0.2.0 */
.getCapabilities = qemuGetCapabilities, /* 0.2.1 */ .connectGetCapabilities = qemuGetCapabilities, /* 0.2.1 */
.listDomains = qemuListDomains, /* 0.2.0 */ .connectListDomains = qemuListDomains, /* 0.2.0 */
.numOfDomains = qemuNumDomains, /* 0.2.0 */ .connectNumOfDomains = qemuNumDomains, /* 0.2.0 */
.listAllDomains = qemuListAllDomains, /* 0.9.13 */ .connectListAllDomains = qemuListAllDomains, /* 0.9.13 */
.domainCreateXML = qemuDomainCreate, /* 0.2.0 */ .domainCreateXML = qemuDomainCreate, /* 0.2.0 */
.domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */ .domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */
.domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */ .domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */
@ -14685,10 +14685,10 @@ static virDriver qemuDriver = {
.domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */ .domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */
.nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */ .nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */ .domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */
.domainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */ .connectDomainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */ .connectDomainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
.listDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */ .connectListDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
.numOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */ .connectNumOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
.domainCreate = qemuDomainStart, /* 0.2.0 */ .domainCreate = qemuDomainStart, /* 0.2.0 */
.domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */ .domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = qemuDomainDefine, /* 0.2.0 */ .domainDefineXML = qemuDomainDefine, /* 0.2.0 */
@ -14719,21 +14719,21 @@ static virDriver qemuDriver = {
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */ .nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.4.4 */ .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.4.4 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */ .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */
.domainEventRegister = qemuDomainEventRegister, /* 0.5.0 */ .connectDomainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */ .connectDomainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
.domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */ .domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */
.domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */ .domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */
.nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */ .nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */ .nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */ .nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */
.domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */ .domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */
.isEncrypted = qemuIsEncrypted, /* 0.7.3 */ .connectIsEncrypted = qemuIsEncrypted, /* 0.7.3 */
.isSecure = qemuIsSecure, /* 0.7.3 */ .connectIsSecure = qemuIsSecure, /* 0.7.3 */
.domainIsActive = qemuDomainIsActive, /* 0.7.3 */ .domainIsActive = qemuDomainIsActive, /* 0.7.3 */
.domainIsPersistent = qemuDomainIsPersistent, /* 0.7.3 */ .domainIsPersistent = qemuDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = qemuDomainIsUpdated, /* 0.8.6 */ .domainIsUpdated = qemuDomainIsUpdated, /* 0.8.6 */
.cpuCompare = qemuCPUCompare, /* 0.7.5 */ .connectCompareCPU = qemuCPUCompare, /* 0.7.5 */
.cpuBaseline = qemuCPUBaseline, /* 0.7.7 */ .connectBaselineCPU = qemuCPUBaseline, /* 0.7.7 */
.domainGetJobInfo = qemuDomainGetJobInfo, /* 0.7.7 */ .domainGetJobInfo = qemuDomainGetJobInfo, /* 0.7.7 */
.domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */ .domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */
.domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */ .domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */
@ -14742,8 +14742,8 @@ static virDriver qemuDriver = {
.domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */ .domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */
.domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */ .domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */
.domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */ .domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */
.domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */ .connectDomainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */ .connectDomainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
.domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */ .domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */
.domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */ .domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */
.domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */ .domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */
@ -14763,9 +14763,9 @@ static virDriver qemuDriver = {
.domainSnapshotHasMetadata = qemuDomainSnapshotHasMetadata, /* 0.9.13 */ .domainSnapshotHasMetadata = qemuDomainSnapshotHasMetadata, /* 0.9.13 */
.domainRevertToSnapshot = qemuDomainRevertToSnapshot, /* 0.8.0 */ .domainRevertToSnapshot = qemuDomainRevertToSnapshot, /* 0.8.0 */
.domainSnapshotDelete = qemuDomainSnapshotDelete, /* 0.8.0 */ .domainSnapshotDelete = qemuDomainSnapshotDelete, /* 0.8.0 */
.qemuDomainMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */ .domainQemuMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
.qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */ .domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
.qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */ .domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainOpenConsole = qemuDomainOpenConsole, /* 0.8.6 */ .domainOpenConsole = qemuDomainOpenConsole, /* 0.8.6 */
.domainOpenGraphics = qemuDomainOpenGraphics, /* 0.9.7 */ .domainOpenGraphics = qemuDomainOpenGraphics, /* 0.9.7 */
.domainInjectNMI = qemuDomainInjectNMI, /* 0.9.2 */ .domainInjectNMI = qemuDomainInjectNMI, /* 0.9.2 */
@ -14782,7 +14782,7 @@ static virDriver qemuDriver = {
.domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */ .domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */
.domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */ .domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */
.domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */ .domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */
.isAlive = qemuIsAlive, /* 0.9.8 */ .connectIsAlive = qemuIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */ .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */ .domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */
.domainGetBlockIoTune = qemuDomainGetBlockIoTune, /* 0.9.8 */ .domainGetBlockIoTune = qemuDomainGetBlockIoTune, /* 0.9.8 */
@ -14806,10 +14806,10 @@ static virDriver qemuDriver = {
static virStateDriver qemuStateDriver = { static virStateDriver qemuStateDriver = {
.name = "QEMU", .name = "QEMU",
.initialize = qemuStartup, .stateInitialize = qemuStartup,
.cleanup = qemuShutdown, .stateCleanup = qemuShutdown,
.reload = qemuReload, .stateReload = qemuReload,
.stop = qemuStop, .stateStop = qemuStop,
}; };
int qemuRegister(void) { int qemuRegister(void) {

12
src/qemu/qemu_process.c
View File

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

246
src/remote/remote_driver.c
View File

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

30
src/secret/secret_driver.c
View File

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

16
src/storage/storage_backend.c
View File

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

90
src/storage/storage_driver.c
View File

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

166
src/test/test_driver.c
View File

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

2
src/vbox/vbox_driver.c
View File

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

94
src/vbox/vbox_tmpl.c
View File

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

44
src/xen/xen_driver.c
View File

@ -213,7 +213,7 @@ xenInitialize(bool privileged ATTRIBUTE_UNUSED,
static virStateDriver state_driver = { static virStateDriver state_driver = {
.name = "Xen", .name = "Xen",
.initialize = xenInitialize, .stateInitialize = xenInitialize,
}; };
#endif #endif
@ -2330,17 +2330,17 @@ cleanup:
static virDriver xenUnifiedDriver = { static virDriver xenUnifiedDriver = {
.no = VIR_DRV_XEN_UNIFIED, .no = VIR_DRV_XEN_UNIFIED,
.name = "Xen", .name = "Xen",
.open = xenUnifiedOpen, /* 0.0.3 */ .connectOpen = xenUnifiedOpen, /* 0.0.3 */
.close = xenUnifiedClose, /* 0.0.3 */ .connectClose = xenUnifiedClose, /* 0.0.3 */
.supports_feature = xenUnifiedSupportsFeature, /* 0.3.2 */ .connectSupportsFeature = xenUnifiedSupportsFeature, /* 0.3.2 */
.type = xenUnifiedType, /* 0.0.3 */ .connectGetType = xenUnifiedType, /* 0.0.3 */
.version = xenUnifiedGetVersion, /* 0.0.3 */ .connectGetVersion = xenUnifiedGetVersion, /* 0.0.3 */
.getHostname = virGetHostname, /* 0.7.3 */ .connectGetHostname = virGetHostname, /* 0.7.3 */
.getMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */ .connectGetMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
.nodeGetInfo = xenUnifiedNodeGetInfo, /* 0.1.0 */ .nodeGetInfo = xenUnifiedNodeGetInfo, /* 0.1.0 */
.getCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */ .connectGetCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
.listDomains = xenUnifiedListDomains, /* 0.0.3 */ .connectListDomains = xenUnifiedListDomains, /* 0.0.3 */
.numOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */ .connectNumOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
.domainCreateXML = xenUnifiedDomainCreateXML, /* 0.0.3 */ .domainCreateXML = xenUnifiedDomainCreateXML, /* 0.0.3 */
.domainLookupByID = xenUnifiedDomainLookupByID, /* 0.0.3 */ .domainLookupByID = xenUnifiedDomainLookupByID, /* 0.0.3 */
.domainLookupByUUID = xenUnifiedDomainLookupByUUID, /* 0.0.5 */ .domainLookupByUUID = xenUnifiedDomainLookupByUUID, /* 0.0.5 */
@ -2373,10 +2373,10 @@ static virDriver xenUnifiedDriver = {
.domainGetVcpus = xenUnifiedDomainGetVcpus, /* 0.1.4 */ .domainGetVcpus = xenUnifiedDomainGetVcpus, /* 0.1.4 */
.domainGetMaxVcpus = xenUnifiedDomainGetMaxVcpus, /* 0.2.1 */ .domainGetMaxVcpus = xenUnifiedDomainGetMaxVcpus, /* 0.2.1 */
.domainGetXMLDesc = xenUnifiedDomainGetXMLDesc, /* 0.0.3 */ .domainGetXMLDesc = xenUnifiedDomainGetXMLDesc, /* 0.0.3 */
.domainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */ .connectDomainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */ .connectDomainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
.listDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */ .connectListDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
.numOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */ .connectNumOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
.domainCreate = xenUnifiedDomainCreate, /* 0.1.1 */ .domainCreate = xenUnifiedDomainCreate, /* 0.1.1 */
.domainCreateWithFlags = xenUnifiedDomainCreateWithFlags, /* 0.8.2 */ .domainCreateWithFlags = xenUnifiedDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenUnifiedDomainDefineXML, /* 0.1.1 */ .domainDefineXML = xenUnifiedDomainDefineXML, /* 0.1.1 */
@ -2402,20 +2402,20 @@ static virDriver xenUnifiedDriver = {
.domainBlockPeek = xenUnifiedDomainBlockPeek, /* 0.4.4 */ .domainBlockPeek = xenUnifiedDomainBlockPeek, /* 0.4.4 */
.nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, /* 0.3.3 */ .nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, /* 0.3.3 */
.nodeGetFreeMemory = xenUnifiedNodeGetFreeMemory, /* 0.3.3 */ .nodeGetFreeMemory = xenUnifiedNodeGetFreeMemory, /* 0.3.3 */
.domainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */ .connectDomainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */ .connectDomainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
.nodeDeviceDettach = xenUnifiedNodeDeviceDettach, /* 0.6.1 */ .nodeDeviceDettach = xenUnifiedNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = xenUnifiedNodeDeviceReAttach, /* 0.6.1 */ .nodeDeviceReAttach = xenUnifiedNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = xenUnifiedNodeDeviceReset, /* 0.6.1 */ .nodeDeviceReset = xenUnifiedNodeDeviceReset, /* 0.6.1 */
.isEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */ .connectIsEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
.isSecure = xenUnifiedIsSecure, /* 0.7.3 */ .connectIsSecure = xenUnifiedIsSecure, /* 0.7.3 */
.domainIsActive = xenUnifiedDomainIsActive, /* 0.7.3 */ .domainIsActive = xenUnifiedDomainIsActive, /* 0.7.3 */
.domainIsPersistent = xenUnifiedDomainIsPersistent, /* 0.7.3 */ .domainIsPersistent = xenUnifiedDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = xenUnifiedDomainIsUpdated, /* 0.8.6 */ .domainIsUpdated = xenUnifiedDomainIsUpdated, /* 0.8.6 */
.domainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */ .connectDomainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
.domainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */ .connectDomainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
.domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */ .domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */
.isAlive = xenUnifiedIsAlive, /* 0.9.8 */ .connectIsAlive = xenUnifiedIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */ .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */ .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 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 = { static virDriver xenapiDriver = {
.no = VIR_DRV_XENAPI, .no = VIR_DRV_XENAPI,
.name = "XenAPI", .name = "XenAPI",
.open = xenapiOpen, /* 0.8.0 */ .connectOpen = xenapiOpen, /* 0.8.0 */
.close = xenapiClose, /* 0.8.0 */ .connectClose = xenapiClose, /* 0.8.0 */
.supports_feature = xenapiSupportsFeature, /* 0.8.0 */ .connectSupportsFeature = xenapiSupportsFeature, /* 0.8.0 */
.type = xenapiType, /* 0.8.0 */ .connectGetType = xenapiType, /* 0.8.0 */
.version = xenapiGetVersion, /* 0.8.0 */ .connectGetVersion = xenapiGetVersion, /* 0.8.0 */
.getHostname = xenapiGetHostname, /* 0.8.0 */ .connectGetHostname = xenapiGetHostname, /* 0.8.0 */
.getMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */ .connectGetMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
.nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */ .nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */
.getCapabilities = xenapiGetCapabilities, /* 0.8.0 */ .connectGetCapabilities = xenapiGetCapabilities, /* 0.8.0 */
.listDomains = xenapiListDomains, /* 0.8.0 */ .connectListDomains = xenapiListDomains, /* 0.8.0 */
.numOfDomains = xenapiNumOfDomains, /* 0.8.0 */ .connectNumOfDomains = xenapiNumOfDomains, /* 0.8.0 */
.domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */ .domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */
.domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */ .domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */
.domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */ .domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */
@ -1968,8 +1968,8 @@ static virDriver xenapiDriver = {
.domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */ .domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */
.domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */ .domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */
.domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */ .domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */
.listDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */ .connectListDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
.numOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */ .connectNumOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
.domainCreate = xenapiDomainCreate, /* 0.8.0 */ .domainCreate = xenapiDomainCreate, /* 0.8.0 */
.domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */ .domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */ .domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */
@ -1981,7 +1981,7 @@ static virDriver xenapiDriver = {
.nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */ .nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */
.nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */ .nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */
.domainIsUpdated = xenapiDomainIsUpdated, /* 0.8.6 */ .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 = { static virSecretDriver fakeSecretDriver = {
.name = "fake_secret", .name = "fake_secret",
.open = NULL, .connectOpen = NULL,
.close = fakeSecretClose, .connectClose = fakeSecretClose,
.numOfSecrets = NULL, .connectNumOfSecrets = NULL,
.listSecrets = NULL, .connectListSecrets = NULL,
.lookupByUUID = NULL, .secretLookupByUUID = NULL,
.lookupByUsage = fakeSecretLookupByUsage, .secretLookupByUsage = fakeSecretLookupByUsage,
.defineXML = NULL, .secretDefineXML = NULL,
.getXMLDesc = NULL, .secretGetXMLDesc = NULL,
.setValue = NULL, .secretSetValue = NULL,
.getValue = fakeSecretGetValue, .secretGetValue = fakeSecretGetValue,
.undefine = NULL, .secretUndefine = NULL,
}; };
typedef enum { typedef enum {