break;
default:
- if ((supported = virDrvSupportsFeature(priv->conn, args->feature)) < 0)
+ if ((supported = virConnectSupportsFeature(priv->conn, args->feature)) < 0)
goto cleanup;
break;
}
}
ignored_functions = {
+ "virConnectSupportsFeature": "private function for remote access",
"virDomainMigrateFinish": "private function for migration",
"virDomainMigrateFinish2": "private function for migration",
"virDomainMigratePerform": "private function for migration",
"virDomainMigratePrepare3": "private function for migration",
"virDomainMigrateConfirm3": "private function for migration",
"virDomainMigratePrepareTunnel3": "private function for tunnelled migration",
- "virDrvSupportsFeature": "private function for remote access",
"DllMain": "specific function for Win32",
"virTypedParameterArrayValidate": "internal function in virtypedparam.c",
"virTypedParameterAssign": "internal function in virtypedparam.c",
$groups{$ingrp} = { apis => {}, drivers => {} };
}
} elsif ($ingrp) {
- if ($line =~ /^\s*vir(?:Drv|DevMon)(\w+)\s+(\w+);\s*$/) {
+ if ($line =~ /^\s*vir(?:Drv)(\w+)\s+(\w+);\s*$/) {
my $field = $2;
my $name = $1;
my $api;
if (exists $apis{"vir$name"}) {
$api = "vir$name";
- } elsif (exists $apis{"virConnect$name"}) {
- $api = "virConnect$name";
- } elsif (exists $apis{"virNode$name"}) {
- $api = "virNode$name";
} else {
die "driver $name does not have a public API";
}
my $openAuthVers = (0 * 1000 * 1000) + (4 * 1000) + 0;
foreach my $drv (keys %{$groups{"virDriver"}->{drivers}}) {
- my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"open"};
+ my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
my $openVers;
if ($openVersStr =~ /(\d+)\.(\d+)\.(\d+)/) {
$openVers = ($1 * 1000 * 1000) + ($2 * 1000) + $3;
}
# virConnectOpenReadOnly always matches virConnectOpen version
- $groups{"virDriver"}->{drivers}->{$drv}->{"openReadOnly"} =
- $groups{"virDriver"}->{drivers}->{$drv}->{"open"};
+ $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenReadOnly"} =
+ $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
# virConnectOpenAuth is always 0.4.0 if the driver existed
# before this time, otherwise it matches the version of
# the driver's virConnectOpen entry
if ($openVersStr eq "Y" ||
$openVers >= $openAuthVers) {
- $groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = $openVersStr;
+ $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = $openVersStr;
} else {
- $groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = "0.4.0";
+ $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = "0.4.0";
}
}
my $name = $1;
print "Bogus name $1\n";
$status = 1;
+ } elsif (/^\s*(virDrv\w+)\s+(\w+);\s*/) {
+ my $drv = $1;
+ my $field = $2;
+
+ my $tmp = $drv;
+ $tmp =~ s/virDrv//;
+ $tmp =~ s/^NWFilter/nwfilter/;
+ $tmp =~ s/^(\w)/lc $1/e;
+
+ unless ($tmp eq $field) {
+ print "Driver struct field $field should be named $tmp\n";
+ $status = 1;
+ }
}
}
virConnectPtr conn = obj;
if (conn->networkDriver)
- conn->networkDriver->close(conn);
+ conn->networkDriver->connectClose(conn);
if (conn->interfaceDriver)
- conn->interfaceDriver->close(conn);
+ conn->interfaceDriver->connectClose(conn);
if (conn->storageDriver)
- conn->storageDriver->close(conn);
+ conn->storageDriver->connectClose(conn);
if (conn->deviceMonitor)
- conn->deviceMonitor->close(conn);
+ conn->deviceMonitor->connectClose(conn);
if (conn->secretDriver)
- conn->secretDriver->close(conn);
+ conn->secretDriver->connectClose(conn);
if (conn->nwfilterDriver)
- conn->nwfilterDriver->close(conn);
+ conn->nwfilterDriver->connectClose(conn);
if (conn->driver)
- conn->driver->close(conn);
+ conn->driver->connectClose(conn);
virMutexLock(&conn->lock);
* != 0 Feature is supported.
* 0 Feature is not supported.
*/
-# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
- ((drv)->supports_feature ? \
- (drv)->supports_feature((conn), (feature)) > 0 : 0)
+# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
+ ((drv)->connectSupportsFeature ? \
+ (drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
typedef virDrvOpenStatus
(*virDrvConnectOpen) (virConnectPtr conn,
struct _virDriver {
int no; /* the number virDrvNo */
const char *name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
- virDrvConnectSupportsFeature supports_feature;
- virDrvConnectGetType type;
- virDrvConnectGetVersion version;
- virDrvConnectGetLibVersion libvirtVersion;
- virDrvConnectGetHostname getHostname;
- virDrvConnectGetSysinfo getSysinfo;
- virDrvConnectGetMaxVcpus getMaxVcpus;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+ virDrvConnectSupportsFeature connectSupportsFeature;
+ virDrvConnectGetType connectGetType;
+ virDrvConnectGetVersion connectGetVersion;
+ virDrvConnectGetLibVersion connectGetLibVersion;
+ virDrvConnectGetHostname connectGetHostname;
+ virDrvConnectGetSysinfo connectGetSysinfo;
+ virDrvConnectGetMaxVcpus connectGetMaxVcpus;
virDrvNodeGetInfo nodeGetInfo;
- virDrvConnectGetCapabilities getCapabilities;
- virDrvConnectListDomains listDomains;
- virDrvConnectNumOfDomains numOfDomains;
- virDrvConnectListAllDomains listAllDomains;
+ virDrvConnectGetCapabilities connectGetCapabilities;
+ virDrvConnectListDomains connectListDomains;
+ virDrvConnectNumOfDomains connectNumOfDomains;
+ virDrvConnectListAllDomains connectListAllDomains;
virDrvDomainCreateXML domainCreateXML;
virDrvDomainLookupByID domainLookupByID;
virDrvDomainLookupByUUID domainLookupByUUID;
virDrvDomainGetSecurityLabelList domainGetSecurityLabelList;
virDrvNodeGetSecurityModel nodeGetSecurityModel;
virDrvDomainGetXMLDesc domainGetXMLDesc;
- virDrvConnectDomainXMLFromNative domainXMLFromNative;
- virDrvConnectDomainXMLToNative domainXMLToNative;
- virDrvConnectListDefinedDomains listDefinedDomains;
- virDrvConnectNumOfDefinedDomains numOfDefinedDomains;
+ virDrvConnectDomainXMLFromNative connectDomainXMLFromNative;
+ virDrvConnectDomainXMLToNative connectDomainXMLToNative;
+ virDrvConnectListDefinedDomains connectListDefinedDomains;
+ virDrvConnectNumOfDefinedDomains connectNumOfDefinedDomains;
virDrvDomainCreate domainCreate;
virDrvDomainCreateWithFlags domainCreateWithFlags;
virDrvDomainDefineXML domainDefineXML;
virDrvNodeGetMemoryStats nodeGetMemoryStats;
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
virDrvNodeGetFreeMemory nodeGetFreeMemory;
- virDrvConnectDomainEventRegister domainEventRegister;
- virDrvConnectDomainEventDeregister domainEventDeregister;
+ virDrvConnectDomainEventRegister connectDomainEventRegister;
+ virDrvConnectDomainEventDeregister connectDomainEventDeregister;
virDrvDomainMigratePrepare2 domainMigratePrepare2;
virDrvDomainMigrateFinish2 domainMigrateFinish2;
virDrvNodeDeviceDettach nodeDeviceDettach;
virDrvNodeDeviceReAttach nodeDeviceReAttach;
virDrvNodeDeviceReset nodeDeviceReset;
virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
- virDrvConnectIsEncrypted isEncrypted;
- virDrvConnectIsSecure isSecure;
+ virDrvConnectIsEncrypted connectIsEncrypted;
+ virDrvConnectIsSecure connectIsSecure;
virDrvDomainIsActive domainIsActive;
virDrvDomainIsPersistent domainIsPersistent;
virDrvDomainIsUpdated domainIsUpdated;
- virDrvConnectCompareCPU cpuCompare;
- virDrvConnectBaselineCPU cpuBaseline;
+ virDrvConnectCompareCPU connectCompareCPU;
+ virDrvConnectBaselineCPU connectBaselineCPU;
virDrvDomainGetJobInfo domainGetJobInfo;
virDrvDomainGetJobStats domainGetJobStats;
virDrvDomainAbortJob domainAbortJob;
virDrvDomainMigrateSetCompressionCache domainMigrateSetCompressionCache;
virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed;
virDrvDomainMigrateSetMaxSpeed domainMigrateSetMaxSpeed;
- virDrvConnectDomainEventRegisterAny domainEventRegisterAny;
- virDrvConnectDomainEventDeregisterAny domainEventDeregisterAny;
+ virDrvConnectDomainEventRegisterAny connectDomainEventRegisterAny;
+ virDrvConnectDomainEventDeregisterAny connectDomainEventDeregisterAny;
virDrvDomainManagedSave domainManagedSave;
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
virDrvDomainSnapshotHasMetadata domainSnapshotHasMetadata;
virDrvDomainRevertToSnapshot domainRevertToSnapshot;
virDrvDomainSnapshotDelete domainSnapshotDelete;
- virDrvDomainQemuMonitorCommand qemuDomainMonitorCommand;
- virDrvDomainQemuAttach qemuDomainAttach;
- virDrvDomainQemuAgentCommand qemuDomainArbitraryAgentCommand;
+ virDrvDomainQemuMonitorCommand domainQemuMonitorCommand;
+ virDrvDomainQemuAttach domainQemuAttach;
+ virDrvDomainQemuAgentCommand domainQemuAgentCommand;
virDrvDomainOpenConsole domainOpenConsole;
virDrvDomainOpenChannel domainOpenChannel;
virDrvDomainOpenGraphics domainOpenGraphics;
virDrvDomainBlockPull domainBlockPull;
virDrvDomainBlockRebase domainBlockRebase;
virDrvDomainBlockCommit domainBlockCommit;
- virDrvConnectSetKeepAlive setKeepAlive;
- virDrvConnectIsAlive isAlive;
+ virDrvConnectSetKeepAlive connectSetKeepAlive;
+ virDrvConnectIsAlive connectIsAlive;
virDrvNodeSuspendForDuration nodeSuspendForDuration;
virDrvDomainSetBlockIoTune domainSetBlockIoTune;
virDrvDomainGetBlockIoTune domainGetBlockIoTune;
*/
struct _virNetworkDriver {
const char * name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
- virDrvConnectNumOfNetworks numOfNetworks;
- virDrvConnectListNetworks listNetworks;
- virDrvConnectNumOfDefinedNetworks numOfDefinedNetworks;
- virDrvConnectListDefinedNetworks listDefinedNetworks;
- virDrvConnectListAllNetworks listAllNetworks;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+ virDrvConnectNumOfNetworks connectNumOfNetworks;
+ virDrvConnectListNetworks connectListNetworks;
+ virDrvConnectNumOfDefinedNetworks connectNumOfDefinedNetworks;
+ virDrvConnectListDefinedNetworks connectListDefinedNetworks;
+ virDrvConnectListAllNetworks connectListAllNetworks;
virDrvNetworkLookupByUUID networkLookupByUUID;
virDrvNetworkLookupByName networkLookupByName;
virDrvNetworkCreateXML networkCreateXML;
*/
struct _virInterfaceDriver {
const char *name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
- virDrvConnectNumOfInterfaces numOfInterfaces;
- virDrvConnectListInterfaces listInterfaces;
- virDrvConnectNumOfDefinedInterfaces numOfDefinedInterfaces;
- virDrvConnectListDefinedInterfaces listDefinedInterfaces;
- virDrvConnectListAllInterfaces listAllInterfaces;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+ virDrvConnectNumOfInterfaces connectNumOfInterfaces;
+ virDrvConnectListInterfaces connectListInterfaces;
+ virDrvConnectNumOfDefinedInterfaces connectNumOfDefinedInterfaces;
+ virDrvConnectListDefinedInterfaces connectListDefinedInterfaces;
+ virDrvConnectListAllInterfaces connectListAllInterfaces;
virDrvInterfaceLookupByName interfaceLookupByName;
virDrvInterfaceLookupByMACString interfaceLookupByMACString;
virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
*/
struct _virStorageDriver {
const char * name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
-
- virDrvConnectNumOfStoragePools numOfPools;
- virDrvConnectListStoragePools listPools;
- virDrvConnectNumOfDefinedStoragePools numOfDefinedPools;
- virDrvConnectListDefinedStoragePools listDefinedPools;
- virDrvConnectListAllStoragePools listAllPools;
- virDrvConnectFindStoragePoolSources findPoolSources;
- virDrvStoragePoolLookupByName poolLookupByName;
- virDrvStoragePoolLookupByUUID poolLookupByUUID;
- virDrvStoragePoolLookupByVolume poolLookupByVolume;
- virDrvStoragePoolCreateXML poolCreateXML;
- virDrvStoragePoolDefineXML poolDefineXML;
- virDrvStoragePoolBuild poolBuild;
- virDrvStoragePoolUndefine poolUndefine;
- virDrvStoragePoolCreate poolCreate;
- virDrvStoragePoolDestroy poolDestroy;
- virDrvStoragePoolDelete poolDelete;
- virDrvStoragePoolRefresh poolRefresh;
- virDrvStoragePoolGetInfo poolGetInfo;
- virDrvStoragePoolGetXMLDesc poolGetXMLDesc;
- virDrvStoragePoolGetAutostart poolGetAutostart;
- virDrvStoragePoolSetAutostart poolSetAutostart;
- virDrvStoragePoolNumOfVolumes poolNumOfVolumes;
- virDrvStoragePoolListVolumes poolListVolumes;
- virDrvStoragePoolListAllVolumes poolListAllVolumes;
-
- virDrvStorageVolLookupByName volLookupByName;
- virDrvStorageVolLookupByKey volLookupByKey;
- virDrvStorageVolLookupByPath volLookupByPath;
- virDrvStorageVolCreateXML volCreateXML;
- virDrvStorageVolCreateXMLFrom volCreateXMLFrom;
- virDrvStorageVolDownload volDownload;
- virDrvStorageVolUpload volUpload;
- virDrvStorageVolDelete volDelete;
- virDrvStorageVolWipe volWipe;
- virDrvStorageVolWipePattern volWipePattern;
- virDrvStorageVolGetInfo volGetInfo;
- virDrvStorageVolGetXMLDesc volGetXMLDesc;
- virDrvStorageVolGetPath volGetPath;
- virDrvStorageVolResize volResize;
- virDrvStoragePoolIsActive poolIsActive;
- virDrvStoragePoolIsPersistent poolIsPersistent;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+
+ virDrvConnectNumOfStoragePools connectNumOfStoragePools;
+ virDrvConnectListStoragePools connectListStoragePools;
+ virDrvConnectNumOfDefinedStoragePools connectNumOfDefinedStoragePools;
+ virDrvConnectListDefinedStoragePools connectListDefinedStoragePools;
+ virDrvConnectListAllStoragePools connectListAllStoragePools;
+ virDrvConnectFindStoragePoolSources connectFindStoragePoolSources;
+ virDrvStoragePoolLookupByName storagePoolLookupByName;
+ virDrvStoragePoolLookupByUUID storagePoolLookupByUUID;
+ virDrvStoragePoolLookupByVolume storagePoolLookupByVolume;
+ virDrvStoragePoolCreateXML storagePoolCreateXML;
+ virDrvStoragePoolDefineXML storagePoolDefineXML;
+ virDrvStoragePoolBuild storagePoolBuild;
+ virDrvStoragePoolUndefine storagePoolUndefine;
+ virDrvStoragePoolCreate storagePoolCreate;
+ virDrvStoragePoolDestroy storagePoolDestroy;
+ virDrvStoragePoolDelete storagePoolDelete;
+ virDrvStoragePoolRefresh storagePoolRefresh;
+ virDrvStoragePoolGetInfo storagePoolGetInfo;
+ virDrvStoragePoolGetXMLDesc storagePoolGetXMLDesc;
+ virDrvStoragePoolGetAutostart storagePoolGetAutostart;
+ virDrvStoragePoolSetAutostart storagePoolSetAutostart;
+ virDrvStoragePoolNumOfVolumes storagePoolNumOfVolumes;
+ virDrvStoragePoolListVolumes storagePoolListVolumes;
+ virDrvStoragePoolListAllVolumes storagePoolListAllVolumes;
+
+ virDrvStorageVolLookupByName storageVolLookupByName;
+ virDrvStorageVolLookupByKey storageVolLookupByKey;
+ virDrvStorageVolLookupByPath storageVolLookupByPath;
+ virDrvStorageVolCreateXML storageVolCreateXML;
+ virDrvStorageVolCreateXMLFrom storageVolCreateXMLFrom;
+ virDrvStorageVolDownload storageVolDownload;
+ virDrvStorageVolUpload storageVolUpload;
+ virDrvStorageVolDelete storageVolDelete;
+ virDrvStorageVolWipe storageVolWipe;
+ virDrvStorageVolWipePattern storageVolWipePattern;
+ virDrvStorageVolGetInfo storageVolGetInfo;
+ virDrvStorageVolGetXMLDesc storageVolGetXMLDesc;
+ virDrvStorageVolGetPath storageVolGetPath;
+ virDrvStorageVolResize storageVolResize;
+ virDrvStoragePoolIsActive storagePoolIsActive;
+ virDrvStoragePoolIsPersistent storagePoolIsPersistent;
};
# ifdef WITH_LIBVIRTD
struct _virStateDriver {
const char *name;
- virDrvStateInitialize initialize;
- virDrvStateCleanup cleanup;
- virDrvStateReload reload;
- virDrvStateStop stop;
+ virDrvStateInitialize stateInitialize;
+ virDrvStateCleanup stateCleanup;
+ virDrvStateReload stateReload;
+ virDrvStateStop stateStop;
};
# endif
*/
struct _virDeviceMonitor {
const char * name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
- virDrvNodeNumOfDevices numOfDevices;
- virDrvNodeListDevices listDevices;
- virDrvConnectListAllNodeDevices listAllNodeDevices;
- virDrvNodeDeviceLookupByName deviceLookupByName;
- virDrvNodeDeviceLookupSCSIHostByWWN deviceLookupSCSIHostByWWN;
- virDrvNodeDeviceGetXMLDesc deviceGetXMLDesc;
- virDrvNodeDeviceGetParent deviceGetParent;
- virDrvNodeDeviceNumOfCaps deviceNumOfCaps;
- virDrvNodeDeviceListCaps deviceListCaps;
- virDrvNodeDeviceCreateXML deviceCreateXML;
- virDrvNodeDeviceDestroy deviceDestroy;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+ virDrvNodeNumOfDevices nodeNumOfDevices;
+ virDrvNodeListDevices nodeListDevices;
+ virDrvConnectListAllNodeDevices connectListAllNodeDevices;
+ virDrvNodeDeviceLookupByName nodeDeviceLookupByName;
+ virDrvNodeDeviceLookupSCSIHostByWWN nodeDeviceLookupSCSIHostByWWN;
+ virDrvNodeDeviceGetXMLDesc nodeDeviceGetXMLDesc;
+ virDrvNodeDeviceGetParent nodeDeviceGetParent;
+ virDrvNodeDeviceNumOfCaps nodeDeviceNumOfCaps;
+ virDrvNodeDeviceListCaps nodeDeviceListCaps;
+ virDrvNodeDeviceCreateXML nodeDeviceCreateXML;
+ virDrvNodeDeviceDestroy nodeDeviceDestroy;
};
enum {
*/
struct _virSecretDriver {
const char *name;
- virDrvConnectOpen open;
- virDrvConnectClose close;
-
- virDrvConnectNumOfSecrets numOfSecrets;
- virDrvConnectListSecrets listSecrets;
- virDrvConnectListAllSecrets listAllSecrets;
- virDrvSecretLookupByUUID lookupByUUID;
- virDrvSecretLookupByUsage lookupByUsage;
- virDrvSecretDefineXML defineXML;
- virDrvSecretGetXMLDesc getXMLDesc;
- virDrvSecretSetValue setValue;
- virDrvSecretGetValue getValue;
- virDrvSecretUndefine undefine;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
+
+ virDrvConnectNumOfSecrets connectNumOfSecrets;
+ virDrvConnectListSecrets connectListSecrets;
+ virDrvConnectListAllSecrets connectListAllSecrets;
+ virDrvSecretLookupByUUID secretLookupByUUID;
+ virDrvSecretLookupByUsage secretLookupByUsage;
+ virDrvSecretDefineXML secretDefineXML;
+ virDrvSecretGetXMLDesc secretGetXMLDesc;
+ virDrvSecretSetValue secretSetValue;
+ virDrvSecretGetValue secretGetValue;
+ virDrvSecretUndefine secretUndefine;
};
struct _virStreamDriver {
virDrvStreamSend streamSend;
virDrvStreamRecv streamRecv;
- virDrvStreamEventAddCallback streamAddCallback;
- virDrvStreamEventUpdateCallback streamUpdateCallback;
- virDrvStreamEventRemoveCallback streamRemoveCallback;
+ virDrvStreamEventAddCallback streamEventAddCallback;
+ virDrvStreamEventUpdateCallback streamEventUpdateCallback;
+ virDrvStreamEventRemoveCallback streamEventRemoveCallback;
virDrvStreamFinish streamFinish;
virDrvStreamAbort streamAbort;
};
*/
struct _virNWFilterDriver {
const char * name; /* the name of the driver */
- virDrvConnectOpen open;
- virDrvConnectClose close;
+ virDrvConnectOpen connectOpen;
+ virDrvConnectClose connectClose;
- virDrvConnectNumOfNWFilters numOfNWFilters;
- virDrvConnectListNWFilters listNWFilters;
- virDrvConnectListAllNWFilters listAllNWFilters;
+ virDrvConnectNumOfNWFilters connectNumOfNWFilters;
+ virDrvConnectListNWFilters connectListNWFilters;
+ virDrvConnectListAllNWFilters connectListAllNWFilters;
virDrvNWFilterLookupByName nwfilterLookupByName;
virDrvNWFilterLookupByUUID nwfilterLookupByUUID;
- virDrvNWFilterDefineXML defineXML;
- virDrvNWFilterUndefine undefine;
- virDrvNWFilterGetXMLDesc getXMLDesc;
+ virDrvNWFilterDefineXML nwfilterDefineXML;
+ virDrvNWFilterUndefine nwfilterUndefine;
+ virDrvNWFilterGetXMLDesc nwfilterGetXMLDesc;
};
static virDeviceMonitor esxDeviceMonitor = {
.name = "ESX",
- .open = esxDeviceOpen, /* 0.7.6 */
- .close = esxDeviceClose, /* 0.7.6 */
+ .connectOpen = esxDeviceOpen, /* 0.7.6 */
+ .connectClose = esxDeviceClose, /* 0.7.6 */
};
static virDriver esxDriver = {
.no = VIR_DRV_ESX,
.name = "ESX",
- .open = esxOpen, /* 0.7.0 */
- .close = esxClose, /* 0.7.0 */
- .supports_feature = esxSupportsFeature, /* 0.7.0 */
- .type = esxGetType, /* 0.7.0 */
- .version = esxGetVersion, /* 0.7.0 */
- .getHostname = esxGetHostname, /* 0.7.0 */
+ .connectOpen = esxOpen, /* 0.7.0 */
+ .connectClose = esxClose, /* 0.7.0 */
+ .connectSupportsFeature = esxSupportsFeature, /* 0.7.0 */
+ .connectGetType = esxGetType, /* 0.7.0 */
+ .connectGetVersion = esxGetVersion, /* 0.7.0 */
+ .connectGetHostname = esxGetHostname, /* 0.7.0 */
.nodeGetInfo = esxNodeGetInfo, /* 0.7.0 */
- .getCapabilities = esxGetCapabilities, /* 0.7.1 */
- .listDomains = esxListDomains, /* 0.7.0 */
- .numOfDomains = esxNumberOfDomains, /* 0.7.0 */
- .listAllDomains = esxListAllDomains, /* 0.10.2 */
+ .connectGetCapabilities = esxGetCapabilities, /* 0.7.1 */
+ .connectListDomains = esxListDomains, /* 0.7.0 */
+ .connectNumOfDomains = esxNumberOfDomains, /* 0.7.0 */
+ .connectListAllDomains = esxListAllDomains, /* 0.10.2 */
.domainLookupByID = esxDomainLookupByID, /* 0.7.0 */
.domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */
.domainLookupByName = esxDomainLookupByName, /* 0.7.0 */
.domainGetVcpusFlags = esxDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = esxDomainGetMaxVcpus, /* 0.7.0 */
.domainGetXMLDesc = esxDomainGetXMLDesc, /* 0.7.0 */
- .domainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
- .domainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
- .listDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
- .numOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
+ .connectDomainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
+ .connectDomainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
+ .connectListDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
+ .connectNumOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
.domainCreate = esxDomainCreate, /* 0.7.0 */
.domainCreateWithFlags = esxDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = esxDomainDefineXML, /* 0.7.2 */
.domainMigratePerform = esxDomainMigratePerform, /* 0.7.0 */
.domainMigrateFinish = esxDomainMigrateFinish, /* 0.7.0 */
.nodeGetFreeMemory = esxNodeGetFreeMemory, /* 0.7.2 */
- .isEncrypted = esxIsEncrypted, /* 0.7.3 */
- .isSecure = esxIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = esxIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = esxIsSecure, /* 0.7.3 */
.domainIsActive = esxDomainIsActive, /* 0.7.3 */
.domainIsPersistent = esxDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = esxDomainIsUpdated, /* 0.8.6 */
.domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */
.domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */
.domainSnapshotDelete = esxDomainSnapshotDelete, /* 0.8.0 */
- .isAlive = esxIsAlive, /* 0.9.8 */
+ .connectIsAlive = esxIsAlive, /* 0.9.8 */
};
static virInterfaceDriver esxInterfaceDriver = {
.name = "ESX",
- .open = esxInterfaceOpen, /* 0.7.6 */
- .close = esxInterfaceClose, /* 0.7.6 */
- .numOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
- .listInterfaces = esxListInterfaces, /* 0.10.0 */
- .numOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
- .listDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
+ .connectOpen = esxInterfaceOpen, /* 0.7.6 */
+ .connectClose = esxInterfaceClose, /* 0.7.6 */
+ .connectNumOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
+ .connectListInterfaces = esxListInterfaces, /* 0.10.0 */
+ .connectNumOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
+ .connectListDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
.interfaceLookupByName = esxInterfaceLookupByName, /* 0.10.0 */
.interfaceLookupByMACString = esxInterfaceLookupByMACString, /* 0.10.0 */
.interfaceGetXMLDesc = esxInterfaceGetXMLDesc, /* 0.10.0 */
static virNetworkDriver esxNetworkDriver = {
.name = "ESX",
- .open = esxNetworkOpen, /* 0.7.6 */
- .close = esxNetworkClose, /* 0.7.6 */
- .numOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
- .listNetworks = esxListNetworks, /* 0.10.0 */
- .numOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
- .listDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
+ .connectOpen = esxNetworkOpen, /* 0.7.6 */
+ .connectClose = esxNetworkClose, /* 0.7.6 */
+ .connectNumOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
+ .connectListNetworks = esxListNetworks, /* 0.10.0 */
+ .connectNumOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
+ .connectListDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
.networkLookupByUUID = esxNetworkLookupByUUID, /* 0.10.0 */
.networkLookupByName = esxNetworkLookupByName, /* 0.10.0 */
.networkDefineXML = esxNetworkDefineXML, /* 0.10.0 */
static virNWFilterDriver esxNWFilterDriver = {
.name = "ESX",
- .open = esxNWFilterOpen, /* 0.8.1 */
- .close = esxNWFilterClose, /* 0.8.1 */
+ .connectOpen = esxNWFilterOpen, /* 0.8.1 */
+ .connectClose = esxNWFilterClose, /* 0.8.1 */
};
static virSecretDriver esxSecretDriver = {
.name = "ESX",
- .open = esxSecretOpen, /* 0.7.6 */
- .close = esxSecretClose, /* 0.7.6 */
+ .connectOpen = esxSecretOpen, /* 0.7.6 */
+ .connectClose = esxSecretClose, /* 0.7.6 */
};
virStorageDriver esxStorageBackendISCSI = {
- .numOfPools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
- .listPools = esxStorageBackendISCSIListPools, /* 1.0.1 */
- .poolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
- .poolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
- .poolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
- .poolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
- .poolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
- .poolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
- .poolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
- .volLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
- .volLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
- .volLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
- .volCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
- .volCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
- .volGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
- .volDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
- .volWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
- .volGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
+ .connectNumOfStoragePools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
+ .connectListStoragePools = esxStorageBackendISCSIListPools, /* 1.0.1 */
+ .storagePoolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
+ .storagePoolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
+ .storagePoolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
+ .storagePoolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
+ .storagePoolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
+ .storagePoolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
+ .storagePoolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
+ .storageVolLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
+ .storageVolLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
+ .storageVolLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
+ .storageVolCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
+ .storageVolCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
+ .storageVolGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
+ .storageVolDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
+ .storageVolWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
+ .storageVolGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
};
virStorageDriver esxStorageBackendVMFS = {
- .numOfPools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
- .listPools = esxStorageBackendVMFSListPools, /* 0.8.2 */
- .poolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
- .poolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
- .poolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
- .poolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
- .poolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
- .poolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
- .poolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
- .volLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
- .volLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
- .volLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
- .volCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
- .volCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
- .volDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
- .volWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
- .volGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
- .volGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
- .volGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
+ .connectNumOfStoragePools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
+ .connectListStoragePools = esxStorageBackendVMFSListPools, /* 0.8.2 */
+ .storagePoolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
+ .storagePoolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
+ .storagePoolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
+ .storagePoolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
+ .storagePoolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
+ .storagePoolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
+ .storagePoolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
+ .storageVolLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
+ .storageVolLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
+ .storageVolLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
+ .storageVolCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
+ .storageVolCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
+ .storageVolDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
+ .storageVolWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
+ .storageVolGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
+ .storageVolGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
+ .storageVolGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
};
}
for (i = 0; i < LAST_BACKEND; ++i) {
- tmp = backends[i]->numOfPools(conn);
+ tmp = backends[i]->connectNumOfStoragePools(conn);
if (tmp < 0) {
return -1;
}
for (i = 0; i < LAST_BACKEND; ++i) {
- tmp = backends[i]->listPools(conn, &names[count], maxnames - count);
+ tmp = backends[i]->connectListStoragePools(conn, &names[count], maxnames - count);
if (tmp < 0) {
goto cleanup;
}
for (i = 0; i < LAST_BACKEND; ++i) {
- pool = backends[i]->poolLookupByName(conn, name);
+ pool = backends[i]->storagePoolLookupByName(conn, name);
if (pool != NULL) {
return pool;
/* invoke backend drive method to search all known pools */
for (i = 0; i < LAST_BACKEND; ++i) {
- pool = backends[i]->poolLookupByUUID(conn, uuid);
+ pool = backends[i]->storagePoolLookupByUUID(conn, uuid);
if (pool != NULL) {
return pool;
return -1;
}
- return backend->poolRefresh(pool, flags);
+ return backend->storagePoolRefresh(pool, flags);
}
return -1;
}
- return backend->poolGetInfo(pool, info);
+ return backend->storagePoolGetInfo(pool, info);
}
return NULL;
}
- return backend->poolGetXMLDesc(pool, flags);
+ return backend->storagePoolGetXMLDesc(pool, flags);
}
return -1;
}
- return backend->poolNumOfVolumes(pool);
+ return backend->storagePoolNumOfVolumes(pool);
}
return -1;
}
- return backend->poolListVolumes(pool, names, maxnames);
+ return backend->storagePoolListVolumes(pool, names, maxnames);
}
return NULL;
}
- return backend->volLookupByName(pool, name);
+ return backend->storageVolLookupByName(pool, name);
}
* iSCSI LUNs device path follows normal linux path convention
*/
if (STRPREFIX(path, "[")) {
- return backends[VMFS]->volLookupByPath(conn, path);
+ return backends[VMFS]->storageVolLookupByPath(conn, path);
} else if (STRPREFIX(path, "/")) {
- return backends[ISCSI]->volLookupByPath(conn, path);
+ return backends[ISCSI]->storageVolLookupByPath(conn, path);
} else {
virReportError(VIR_ERR_INVALID_ARG,
_("Unexpected volume path format: %s"), path);
}
for (i = 0; i < LAST_BACKEND; ++i) {
- volume = backends[i]->volLookupByKey(conn, key);
+ volume = backends[i]->storageVolLookupByKey(conn, key);
if (volume != NULL) {
return volume;
return NULL;
}
- return backend->volCreateXML(pool, xmldesc, flags);
+ return backend->storageVolCreateXML(pool, xmldesc, flags);
}
return NULL;
}
- return backend->volCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
+ return backend->storageVolCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
}
return -1;
}
- return backend->volDelete(volume, flags);
+ return backend->storageVolDelete(volume, flags);
}
return -1;
}
- return backend->volWipe(volume, flags);
+ return backend->storageVolWipe(volume, flags);
}
return -1;
}
- return backend->volGetInfo(volume, info);
+ return backend->storageVolGetInfo(volume, info);
}
return NULL;
}
- return backend->volGetXMLDesc(volume, flags);
+ return backend->storageVolGetXMLDesc(volume, flags);
}
return NULL;
}
- return backend->volGetPath(volume);
+ return backend->storageVolGetPath(volume);
}
static virStorageDriver esxStorageDriver = {
.name = "ESX",
- .open = esxStorageOpen, /* 0.7.6 */
- .close = esxStorageClose, /* 0.7.6 */
- .numOfPools = esxNumberOfStoragePools, /* 0.8.2 */
- .listPools = esxListStoragePools, /* 0.8.2 */
- .numOfDefinedPools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
- .listDefinedPools = esxListDefinedStoragePools, /* 0.8.2 */
- .poolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
- .poolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
- .poolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
- .poolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
- .poolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
- .poolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
- .poolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
- .poolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
- .poolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
- .poolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
- .volLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
- .volLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
- .volLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
- .volCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
- .volCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
- .volDelete = esxStorageVolumeDelete, /* 0.8.7 */
- .volWipe = esxStorageVolumeWipe, /* 0.8.7 */
- .volGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
- .volGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
- .volGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
- .poolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
- .poolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
+ .connectOpen = esxStorageOpen, /* 0.7.6 */
+ .connectClose = esxStorageClose, /* 0.7.6 */
+ .connectNumOfStoragePools = esxNumberOfStoragePools, /* 0.8.2 */
+ .connectListStoragePools = esxListStoragePools, /* 0.8.2 */
+ .connectNumOfDefinedStoragePools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
+ .connectListDefinedStoragePools = esxListDefinedStoragePools, /* 0.8.2 */
+ .storagePoolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
+ .storagePoolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
+ .storagePoolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
+ .storagePoolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
+ .storagePoolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
+ .storagePoolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
+ .storagePoolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
+ .storagePoolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
+ .storagePoolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
+ .storagePoolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
+ .storageVolLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
+ .storageVolLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
+ .storageVolLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
+ .storageVolCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
+ .storageVolCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
+ .storageVolDelete = esxStorageVolumeDelete, /* 0.8.7 */
+ .storageVolWipe = esxStorageVolumeWipe, /* 0.8.7 */
+ .storageVolGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
+ .storageVolGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
+ .storageVolGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
+ .storagePoolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
+ .storagePoolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
};
.streamRecv = virFDStreamRead,
.streamFinish = virFDStreamClose,
.streamAbort = virFDStreamAbort,
- .streamAddCallback = virFDStreamAddCallback,
- .streamUpdateCallback = virFDStreamUpdateCallback,
- .streamRemoveCallback = virFDStreamRemoveCallback
+ .streamEventAddCallback = virFDStreamAddCallback,
+ .streamEventUpdateCallback = virFDStreamUpdateCallback,
+ .streamEventRemoveCallback = virFDStreamRemoveCallback
};
static int virFDStreamOpenInternal(virStreamPtr st,
static virDeviceMonitor hypervDeviceMonitor = {
"Hyper-V",
- .open = hypervDeviceOpen, /* 0.9.5 */
- .close = hypervDeviceClose, /* 0.9.5 */
+ .connectOpen = hypervDeviceOpen, /* 0.9.5 */
+ .connectClose = hypervDeviceClose, /* 0.9.5 */
};
static virDriver hypervDriver = {
.no = VIR_DRV_HYPERV,
.name = "Hyper-V",
- .open = hypervOpen, /* 0.9.5 */
- .close = hypervClose, /* 0.9.5 */
- .type = hypervGetType, /* 0.9.5 */
- .getHostname = hypervGetHostname, /* 0.9.5 */
+ .connectOpen = hypervOpen, /* 0.9.5 */
+ .connectClose = hypervClose, /* 0.9.5 */
+ .connectGetType = hypervGetType, /* 0.9.5 */
+ .connectGetHostname = hypervGetHostname, /* 0.9.5 */
.nodeGetInfo = hypervNodeGetInfo, /* 0.9.5 */
- .listDomains = hypervListDomains, /* 0.9.5 */
- .numOfDomains = hypervNumberOfDomains, /* 0.9.5 */
- .listAllDomains = hypervListAllDomains, /* 0.10.2 */
+ .connectListDomains = hypervListDomains, /* 0.9.5 */
+ .connectNumOfDomains = hypervNumberOfDomains, /* 0.9.5 */
+ .connectListAllDomains = hypervListAllDomains, /* 0.10.2 */
.domainLookupByID = hypervDomainLookupByID, /* 0.9.5 */
.domainLookupByUUID = hypervDomainLookupByUUID, /* 0.9.5 */
.domainLookupByName = hypervDomainLookupByName, /* 0.9.5 */
.domainGetInfo = hypervDomainGetInfo, /* 0.9.5 */
.domainGetState = hypervDomainGetState, /* 0.9.5 */
.domainGetXMLDesc = hypervDomainGetXMLDesc, /* 0.9.5 */
- .listDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
- .numOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
+ .connectListDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
+ .connectNumOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
.domainCreate = hypervDomainCreate, /* 0.9.5 */
.domainCreateWithFlags = hypervDomainCreateWithFlags, /* 0.9.5 */
- .isEncrypted = hypervIsEncrypted, /* 0.9.5 */
- .isSecure = hypervIsSecure, /* 0.9.5 */
+ .connectIsEncrypted = hypervIsEncrypted, /* 0.9.5 */
+ .connectIsSecure = hypervIsSecure, /* 0.9.5 */
.domainIsActive = hypervDomainIsActive, /* 0.9.5 */
.domainIsPersistent = hypervDomainIsPersistent, /* 0.9.5 */
.domainIsUpdated = hypervDomainIsUpdated, /* 0.9.5 */
.domainManagedSave = hypervDomainManagedSave, /* 0.9.5 */
.domainHasManagedSaveImage = hypervDomainHasManagedSaveImage, /* 0.9.5 */
.domainManagedSaveRemove = hypervDomainManagedSaveRemove, /* 0.9.5 */
- .isAlive = hypervIsAlive, /* 0.9.8 */
+ .connectIsAlive = hypervIsAlive, /* 0.9.8 */
};
static virInterfaceDriver hypervInterfaceDriver = {
.name = "Hyper-V",
- .open = hypervInterfaceOpen, /* 0.9.5 */
- .close = hypervInterfaceClose, /* 0.9.5 */
+ .connectOpen = hypervInterfaceOpen, /* 0.9.5 */
+ .connectClose = hypervInterfaceClose, /* 0.9.5 */
};
static virNetworkDriver hypervNetworkDriver = {
.name = "Hyper-V",
- .open = hypervNetworkOpen, /* 0.9.5 */
- .close = hypervNetworkClose, /* 0.9.5 */
+ .connectOpen = hypervNetworkOpen, /* 0.9.5 */
+ .connectClose = hypervNetworkClose, /* 0.9.5 */
};
static virNWFilterDriver hypervNWFilterDriver = {
.name = "Hyper-V",
- .open = hypervNWFilterOpen, /* 0.9.5 */
- .close = hypervNWFilterClose, /* 0.9.5 */
+ .connectOpen = hypervNWFilterOpen, /* 0.9.5 */
+ .connectClose = hypervNWFilterClose, /* 0.9.5 */
};
static virSecretDriver hypervSecretDriver = {
.name = "Hyper-V",
- .open = hypervSecretOpen, /* 0.9.5 */
- .close = hypervSecretClose, /* 0.9.5 */
+ .connectOpen = hypervSecretOpen, /* 0.9.5 */
+ .connectClose = hypervSecretClose, /* 0.9.5 */
};
static virStorageDriver hypervStorageDriver = {
.name = "Hyper-V",
- .open = hypervStorageOpen, /* 0.9.5*/
- .close = hypervStorageClose, /* 0.9.5 */
+ .connectOpen = hypervStorageOpen, /* 0.9.5*/
+ .connectClose = hypervStorageClose, /* 0.9.5 */
};
static virInterfaceDriver interfaceDriver = {
"netcf",
- .open = interfaceOpenInterface, /* 0.7.0 */
- .close = interfaceCloseInterface, /* 0.7.0 */
- .numOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
- .listInterfaces = interfaceListInterfaces, /* 0.7.0 */
- .numOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
- .listDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
- .listAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
+ .connectOpen = interfaceOpenInterface, /* 0.7.0 */
+ .connectClose = interfaceCloseInterface, /* 0.7.0 */
+ .connectNumOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
+ .connectListInterfaces = interfaceListInterfaces, /* 0.7.0 */
+ .connectNumOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
+ .connectListDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
+ .connectListAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
.interfaceLookupByName = interfaceLookupByName, /* 0.7.0 */
.interfaceLookupByMACString = interfaceLookupByMACString, /* 0.7.0 */
.interfaceGetXMLDesc = interfaceGetXMLDesc, /* 0.7.0 */
static virInterfaceDriver udevIfaceDriver = {
"udev",
- .open = udevIfaceOpenInterface, /* 1.0.0 */
- .close = udevIfaceCloseInterface, /* 1.0.0 */
- .numOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
- .listInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
- .numOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
- .listDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
- .listAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
+ .connectOpen = udevIfaceOpenInterface, /* 1.0.0 */
+ .connectClose = udevIfaceCloseInterface, /* 1.0.0 */
+ .connectNumOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
+ .connectListInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
+ .connectNumOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
+ .connectListDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
+ .connectListAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
.interfaceLookupByName = udevIfaceLookupByName, /* 1.0.0 */
.interfaceLookupByMACString = udevIfaceLookupByMACString, /* 1.0.0 */
.interfaceIsActive = udevIfaceIsActive, /* 1.0.0 */
goto error;
}
- if (conn->driver->qemuDomainMonitorCommand) {
+ if (conn->driver->domainQemuMonitorCommand) {
int ret;
- ret = conn->driver->qemuDomainMonitorCommand(domain, cmd, result,
+ ret = conn->driver->domainQemuMonitorCommand(domain, cmd, result,
flags);
if (ret < 0)
goto error;
goto error;
}
- if (conn->driver->qemuDomainAttach) {
+ if (conn->driver->domainQemuAttach) {
virDomainPtr ret;
- ret = conn->driver->qemuDomainAttach(conn, pid_value, flags);
+ ret = conn->driver->domainQemuAttach(conn, pid_value, flags);
if (!ret)
goto error;
return ret;
conn = domain->conn;
- if (conn->driver->qemuDomainArbitraryAgentCommand) {
- return conn->driver->qemuDomainArbitraryAgentCommand(domain, cmd,
- timeout, flags);
+ if (conn->driver->domainQemuAgentCommand) {
+ return conn->driver->domainQemuAgentCommand(domain, cmd,
+ timeout, flags);
}
virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
return -1;
for (i = 0 ; i < virStateDriverTabCount ; i++) {
- if (virStateDriverTab[i]->initialize) {
+ if (virStateDriverTab[i]->stateInitialize) {
VIR_DEBUG("Running global init for %s state driver",
virStateDriverTab[i]->name);
- if (virStateDriverTab[i]->initialize(privileged,
- callback,
- opaque) < 0) {
+ if (virStateDriverTab[i]->stateInitialize(privileged,
+ callback,
+ opaque) < 0) {
VIR_ERROR(_("Initialization of %s state driver failed"),
virStateDriverTab[i]->name);
return -1;
int i, ret = 0;
for (i = 0 ; i < virStateDriverTabCount ; i++) {
- if (virStateDriverTab[i]->cleanup &&
- virStateDriverTab[i]->cleanup() < 0)
+ if (virStateDriverTab[i]->stateCleanup &&
+ virStateDriverTab[i]->stateCleanup() < 0)
ret = -1;
}
return ret;
int i, ret = 0;
for (i = 0 ; i < virStateDriverTabCount ; i++) {
- if (virStateDriverTab[i]->reload &&
- virStateDriverTab[i]->reload() < 0)
+ if (virStateDriverTab[i]->stateReload &&
+ virStateDriverTab[i]->stateReload() < 0)
ret = -1;
}
return ret;
int i, ret = 0;
for (i = 0 ; i < virStateDriverTabCount ; i++) {
- if (virStateDriverTab[i]->stop &&
- virStateDriverTab[i]->stop())
+ if (virStateDriverTab[i]->stateStop &&
+ virStateDriverTab[i]->stateStop())
ret = 1;
}
return ret;
}
VIR_DEBUG("trying driver %d (%s) ...", i, virDriverTab[i]->name);
- res = virDriverTab[i]->open(ret, auth, flags);
+ res = virDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("driver %d %s returned %s",
i, virDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
}
for (i = 0; i < virNetworkDriverTabCount; i++) {
- res = virNetworkDriverTab[i]->open(ret, auth, flags);
+ res = virNetworkDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("network driver %d %s returned %s",
i, virNetworkDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
}
for (i = 0; i < virInterfaceDriverTabCount; i++) {
- res = virInterfaceDriverTab[i]->open(ret, auth, flags);
+ res = virInterfaceDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("interface driver %d %s returned %s",
i, virInterfaceDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
/* Secondary driver for storage. Optional */
for (i = 0; i < virStorageDriverTabCount; i++) {
- res = virStorageDriverTab[i]->open(ret, auth, flags);
+ res = virStorageDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("storage driver %d %s returned %s",
i, virStorageDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
/* Node driver (optional) */
for (i = 0; i < virDeviceMonitorTabCount; i++) {
- res = virDeviceMonitorTab[i]->open(ret, auth, flags);
+ res = virDeviceMonitorTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("node driver %d %s returned %s",
i, virDeviceMonitorTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
/* Secret manipulation driver. Optional */
for (i = 0; i < virSecretDriverTabCount; i++) {
- res = virSecretDriverTab[i]->open(ret, auth, flags);
+ res = virSecretDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("secret driver %d %s returned %s",
i, virSecretDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
/* Network filter driver. Optional */
for (i = 0; i < virNWFilterDriverTabCount; i++) {
- res = virNWFilterDriverTab[i]->open(ret, auth, flags);
+ res = virNWFilterDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("nwfilter driver %d %s returned %s",
i, virNWFilterDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
* implementation of driver features in the remote case.
*/
int
-virDrvSupportsFeature(virConnectPtr conn, int feature)
+virConnectSupportsFeature(virConnectPtr conn, int feature)
{
int ret;
VIR_DEBUG("conn=%p, feature=%d", conn, feature);
return -1;
}
- if (!conn->driver->supports_feature)
+ if (!conn->driver->connectSupportsFeature)
ret = 0;
else
- ret = conn->driver->supports_feature(conn, feature);
+ ret = conn->driver->connectSupportsFeature(conn, feature);
if (ret < 0)
virDispatchError(conn);
return NULL;
}
- if (conn->driver->type) {
- ret = conn->driver->type(conn);
+ if (conn->driver->connectGetType) {
+ ret = conn->driver->connectGetType(conn);
if (ret) return ret;
}
return conn->driver->name;
virCheckNonNullArgGoto(hvVer, error);
- if (conn->driver->version) {
- int ret = conn->driver->version(conn, hvVer);
+ if (conn->driver->connectGetVersion) {
+ int ret = conn->driver->connectGetVersion(conn, hvVer);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(libVer, error);
- if (conn->driver->libvirtVersion) {
- ret = conn->driver->libvirtVersion(conn, libVer);
+ if (conn->driver->connectGetLibVersion) {
+ ret = conn->driver->connectGetLibVersion(conn, libVer);
if (ret < 0)
goto error;
return ret;
return NULL;
}
- if (conn->driver->getHostname) {
- char *ret = conn->driver->getHostname(conn);
+ if (conn->driver->connectGetHostname) {
+ char *ret = conn->driver->connectGetHostname(conn);
if (!ret)
goto error;
return ret;
return NULL;
}
- if (conn->driver->getSysinfo) {
- char *ret = conn->driver->getSysinfo(conn, flags);
+ if (conn->driver->connectGetSysinfo) {
+ char *ret = conn->driver->connectGetSysinfo(conn, flags);
if (!ret)
goto error;
return ret;
return -1;
}
- if (conn->driver->getMaxVcpus) {
- int ret = conn->driver->getMaxVcpus(conn, type);
+ if (conn->driver->connectGetMaxVcpus) {
+ int ret = conn->driver->connectGetMaxVcpus(conn, type);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(ids, error);
virCheckNonNegativeArgGoto(maxids, error);
- if (conn->driver->listDomains) {
- int ret = conn->driver->listDomains(conn, ids, maxids);
+ if (conn->driver->connectListDomains) {
+ int ret = conn->driver->connectListDomains(conn, ids, maxids);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->driver->numOfDomains) {
- int ret = conn->driver->numOfDomains(conn);
+ if (conn->driver->connectNumOfDomains) {
+ int ret = conn->driver->connectNumOfDomains(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(nativeFormat, error);
virCheckNonNullArgGoto(nativeConfig, error);
- if (conn->driver->domainXMLFromNative) {
+ if (conn->driver->connectDomainXMLFromNative) {
char *ret;
- ret = conn->driver->domainXMLFromNative(conn,
- nativeFormat,
- nativeConfig,
- flags);
+ ret = conn->driver->connectDomainXMLFromNative(conn,
+ nativeFormat,
+ nativeConfig,
+ flags);
if (!ret)
goto error;
return ret;
virCheckNonNullArgGoto(nativeFormat, error);
virCheckNonNullArgGoto(domainXml, error);
- if (conn->driver->domainXMLToNative) {
+ if (conn->driver->connectDomainXMLToNative) {
char *ret;
- ret = conn->driver->domainXMLToNative(conn,
- nativeFormat,
- domainXml,
- flags);
+ ret = conn->driver->connectDomainXMLToNative(conn,
+ nativeFormat,
+ domainXml,
+ flags);
if (!ret)
goto error;
return ret;
return NULL;
}
- if (conn->driver->getCapabilities) {
+ if (conn->driver->connectGetCapabilities) {
char *ret;
- ret = conn->driver->getCapabilities(conn);
+ ret = conn->driver->connectGetCapabilities(conn);
if (!ret)
goto error;
VIR_DEBUG("conn=%p ret=%s", conn, ret);
return -1;
}
- if (conn->driver->numOfDefinedDomains) {
+ if (conn->driver->connectNumOfDefinedDomains) {
int ret;
- ret = conn->driver->numOfDefinedDomains(conn);
+ ret = conn->driver->connectNumOfDefinedDomains(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->driver->listDefinedDomains) {
+ if (conn->driver->connectListDefinedDomains) {
int ret;
- ret = conn->driver->listDefinedDomains(conn, names, maxnames);
+ ret = conn->driver->connectListDefinedDomains(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->driver->listAllDomains) {
+ if (conn->driver->connectListAllDomains) {
int ret;
- ret = conn->driver->listAllDomains(conn, domains, flags);
+ ret = conn->driver->connectListAllDomains(conn, domains, flags);
if (ret < 0)
goto error;
return ret;
}
if (conn->networkDriver &&
- conn->networkDriver->listAllNetworks) {
+ conn->networkDriver->connectListAllNetworks) {
int ret;
- ret = conn->networkDriver->listAllNetworks(conn, nets, flags);
+ ret = conn->networkDriver->connectListAllNetworks(conn, nets, flags);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->networkDriver && conn->networkDriver->numOfNetworks) {
+ if (conn->networkDriver && conn->networkDriver->connectNumOfNetworks) {
int ret;
- ret = conn->networkDriver->numOfNetworks(conn);
+ ret = conn->networkDriver->connectNumOfNetworks(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->networkDriver && conn->networkDriver->listNetworks) {
+ if (conn->networkDriver && conn->networkDriver->connectListNetworks) {
int ret;
- ret = conn->networkDriver->listNetworks(conn, names, maxnames);
+ ret = conn->networkDriver->connectListNetworks(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->networkDriver && conn->networkDriver->numOfDefinedNetworks) {
+ if (conn->networkDriver && conn->networkDriver->connectNumOfDefinedNetworks) {
int ret;
- ret = conn->networkDriver->numOfDefinedNetworks(conn);
+ ret = conn->networkDriver->connectNumOfDefinedNetworks(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->networkDriver && conn->networkDriver->listDefinedNetworks) {
+ if (conn->networkDriver && conn->networkDriver->connectListDefinedNetworks) {
int ret;
- ret = conn->networkDriver->listDefinedNetworks(conn,
- names, maxnames);
+ ret = conn->networkDriver->connectListDefinedNetworks(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
}
if (conn->interfaceDriver &&
- conn->interfaceDriver->listAllInterfaces) {
+ conn->interfaceDriver->connectListAllInterfaces) {
int ret;
- ret = conn->interfaceDriver->listAllInterfaces(conn, ifaces, flags);
+ ret = conn->interfaceDriver->connectListAllInterfaces(conn, ifaces, flags);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->interfaceDriver && conn->interfaceDriver->numOfInterfaces) {
+ if (conn->interfaceDriver && conn->interfaceDriver->connectNumOfInterfaces) {
int ret;
- ret = conn->interfaceDriver->numOfInterfaces(conn);
+ ret = conn->interfaceDriver->connectNumOfInterfaces(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->interfaceDriver && conn->interfaceDriver->listInterfaces) {
+ if (conn->interfaceDriver && conn->interfaceDriver->connectListInterfaces) {
int ret;
- ret = conn->interfaceDriver->listInterfaces(conn, names, maxnames);
+ ret = conn->interfaceDriver->connectListInterfaces(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->interfaceDriver && conn->interfaceDriver->numOfDefinedInterfaces) {
+ if (conn->interfaceDriver && conn->interfaceDriver->connectNumOfDefinedInterfaces) {
int ret;
- ret = conn->interfaceDriver->numOfDefinedInterfaces(conn);
+ ret = conn->interfaceDriver->connectNumOfDefinedInterfaces(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->interfaceDriver && conn->interfaceDriver->listDefinedInterfaces) {
+ if (conn->interfaceDriver && conn->interfaceDriver->connectListDefinedInterfaces) {
int ret;
- ret = conn->interfaceDriver->listDefinedInterfaces(conn, names, maxnames);
+ ret = conn->interfaceDriver->connectListDefinedInterfaces(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
}
if (conn->storageDriver &&
- conn->storageDriver->listAllPools) {
+ conn->storageDriver->connectListAllStoragePools) {
int ret;
- ret = conn->storageDriver->listAllPools(conn, pools, flags);
+ ret = conn->storageDriver->connectListAllStoragePools(conn, pools, flags);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->storageDriver && conn->storageDriver->numOfPools) {
+ if (conn->storageDriver && conn->storageDriver->connectNumOfStoragePools) {
int ret;
- ret = conn->storageDriver->numOfPools(conn);
+ ret = conn->storageDriver->connectNumOfStoragePools(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->storageDriver && conn->storageDriver->listPools) {
+ if (conn->storageDriver && conn->storageDriver->connectListStoragePools) {
int ret;
- ret = conn->storageDriver->listPools(conn, names, maxnames);
+ ret = conn->storageDriver->connectListStoragePools(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->storageDriver && conn->storageDriver->numOfDefinedPools) {
+ if (conn->storageDriver && conn->storageDriver->connectNumOfDefinedStoragePools) {
int ret;
- ret = conn->storageDriver->numOfDefinedPools(conn);
+ ret = conn->storageDriver->connectNumOfDefinedStoragePools(conn);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->storageDriver && conn->storageDriver->listDefinedPools) {
+ if (conn->storageDriver && conn->storageDriver->connectListDefinedStoragePools) {
int ret;
- ret = conn->storageDriver->listDefinedPools(conn, names, maxnames);
+ ret = conn->storageDriver->connectListDefinedStoragePools(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->findPoolSources) {
+ if (conn->storageDriver && conn->storageDriver->connectFindStoragePoolSources) {
char *ret;
- ret = conn->storageDriver->findPoolSources(conn, type, srcSpec, flags);
+ ret = conn->storageDriver->connectFindStoragePoolSources(conn, type, srcSpec, flags);
if (!ret)
goto error;
return ret;
}
virCheckNonNullArgGoto(name, error);
- if (conn->storageDriver && conn->storageDriver->poolLookupByName) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolLookupByName) {
virStoragePoolPtr ret;
- ret = conn->storageDriver->poolLookupByName(conn, name);
+ ret = conn->storageDriver->storagePoolLookupByName(conn, name);
if (!ret)
goto error;
return ret;
}
virCheckNonNullArgGoto(uuid, error);
- if (conn->storageDriver && conn->storageDriver->poolLookupByUUID) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolLookupByUUID) {
virStoragePoolPtr ret;
- ret = conn->storageDriver->poolLookupByUUID(conn, uuid);
+ ret = conn->storageDriver->storagePoolLookupByUUID(conn, uuid);
if (!ret)
goto error;
return ret;
return NULL;
}
- if (vol->conn->storageDriver && vol->conn->storageDriver->poolLookupByVolume) {
+ if (vol->conn->storageDriver && vol->conn->storageDriver->storagePoolLookupByVolume) {
virStoragePoolPtr ret;
- ret = vol->conn->storageDriver->poolLookupByVolume(vol);
+ ret = vol->conn->storageDriver->storagePoolLookupByVolume(vol);
if (!ret)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolCreateXML) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolCreateXML) {
virStoragePoolPtr ret;
- ret = conn->storageDriver->poolCreateXML(conn, xmlDesc, flags);
+ ret = conn->storageDriver->storagePoolCreateXML(conn, xmlDesc, flags);
if (!ret)
goto error;
return ret;
}
virCheckNonNullArgGoto(xml, error);
- if (conn->storageDriver && conn->storageDriver->poolDefineXML) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolDefineXML) {
virStoragePoolPtr ret;
- ret = conn->storageDriver->poolDefineXML(conn, xml, flags);
+ ret = conn->storageDriver->storagePoolDefineXML(conn, xml, flags);
if (!ret)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolBuild) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolBuild) {
int ret;
- ret = conn->storageDriver->poolBuild(pool, flags);
+ ret = conn->storageDriver->storagePoolBuild(pool, flags);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolUndefine) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolUndefine) {
int ret;
- ret = conn->storageDriver->poolUndefine(pool);
+ ret = conn->storageDriver->storagePoolUndefine(pool);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolCreate) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolCreate) {
int ret;
- ret = conn->storageDriver->poolCreate(pool, flags);
+ ret = conn->storageDriver->storagePoolCreate(pool, flags);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolDestroy) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolDestroy) {
int ret;
- ret = conn->storageDriver->poolDestroy(pool);
+ ret = conn->storageDriver->storagePoolDestroy(pool);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolDelete) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolDelete) {
int ret;
- ret = conn->storageDriver->poolDelete(pool, flags);
+ ret = conn->storageDriver->storagePoolDelete(pool, flags);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->poolRefresh) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolRefresh) {
int ret;
- ret = conn->storageDriver->poolRefresh(pool, flags);
+ ret = conn->storageDriver->storagePoolRefresh(pool, flags);
if (ret < 0)
goto error;
return ret;
conn = pool->conn;
- if (conn->storageDriver->poolGetInfo) {
+ if (conn->storageDriver->storagePoolGetInfo) {
int ret;
- ret = conn->storageDriver->poolGetInfo(pool, info);
+ ret = conn->storageDriver->storagePoolGetInfo(pool, info);
if (ret < 0)
goto error;
return ret;
conn = pool->conn;
- if (conn->storageDriver && conn->storageDriver->poolGetXMLDesc) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolGetXMLDesc) {
char *ret;
- ret = conn->storageDriver->poolGetXMLDesc(pool, flags);
+ ret = conn->storageDriver->storagePoolGetXMLDesc(pool, flags);
if (!ret)
goto error;
return ret;
conn = pool->conn;
- if (conn->storageDriver && conn->storageDriver->poolGetAutostart) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolGetAutostart) {
int ret;
- ret = conn->storageDriver->poolGetAutostart(pool, autostart);
+ ret = conn->storageDriver->storagePoolGetAutostart(pool, autostart);
if (ret < 0)
goto error;
return ret;
conn = pool->conn;
- if (conn->storageDriver && conn->storageDriver->poolSetAutostart) {
+ if (conn->storageDriver && conn->storageDriver->storagePoolSetAutostart) {
int ret;
- ret = conn->storageDriver->poolSetAutostart(pool, autostart);
+ ret = conn->storageDriver->storagePoolSetAutostart(pool, autostart);
if (ret < 0)
goto error;
return ret;
}
if (pool->conn->storageDriver &&
- pool->conn->storageDriver->poolListAllVolumes) {
+ pool->conn->storageDriver->storagePoolListAllVolumes) {
int ret;
- ret = pool->conn->storageDriver->poolListAllVolumes(pool, vols, flags);
+ ret = pool->conn->storageDriver->storagePoolListAllVolumes(pool, vols, flags);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (pool->conn->storageDriver && pool->conn->storageDriver->poolNumOfVolumes) {
+ if (pool->conn->storageDriver && pool->conn->storageDriver->storagePoolNumOfVolumes) {
int ret;
- ret = pool->conn->storageDriver->poolNumOfVolumes(pool);
+ ret = pool->conn->storageDriver->storagePoolNumOfVolumes(pool);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (pool->conn->storageDriver && pool->conn->storageDriver->poolListVolumes) {
+ if (pool->conn->storageDriver && pool->conn->storageDriver->storagePoolListVolumes) {
int ret;
- ret = pool->conn->storageDriver->poolListVolumes(pool, names, maxnames);
+ ret = pool->conn->storageDriver->storagePoolListVolumes(pool, names, maxnames);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(name, error);
- if (pool->conn->storageDriver && pool->conn->storageDriver->volLookupByName) {
+ if (pool->conn->storageDriver && pool->conn->storageDriver->storageVolLookupByName) {
virStorageVolPtr ret;
- ret = pool->conn->storageDriver->volLookupByName(pool, name);
+ ret = pool->conn->storageDriver->storageVolLookupByName(pool, name);
if (!ret)
goto error;
return ret;
virCheckNonNullArgGoto(key, error);
- if (conn->storageDriver && conn->storageDriver->volLookupByKey) {
+ if (conn->storageDriver && conn->storageDriver->storageVolLookupByKey) {
virStorageVolPtr ret;
- ret = conn->storageDriver->volLookupByKey(conn, key);
+ ret = conn->storageDriver->storageVolLookupByKey(conn, key);
if (!ret)
goto error;
return ret;
}
virCheckNonNullArgGoto(path, error);
- if (conn->storageDriver && conn->storageDriver->volLookupByPath) {
+ if (conn->storageDriver && conn->storageDriver->storageVolLookupByPath) {
virStorageVolPtr ret;
- ret = conn->storageDriver->volLookupByPath(conn, path);
+ ret = conn->storageDriver->storageVolLookupByPath(conn, path);
if (!ret)
goto error;
return ret;
goto error;
}
- if (pool->conn->storageDriver && pool->conn->storageDriver->volCreateXML) {
+ if (pool->conn->storageDriver && pool->conn->storageDriver->storageVolCreateXML) {
virStorageVolPtr ret;
- ret = pool->conn->storageDriver->volCreateXML(pool, xmlDesc, flags);
+ ret = pool->conn->storageDriver->storageVolCreateXML(pool, xmlDesc, flags);
if (!ret)
goto error;
return ret;
}
if (pool->conn->storageDriver &&
- pool->conn->storageDriver->volCreateXMLFrom) {
+ pool->conn->storageDriver->storageVolCreateXMLFrom) {
virStorageVolPtr ret;
- ret = pool->conn->storageDriver->volCreateXMLFrom(pool, xmlDesc,
+ ret = pool->conn->storageDriver->storageVolCreateXMLFrom(pool, xmlDesc,
clonevol, flags);
if (!ret)
goto error;
}
if (vol->conn->storageDriver &&
- vol->conn->storageDriver->volDownload) {
+ vol->conn->storageDriver->storageVolDownload) {
int ret;
- ret = vol->conn->storageDriver->volDownload(vol,
+ ret = vol->conn->storageDriver->storageVolDownload(vol,
stream,
offset,
length,
}
if (vol->conn->storageDriver &&
- vol->conn->storageDriver->volUpload) {
+ vol->conn->storageDriver->storageVolUpload) {
int ret;
- ret = vol->conn->storageDriver->volUpload(vol,
+ ret = vol->conn->storageDriver->storageVolUpload(vol,
stream,
offset,
length,
goto error;
}
- if (conn->storageDriver && conn->storageDriver->volDelete) {
+ if (conn->storageDriver && conn->storageDriver->storageVolDelete) {
int ret;
- ret = conn->storageDriver->volDelete(vol, flags);
+ ret = conn->storageDriver->storageVolDelete(vol, flags);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->volWipe) {
+ if (conn->storageDriver && conn->storageDriver->storageVolWipe) {
int ret;
- ret = conn->storageDriver->volWipe(vol, flags);
+ ret = conn->storageDriver->storageVolWipe(vol, flags);
if (ret < 0) {
goto error;
}
goto error;
}
- if (conn->storageDriver && conn->storageDriver->volWipePattern) {
+ if (conn->storageDriver && conn->storageDriver->storageVolWipePattern) {
int ret;
- ret = conn->storageDriver->volWipePattern(vol, algorithm, flags);
+ ret = conn->storageDriver->storageVolWipePattern(vol, algorithm, flags);
if (ret < 0) {
goto error;
}
conn = vol->conn;
- if (conn->storageDriver->volGetInfo){
+ if (conn->storageDriver->storageVolGetInfo){
int ret;
- ret = conn->storageDriver->volGetInfo(vol, info);
+ ret = conn->storageDriver->storageVolGetInfo(vol, info);
if (ret < 0)
goto error;
return ret;
conn = vol->conn;
- if (conn->storageDriver && conn->storageDriver->volGetXMLDesc) {
+ if (conn->storageDriver && conn->storageDriver->storageVolGetXMLDesc) {
char *ret;
- ret = conn->storageDriver->volGetXMLDesc(vol, flags);
+ ret = conn->storageDriver->storageVolGetXMLDesc(vol, flags);
if (!ret)
goto error;
return ret;
conn = vol->conn;
- if (conn->storageDriver && conn->storageDriver->volGetPath) {
+ if (conn->storageDriver && conn->storageDriver->storageVolGetPath) {
char *ret;
- ret = conn->storageDriver->volGetPath(vol);
+ ret = conn->storageDriver->storageVolGetPath(vol);
if (!ret)
goto error;
return ret;
goto error;
}
- if (conn->storageDriver && conn->storageDriver->volResize) {
+ if (conn->storageDriver && conn->storageDriver->storageVolResize) {
int ret;
- ret = conn->storageDriver->volResize(vol, capacity, flags);
+ ret = conn->storageDriver->storageVolResize(vol, capacity, flags);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->deviceMonitor && conn->deviceMonitor->numOfDevices) {
+ if (conn->deviceMonitor && conn->deviceMonitor->nodeNumOfDevices) {
int ret;
- ret = conn->deviceMonitor->numOfDevices(conn, cap, flags);
+ ret = conn->deviceMonitor->nodeNumOfDevices(conn, cap, flags);
if (ret < 0)
goto error;
return ret;
}
if (conn->deviceMonitor &&
- conn->deviceMonitor->listAllNodeDevices) {
+ conn->deviceMonitor->connectListAllNodeDevices) {
int ret;
- ret = conn->deviceMonitor->listAllNodeDevices(conn, devices, flags);
+ ret = conn->deviceMonitor->connectListAllNodeDevices(conn, devices, flags);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->deviceMonitor && conn->deviceMonitor->listDevices) {
+ if (conn->deviceMonitor && conn->deviceMonitor->nodeListDevices) {
int ret;
- ret = conn->deviceMonitor->listDevices(conn, cap, names, maxnames, flags);
+ ret = conn->deviceMonitor->nodeListDevices(conn, cap, names, maxnames, flags);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(name, error);
- if (conn->deviceMonitor && conn->deviceMonitor->deviceLookupByName) {
+ if (conn->deviceMonitor && conn->deviceMonitor->nodeDeviceLookupByName) {
virNodeDevicePtr ret;
- ret = conn->deviceMonitor->deviceLookupByName(conn, name);
+ ret = conn->deviceMonitor->nodeDeviceLookupByName(conn, name);
if (!ret)
goto error;
return ret;
virCheckNonNullArgGoto(wwpn, error);
if (conn->deviceMonitor &&
- conn->deviceMonitor->deviceLookupSCSIHostByWWN) {
+ conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN) {
virNodeDevicePtr ret;
- ret = conn->deviceMonitor->deviceLookupSCSIHostByWWN(conn, wwnn,
+ ret = conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN(conn, wwnn,
wwpn, flags);
if (!ret)
goto error;
return NULL;
}
- if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceGetXMLDesc) {
+ if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetXMLDesc) {
char *ret;
- ret = dev->conn->deviceMonitor->deviceGetXMLDesc(dev, flags);
+ ret = dev->conn->deviceMonitor->nodeDeviceGetXMLDesc(dev, flags);
if (!ret)
goto error;
return ret;
}
if (!dev->parent) {
- if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceGetParent) {
- dev->parent = dev->conn->deviceMonitor->deviceGetParent(dev);
+ if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetParent) {
+ dev->parent = dev->conn->deviceMonitor->nodeDeviceGetParent(dev);
} else {
virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
virDispatchError(dev->conn);
return -1;
}
- if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceNumOfCaps) {
+ if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceNumOfCaps) {
int ret;
- ret = dev->conn->deviceMonitor->deviceNumOfCaps(dev);
+ ret = dev->conn->deviceMonitor->nodeDeviceNumOfCaps(dev);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceListCaps) {
+ if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceListCaps) {
int ret;
- ret = dev->conn->deviceMonitor->deviceListCaps(dev, names, maxnames);
+ ret = dev->conn->deviceMonitor->nodeDeviceListCaps(dev, names, maxnames);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(xmlDesc, error);
if (conn->deviceMonitor &&
- conn->deviceMonitor->deviceCreateXML) {
- virNodeDevicePtr dev = conn->deviceMonitor->deviceCreateXML(conn, xmlDesc, flags);
+ conn->deviceMonitor->nodeDeviceCreateXML) {
+ virNodeDevicePtr dev = conn->deviceMonitor->nodeDeviceCreateXML(conn, xmlDesc, flags);
if (dev == NULL)
goto error;
return dev;
}
if (dev->conn->deviceMonitor &&
- dev->conn->deviceMonitor->deviceDestroy) {
- int retval = dev->conn->deviceMonitor->deviceDestroy(dev);
+ dev->conn->deviceMonitor->nodeDeviceDestroy) {
+ int retval = dev->conn->deviceMonitor->nodeDeviceDestroy(dev);
if (retval < 0) {
goto error;
}
}
virCheckNonNullArgGoto(cb, error);
- if ((conn->driver) && (conn->driver->domainEventRegister)) {
+ if ((conn->driver) && (conn->driver->connectDomainEventRegister)) {
int ret;
- ret = conn->driver->domainEventRegister(conn, cb, opaque, freecb);
+ ret = conn->driver->connectDomainEventRegister(conn, cb, opaque, freecb);
if (ret < 0)
goto error;
return ret;
}
virCheckNonNullArgGoto(cb, error);
- if ((conn->driver) && (conn->driver->domainEventDeregister)) {
+ if ((conn->driver) && (conn->driver->connectDomainEventDeregister)) {
int ret;
- ret = conn->driver->domainEventDeregister(conn, cb);
+ ret = conn->driver->connectDomainEventDeregister(conn, cb);
if (ret < 0)
goto error;
return ret;
}
if (conn->secretDriver != NULL &&
- conn->secretDriver->numOfSecrets != NULL) {
+ conn->secretDriver->connectNumOfSecrets != NULL) {
int ret;
- ret = conn->secretDriver->numOfSecrets(conn);
+ ret = conn->secretDriver->connectNumOfSecrets(conn);
if (ret < 0)
goto error;
return ret;
}
if (conn->secretDriver &&
- conn->secretDriver->listAllSecrets) {
+ conn->secretDriver->connectListAllSecrets) {
int ret;
- ret = conn->secretDriver->listAllSecrets(conn, secrets, flags);
+ ret = conn->secretDriver->connectListAllSecrets(conn, secrets, flags);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(uuids, error);
virCheckNonNegativeArgGoto(maxuuids, error);
- if (conn->secretDriver != NULL && conn->secretDriver->listSecrets != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->connectListSecrets != NULL) {
int ret;
- ret = conn->secretDriver->listSecrets(conn, uuids, maxuuids);
+ ret = conn->secretDriver->connectListSecrets(conn, uuids, maxuuids);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(uuid, error);
if (conn->secretDriver &&
- conn->secretDriver->lookupByUUID) {
+ conn->secretDriver->secretLookupByUUID) {
virSecretPtr ret;
- ret = conn->secretDriver->lookupByUUID(conn, uuid);
+ ret = conn->secretDriver->secretLookupByUUID(conn, uuid);
if (!ret)
goto error;
return ret;
virCheckNonNullArgGoto(usageID, error);
if (conn->secretDriver &&
- conn->secretDriver->lookupByUsage) {
+ conn->secretDriver->secretLookupByUsage) {
virSecretPtr ret;
- ret = conn->secretDriver->lookupByUsage(conn, usageType, usageID);
+ ret = conn->secretDriver->secretLookupByUsage(conn, usageType, usageID);
if (!ret)
goto error;
return ret;
}
virCheckNonNullArgGoto(xml, error);
- if (conn->secretDriver != NULL && conn->secretDriver->defineXML != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->secretDefineXML != NULL) {
virSecretPtr ret;
- ret = conn->secretDriver->defineXML(conn, xml, flags);
+ ret = conn->secretDriver->secretDefineXML(conn, xml, flags);
if (ret == NULL)
goto error;
return ret;
}
conn = secret->conn;
- if (conn->secretDriver != NULL && conn->secretDriver->getXMLDesc != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->secretGetXMLDesc != NULL) {
char *ret;
- ret = conn->secretDriver->getXMLDesc(secret, flags);
+ ret = conn->secretDriver->secretGetXMLDesc(secret, flags);
if (ret == NULL)
goto error;
return ret;
}
virCheckNonNullArgGoto(value, error);
- if (conn->secretDriver != NULL && conn->secretDriver->setValue != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->secretSetValue != NULL) {
int ret;
- ret = conn->secretDriver->setValue(secret, value, value_size, flags);
+ ret = conn->secretDriver->secretSetValue(secret, value, value_size, flags);
if (ret < 0)
goto error;
return ret;
}
virCheckNonNullArgGoto(value_size, error);
- if (conn->secretDriver != NULL && conn->secretDriver->getValue != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->secretGetValue != NULL) {
unsigned char *ret;
- ret = conn->secretDriver->getValue(secret, value_size, flags, 0);
+ ret = conn->secretDriver->secretGetValue(secret, value_size, flags, 0);
if (ret == NULL)
goto error;
return ret;
goto error;
}
- if (conn->secretDriver != NULL && conn->secretDriver->undefine != NULL) {
+ if (conn->secretDriver != NULL && conn->secretDriver->secretUndefine != NULL) {
int ret;
- ret = conn->secretDriver->undefine(secret);
+ ret = conn->secretDriver->secretUndefine(secret);
if (ret < 0)
goto error;
return ret;
}
if (stream->driver &&
- stream->driver->streamAddCallback) {
+ stream->driver->streamEventAddCallback) {
int ret;
- ret = (stream->driver->streamAddCallback)(stream, events, cb, opaque, ff);
+ ret = (stream->driver->streamEventAddCallback)(stream, events, cb, opaque, ff);
if (ret < 0)
goto error;
return ret;
}
if (stream->driver &&
- stream->driver->streamUpdateCallback) {
+ stream->driver->streamEventUpdateCallback) {
int ret;
- ret = (stream->driver->streamUpdateCallback)(stream, events);
+ ret = (stream->driver->streamEventUpdateCallback)(stream, events);
if (ret < 0)
goto error;
return ret;
}
if (stream->driver &&
- stream->driver->streamRemoveCallback) {
+ stream->driver->streamEventRemoveCallback) {
int ret;
- ret = (stream->driver->streamRemoveCallback)(stream);
+ ret = (stream->driver->streamEventRemoveCallback)(stream);
if (ret < 0)
goto error;
return ret;
virDispatchError(NULL);
return -1;
}
- if (pool->conn->storageDriver->poolIsActive) {
+ if (pool->conn->storageDriver->storagePoolIsActive) {
int ret;
- ret = pool->conn->storageDriver->poolIsActive(pool);
+ ret = pool->conn->storageDriver->storagePoolIsActive(pool);
if (ret < 0)
goto error;
return ret;
virDispatchError(NULL);
return -1;
}
- if (pool->conn->storageDriver->poolIsPersistent) {
+ if (pool->conn->storageDriver->storagePoolIsPersistent) {
int ret;
- ret = pool->conn->storageDriver->poolIsPersistent(pool);
+ ret = pool->conn->storageDriver->storagePoolIsPersistent(pool);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->nwfilterDriver && conn->nwfilterDriver->numOfNWFilters) {
+ if (conn->nwfilterDriver && conn->nwfilterDriver->connectNumOfNWFilters) {
int ret;
- ret = conn->nwfilterDriver->numOfNWFilters(conn);
+ ret = conn->nwfilterDriver->connectNumOfNWFilters(conn);
if (ret < 0)
goto error;
return ret;
}
if (conn->nwfilterDriver &&
- conn->nwfilterDriver->listAllNWFilters) {
+ conn->nwfilterDriver->connectListAllNWFilters) {
int ret;
- ret = conn->nwfilterDriver->listAllNWFilters(conn, filters, flags);
+ ret = conn->nwfilterDriver->connectListAllNWFilters(conn, filters, flags);
if (ret < 0)
goto error;
return ret;
virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error);
- if (conn->nwfilterDriver && conn->nwfilterDriver->listNWFilters) {
+ if (conn->nwfilterDriver && conn->nwfilterDriver->connectListNWFilters) {
int ret;
- ret = conn->nwfilterDriver->listNWFilters(conn, names, maxnames);
+ ret = conn->nwfilterDriver->connectListNWFilters(conn, names, maxnames);
if (ret < 0)
goto error;
return ret;
goto error;
}
- if (conn->nwfilterDriver && conn->nwfilterDriver->defineXML) {
+ if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterDefineXML) {
virNWFilterPtr ret;
- ret = conn->nwfilterDriver->defineXML(conn, xmlDesc);
+ ret = conn->nwfilterDriver->nwfilterDefineXML(conn, xmlDesc);
if (!ret)
goto error;
return ret;
goto error;
}
- if (conn->nwfilterDriver && conn->nwfilterDriver->undefine) {
+ if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterUndefine) {
int ret;
- ret = conn->nwfilterDriver->undefine(nwfilter);
+ ret = conn->nwfilterDriver->nwfilterUndefine(nwfilter);
if (ret < 0)
goto error;
return ret;
conn = nwfilter->conn;
- if (conn->nwfilterDriver && conn->nwfilterDriver->getXMLDesc) {
+ if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterGetXMLDesc) {
char *ret;
- ret = conn->nwfilterDriver->getXMLDesc(nwfilter, flags);
+ ret = conn->nwfilterDriver->nwfilterGetXMLDesc(nwfilter, flags);
if (!ret)
goto error;
return ret;
virDispatchError(NULL);
return -1;
}
- if (conn->driver->isEncrypted) {
+ if (conn->driver->connectIsEncrypted) {
int ret;
- ret = conn->driver->isEncrypted(conn);
+ ret = conn->driver->connectIsEncrypted(conn);
if (ret < 0)
goto error;
return ret;
virDispatchError(NULL);
return -1;
}
- if (conn->driver->isSecure) {
+ if (conn->driver->connectIsSecure) {
int ret;
- ret = conn->driver->isSecure(conn);
+ ret = conn->driver->connectIsSecure(conn);
if (ret < 0)
goto error;
return ret;
}
virCheckNonNullArgGoto(xmlDesc, error);
- if (conn->driver->cpuCompare) {
+ if (conn->driver->connectCompareCPU) {
int ret;
- ret = conn->driver->cpuCompare(conn, xmlDesc, flags);
+ ret = conn->driver->connectCompareCPU(conn, xmlDesc, flags);
if (ret == VIR_CPU_COMPARE_ERROR)
goto error;
return ret;
}
virCheckNonNullArgGoto(xmlCPUs, error);
- if (conn->driver->cpuBaseline) {
+ if (conn->driver->connectBaselineCPU) {
char *cpu;
- cpu = conn->driver->cpuBaseline(conn, xmlCPUs, ncpus, flags);
+ cpu = conn->driver->connectBaselineCPU(conn, xmlCPUs, ncpus, flags);
if (!cpu)
goto error;
return cpu;
goto error;
}
- if ((conn->driver) && (conn->driver->domainEventRegisterAny)) {
+ if ((conn->driver) && (conn->driver->connectDomainEventRegisterAny)) {
int ret;
- ret = conn->driver->domainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb);
+ ret = conn->driver->connectDomainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb);
if (ret < 0)
goto error;
return ret;
}
virCheckNonNegativeArgGoto(callbackID, error);
- if ((conn->driver) && (conn->driver->domainEventDeregisterAny)) {
+ if ((conn->driver) && (conn->driver->connectDomainEventDeregisterAny)) {
int ret;
- ret = conn->driver->domainEventDeregisterAny(conn, callbackID);
+ ret = conn->driver->connectDomainEventDeregisterAny(conn, callbackID);
if (ret < 0)
goto error;
return ret;
return -1;
}
- if (conn->driver->setKeepAlive) {
- ret = conn->driver->setKeepAlive(conn, interval, count);
+ if (conn->driver->connectSetKeepAlive) {
+ ret = conn->driver->connectSetKeepAlive(conn, interval, count);
if (ret < 0)
goto error;
return ret;
virDispatchError(NULL);
return -1;
}
- if (conn->driver->isAlive) {
+ if (conn->driver->connectIsAlive) {
int ret;
- ret = conn->driver->isAlive(conn);
+ ret = conn->driver->connectIsAlive(conn);
if (ret < 0)
goto error;
return ret;
};
-int virDrvSupportsFeature (virConnectPtr conn, int feature);
+int virConnectSupportsFeature(virConnectPtr conn, int feature);
int virDomainMigratePrepare (virConnectPtr dconn,
char **cookie,
# libvirt_internal.h
+virConnectSupportsFeature;
virDomainMigrateBegin3;
virDomainMigrateConfirm3;
virDomainMigrateFinish;
virDomainMigratePrepare3;
virDomainMigratePrepareTunnel;
virDomainMigratePrepareTunnel3;
-virDrvSupportsFeature;
virRegisterDeviceMonitor;
virRegisterDriver;
virRegisterInterfaceDriver;
static virDriver libxlDriver = {
.no = VIR_DRV_LIBXL,
.name = "xenlight",
- .open = libxlOpen, /* 0.9.0 */
- .close = libxlClose, /* 0.9.0 */
- .type = libxlGetType, /* 0.9.0 */
- .version = libxlGetVersion, /* 0.9.0 */
- .getHostname = virGetHostname, /* 0.9.0 */
- .getMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
+ .connectOpen = libxlOpen, /* 0.9.0 */
+ .connectClose = libxlClose, /* 0.9.0 */
+ .connectGetType = libxlGetType, /* 0.9.0 */
+ .connectGetVersion = libxlGetVersion, /* 0.9.0 */
+ .connectGetHostname = virGetHostname, /* 0.9.0 */
+ .connectGetMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
.nodeGetInfo = libxlNodeGetInfo, /* 0.9.0 */
- .getCapabilities = libxlGetCapabilities, /* 0.9.0 */
- .listDomains = libxlListDomains, /* 0.9.0 */
- .numOfDomains = libxlNumDomains, /* 0.9.0 */
- .listAllDomains = libxlListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = libxlGetCapabilities, /* 0.9.0 */
+ .connectListDomains = libxlListDomains, /* 0.9.0 */
+ .connectNumOfDomains = libxlNumDomains, /* 0.9.0 */
+ .connectListAllDomains = libxlListAllDomains, /* 0.9.13 */
.domainCreateXML = libxlDomainCreateXML, /* 0.9.0 */
.domainLookupByID = libxlDomainLookupByID, /* 0.9.0 */
.domainLookupByUUID = libxlDomainLookupByUUID, /* 0.9.0 */
.domainPinVcpu = libxlDomainPinVcpu, /* 0.9.0 */
.domainGetVcpus = libxlDomainGetVcpus, /* 0.9.0 */
.domainGetXMLDesc = libxlDomainGetXMLDesc, /* 0.9.0 */
- .domainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
- .domainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
- .listDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
- .numOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
+ .connectDomainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
+ .connectDomainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
+ .connectListDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
+ .connectNumOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
.domainCreate = libxlDomainCreate, /* 0.9.0 */
.domainCreateWithFlags = libxlDomainCreateWithFlags, /* 0.9.0 */
.domainDefineXML = libxlDomainDefineXML, /* 0.9.0 */
.domainSetSchedulerParameters = libxlDomainSetSchedulerParameters, /* 0.9.0 */
.domainSetSchedulerParametersFlags = libxlDomainSetSchedulerParametersFlags, /* 0.9.2 */
.nodeGetFreeMemory = libxlNodeGetFreeMemory, /* 0.9.0 */
- .domainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
- .domainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
+ .connectDomainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
+ .connectDomainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
.domainManagedSave = libxlDomainManagedSave, /* 0.9.2 */
.domainHasManagedSaveImage = libxlDomainHasManagedSaveImage, /* 0.9.2 */
.domainManagedSaveRemove = libxlDomainManagedSaveRemove, /* 0.9.2 */
.domainIsActive = libxlDomainIsActive, /* 0.9.0 */
.domainIsPersistent = libxlDomainIsPersistent, /* 0.9.0 */
.domainIsUpdated = libxlDomainIsUpdated, /* 0.9.0 */
- .domainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
- .domainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
- .isAlive = libxlIsAlive, /* 0.9.8 */
+ .connectDomainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
+ .connectDomainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
+ .connectIsAlive = libxlIsAlive, /* 0.9.8 */
};
static virStateDriver libxlStateDriver = {
.name = "LIBXL",
- .initialize = libxlStartup,
- .cleanup = libxlShutdown,
- .reload = libxlReload,
+ .stateInitialize = libxlStartup,
+ .stateCleanup = libxlShutdown,
+ .stateReload = libxlReload,
};
static virDriver lxcDriver = {
.no = VIR_DRV_LXC,
.name = LXC_DRIVER_NAME,
- .open = lxcOpen, /* 0.4.2 */
- .close = lxcClose, /* 0.4.2 */
- .version = lxcVersion, /* 0.4.6 */
- .getHostname = virGetHostname, /* 0.6.3 */
- .getSysinfo = lxcGetSysinfo, /* 1.0.5 */
+ .connectOpen = lxcOpen, /* 0.4.2 */
+ .connectClose = lxcClose, /* 0.4.2 */
+ .connectGetVersion = lxcVersion, /* 0.4.6 */
+ .connectGetHostname = virGetHostname, /* 0.6.3 */
+ .connectGetSysinfo = lxcGetSysinfo, /* 1.0.5 */
.nodeGetInfo = nodeGetInfo, /* 0.6.5 */
- .getCapabilities = lxcGetCapabilities, /* 0.6.5 */
- .listDomains = lxcListDomains, /* 0.4.2 */
- .numOfDomains = lxcNumDomains, /* 0.4.2 */
- .listAllDomains = lxcListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = lxcGetCapabilities, /* 0.6.5 */
+ .connectListDomains = lxcListDomains, /* 0.4.2 */
+ .connectNumOfDomains = lxcNumDomains, /* 0.4.2 */
+ .connectListAllDomains = lxcListAllDomains, /* 0.9.13 */
.domainCreateXML = lxcDomainCreateAndStart, /* 0.4.4 */
.domainLookupByID = lxcDomainLookupByID, /* 0.4.2 */
.domainLookupByUUID = lxcDomainLookupByUUID, /* 0.4.2 */
.domainGetSecurityLabel = lxcDomainGetSecurityLabel, /* 0.9.10 */
.nodeGetSecurityModel = lxcNodeGetSecurityModel, /* 0.9.10 */
.domainGetXMLDesc = lxcDomainGetXMLDesc, /* 0.4.2 */
- .listDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
- .numOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
+ .connectListDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
+ .connectNumOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
.domainCreate = lxcDomainStart, /* 0.4.4 */
.domainCreateWithFlags = lxcDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = lxcDomainDefine, /* 0.4.2 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.6.5 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.6.5 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
- .domainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
- .domainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
- .isEncrypted = lxcIsEncrypted, /* 0.7.3 */
- .isSecure = lxcIsSecure, /* 0.7.3 */
+ .connectDomainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
+ .connectDomainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
+ .connectIsEncrypted = lxcIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = lxcIsSecure, /* 0.7.3 */
.domainIsActive = lxcDomainIsActive, /* 0.7.3 */
.domainIsPersistent = lxcDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = lxcDomainIsUpdated, /* 0.8.6 */
- .domainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
+ .connectDomainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
.domainOpenConsole = lxcDomainOpenConsole, /* 0.8.6 */
- .isAlive = lxcIsAlive, /* 0.9.8 */
+ .connectIsAlive = lxcIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
static virStateDriver lxcStateDriver = {
.name = LXC_DRIVER_NAME,
- .initialize = lxcStartup,
- .cleanup = lxcShutdown,
- .reload = lxcReload,
+ .stateInitialize = lxcStartup,
+ .stateCleanup = lxcShutdown,
+ .stateReload = lxcReload,
};
int lxcRegister(void)
static virNetworkDriver networkDriver = {
"Network",
- .open = networkOpenNetwork, /* 0.2.0 */
- .close = networkCloseNetwork, /* 0.2.0 */
- .numOfNetworks = networkNumNetworks, /* 0.2.0 */
- .listNetworks = networkListNetworks, /* 0.2.0 */
- .numOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
- .listDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
- .listAllNetworks = networkListAllNetworks, /* 0.10.2 */
+ .connectOpen = networkOpenNetwork, /* 0.2.0 */
+ .connectClose = networkCloseNetwork, /* 0.2.0 */
+ .connectNumOfNetworks = networkNumNetworks, /* 0.2.0 */
+ .connectListNetworks = networkListNetworks, /* 0.2.0 */
+ .connectNumOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
+ .connectListDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
+ .connectListAllNetworks = networkListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */
.networkLookupByName = networkLookupByName, /* 0.2.0 */
.networkCreateXML = networkCreate, /* 0.2.0 */
static virStateDriver networkStateDriver = {
.name = "Network",
- .initialize = networkStartup,
- .cleanup = networkShutdown,
- .reload = networkReload,
+ .stateInitialize = networkStartup,
+ .stateCleanup = networkShutdown,
+ .stateReload = networkReload,
};
int networkRegister(void) {
static virDeviceMonitor halDeviceMonitor = {
.name = "halDeviceMonitor",
- .open = halNodeDrvOpen, /* 0.5.0 */
- .close = halNodeDrvClose, /* 0.5.0 */
- .numOfDevices = nodeNumOfDevices, /* 0.5.0 */
- .listDevices = nodeListDevices, /* 0.5.0 */
- .listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
- .deviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
- .deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
- .deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
- .deviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
- .deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
- .deviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
- .deviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
- .deviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
+ .connectOpen = halNodeDrvOpen, /* 0.5.0 */
+ .connectClose = halNodeDrvClose, /* 0.5.0 */
+ .nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */
+ .nodeListDevices = nodeListDevices, /* 0.5.0 */
+ .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
+ .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
+ .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+ .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
+ .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
+ .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
+ .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
+ .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
+ .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
};
static virStateDriver halStateDriver = {
.name = "HAL",
- .initialize = halDeviceMonitorStartup, /* 0.5.0 */
- .cleanup = halDeviceMonitorShutdown, /* 0.5.0 */
- .reload = halDeviceMonitorReload, /* 0.5.0 */
+ .stateInitialize = halDeviceMonitorStartup, /* 0.5.0 */
+ .stateCleanup = halDeviceMonitorShutdown, /* 0.5.0 */
+ .stateReload = halDeviceMonitorReload, /* 0.5.0 */
};
int halNodeRegister(void)
static virDeviceMonitor udevDeviceMonitor = {
.name = "udevDeviceMonitor",
- .open = udevNodeDrvOpen, /* 0.7.3 */
- .close = udevNodeDrvClose, /* 0.7.3 */
- .numOfDevices = nodeNumOfDevices, /* 0.7.3 */
- .listDevices = nodeListDevices, /* 0.7.3 */
- .listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
- .deviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
- .deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
- .deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
- .deviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
- .deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
- .deviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
- .deviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
- .deviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
+ .connectOpen = udevNodeDrvOpen, /* 0.7.3 */
+ .connectClose = udevNodeDrvClose, /* 0.7.3 */
+ .nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
+ .nodeListDevices = nodeListDevices, /* 0.7.3 */
+ .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
+ .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
+ .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+ .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
+ .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
+ .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
+ .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
+ .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
+ .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
};
static virStateDriver udevStateDriver = {
.name = "udev",
- .initialize = udevDeviceMonitorStartup, /* 0.7.3 */
- .cleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
- .reload = udevDeviceMonitorReload, /* 0.7.3 */
+ .stateInitialize = udevDeviceMonitorStartup, /* 0.7.3 */
+ .stateCleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
+ .stateReload = udevDeviceMonitorReload, /* 0.7.3 */
};
int udevNodeRegister(void)
static virNWFilterDriver nwfilterDriver = {
.name = "nwfilter",
- .open = nwfilterOpen, /* 0.8.0 */
- .close = nwfilterClose, /* 0.8.0 */
- .numOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
- .listNWFilters = nwfilterListNWFilters, /* 0.8.0 */
- .listAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
+ .connectOpen = nwfilterOpen, /* 0.8.0 */
+ .connectClose = nwfilterClose, /* 0.8.0 */
+ .connectNumOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
+ .connectListNWFilters = nwfilterListNWFilters, /* 0.8.0 */
+ .connectListAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
.nwfilterLookupByName = nwfilterLookupByName, /* 0.8.0 */
.nwfilterLookupByUUID = nwfilterLookupByUUID, /* 0.8.0 */
- .defineXML = nwfilterDefine, /* 0.8.0 */
- .undefine = nwfilterUndefine, /* 0.8.0 */
- .getXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
+ .nwfilterDefineXML = nwfilterDefine, /* 0.8.0 */
+ .nwfilterUndefine = nwfilterUndefine, /* 0.8.0 */
+ .nwfilterGetXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
};
static virStateDriver stateDriver = {
.name = "NWFilter",
- .initialize = nwfilterDriverStartup,
- .cleanup = nwfilterDriverShutdown,
- .reload = nwfilterDriverReload,
+ .stateInitialize = nwfilterDriverStartup,
+ .stateCleanup = nwfilterDriverShutdown,
+ .stateReload = nwfilterDriverReload,
};
static virDriver openvzDriver = {
.no = VIR_DRV_OPENVZ,
.name = "OPENVZ",
- .open = openvzOpen, /* 0.3.1 */
- .close = openvzClose, /* 0.3.1 */
- .type = openvzGetType, /* 0.3.1 */
- .version = openvzGetVersion, /* 0.5.0 */
- .getHostname = virGetHostname, /* 0.9.12 */
- .getMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
+ .connectOpen = openvzOpen, /* 0.3.1 */
+ .connectClose = openvzClose, /* 0.3.1 */
+ .connectGetType = openvzGetType, /* 0.3.1 */
+ .connectGetVersion = openvzGetVersion, /* 0.5.0 */
+ .connectGetHostname = virGetHostname, /* 0.9.12 */
+ .connectGetMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
.nodeGetInfo = nodeGetInfo, /* 0.3.2 */
.nodeGetCPUStats = nodeGetCPUStats, /* 0.9.12 */
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.12 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.9.12 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.9.12 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
- .getCapabilities = openvzGetCapabilities, /* 0.4.6 */
- .listDomains = openvzListDomains, /* 0.3.1 */
- .numOfDomains = openvzNumDomains, /* 0.3.1 */
- .listAllDomains = openvzListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = openvzGetCapabilities, /* 0.4.6 */
+ .connectListDomains = openvzListDomains, /* 0.3.1 */
+ .connectNumOfDomains = openvzNumDomains, /* 0.3.1 */
+ .connectListAllDomains = openvzListAllDomains, /* 0.9.13 */
.domainCreateXML = openvzDomainCreateXML, /* 0.3.3 */
.domainLookupByID = openvzDomainLookupByID, /* 0.3.1 */
.domainLookupByUUID = openvzDomainLookupByUUID, /* 0.3.1 */
.domainGetVcpusFlags = openvzDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = openvzDomainGetMaxVcpus, /* 0.4.6 */
.domainGetXMLDesc = openvzDomainGetXMLDesc, /* 0.4.6 */
- .listDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
- .numOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
+ .connectListDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
+ .connectNumOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
.domainCreate = openvzDomainCreate, /* 0.3.1 */
.domainCreateWithFlags = openvzDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = openvzDomainDefineXML, /* 0.3.3 */
.domainGetAutostart = openvzDomainGetAutostart, /* 0.4.6 */
.domainSetAutostart = openvzDomainSetAutostart, /* 0.4.6 */
.domainInterfaceStats = openvzDomainInterfaceStats, /* 0.9.12 */
- .isEncrypted = openvzIsEncrypted, /* 0.7.3 */
- .isSecure = openvzIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = openvzIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = openvzIsSecure, /* 0.7.3 */
.domainIsActive = openvzDomainIsActive, /* 0.7.3 */
.domainIsPersistent = openvzDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = openvzDomainIsUpdated, /* 0.8.6 */
- .isAlive = openvzIsAlive, /* 0.9.8 */
+ .connectIsAlive = openvzIsAlive, /* 0.9.8 */
.domainUpdateDeviceFlags = openvzDomainUpdateDeviceFlags, /* 0.9.13 */
.domainGetHostname = openvzDomainGetHostname, /* 0.10.0 */
};
static virDriver parallelsDriver = {
.no = VIR_DRV_PARALLELS,
.name = "Parallels",
- .open = parallelsOpen, /* 0.10.0 */
- .close = parallelsClose, /* 0.10.0 */
- .version = parallelsGetVersion, /* 0.10.0 */
- .getHostname = virGetHostname, /* 0.10.0 */
+ .connectOpen = parallelsOpen, /* 0.10.0 */
+ .connectClose = parallelsClose, /* 0.10.0 */
+ .connectGetVersion = parallelsGetVersion, /* 0.10.0 */
+ .connectGetHostname = virGetHostname, /* 0.10.0 */
.nodeGetInfo = nodeGetInfo, /* 0.10.0 */
- .getCapabilities = parallelsGetCapabilities, /* 0.10.0 */
- .listDomains = parallelsListDomains, /* 0.10.0 */
- .numOfDomains = parallelsNumOfDomains, /* 0.10.0 */
- .listDefinedDomains = parallelsListDefinedDomains, /* 0.10.0 */
- .numOfDefinedDomains = parallelsNumOfDefinedDomains, /* 0.10.0 */
- .listAllDomains = parallelsListAllDomains, /* 0.10.0 */
+ .connectGetCapabilities = parallelsGetCapabilities, /* 0.10.0 */
+ .connectListDomains = parallelsListDomains, /* 0.10.0 */
+ .connectNumOfDomains = parallelsNumOfDomains, /* 0.10.0 */
+ .connectListDefinedDomains = parallelsListDefinedDomains, /* 0.10.0 */
+ .connectNumOfDefinedDomains = parallelsNumOfDefinedDomains, /* 0.10.0 */
+ .connectListAllDomains = parallelsListAllDomains, /* 0.10.0 */
.domainLookupByID = parallelsLookupDomainByID, /* 0.10.0 */
.domainLookupByUUID = parallelsLookupDomainByUUID, /* 0.10.0 */
.domainLookupByName = parallelsLookupDomainByName, /* 0.10.0 */
}
static virNetworkDriver parallelsNetworkDriver = {
"Parallels",
- .open = parallelsOpenNetwork, /* 1.0.1 */
- .close = parallelsCloseNetwork, /* 1.0.1 */
- .numOfNetworks = parallelsNumNetworks, /* 1.0.1 */
- .listNetworks = parallelsListNetworks, /* 1.0.1 */
- .numOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
- .listDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
- .listAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
+ .connectOpen = parallelsOpenNetwork, /* 1.0.1 */
+ .connectClose = parallelsCloseNetwork, /* 1.0.1 */
+ .connectNumOfNetworks = parallelsNumNetworks, /* 1.0.1 */
+ .connectListNetworks = parallelsListNetworks, /* 1.0.1 */
+ .connectNumOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
+ .connectListDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
+ .connectListAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
.networkLookupByUUID = parallelsNetworkLookupByUUID, /* 1.0.1 */
.networkLookupByName = parallelsNetworkLookupByName, /* 1.0.1 */
.networkGetXMLDesc = parallelsNetworkGetXMLDesc, /* 1.0.1 */
static virStorageDriver parallelsStorageDriver = {
.name = "Parallels",
- .open = parallelsStorageOpen, /* 0.10.0 */
- .close = parallelsStorageClose, /* 0.10.0 */
-
- .numOfPools = parallelsStorageNumPools, /* 0.10.0 */
- .listPools = parallelsStorageListPools, /* 0.10.0 */
- .numOfDefinedPools = parallelsStorageNumDefinedPools, /* 0.10.0 */
- .listDefinedPools = parallelsStorageListDefinedPools, /* 0.10.0 */
- .poolLookupByName = parallelsStoragePoolLookupByName, /* 0.10.0 */
- .poolLookupByUUID = parallelsStoragePoolLookupByUUID, /* 0.10.0 */
- .poolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
- .poolDefineXML = parallelsStoragePoolDefine, /* 0.10.0 */
- .poolUndefine = parallelsStoragePoolUndefine, /* 0.10.0 */
- .poolCreate = parallelsStoragePoolStart, /* 0.10.0 */
- .poolDestroy = parallelsStoragePoolDestroy, /* 0.10.0 */
- .poolRefresh = parallelsStoragePoolRefresh, /* 0.10.0 */
- .poolGetInfo = parallelsStoragePoolGetInfo, /* 0.10.0 */
- .poolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
- .poolGetAutostart = parallelsStoragePoolGetAutostart, /* 0.10.0 */
- .poolSetAutostart = parallelsStoragePoolSetAutostart, /* 0.10.0 */
- .poolNumOfVolumes = parallelsStoragePoolNumVolumes, /* 0.10.0 */
- .poolListVolumes = parallelsStoragePoolListVolumes, /* 0.10.0 */
-
- .volLookupByName = parallelsStorageVolumeLookupByName, /* 0.10.0 */
- .volLookupByKey = parallelsStorageVolumeLookupByKey, /* 0.10.0 */
- .volLookupByPath = parallelsStorageVolumeLookupByPath, /* 0.10.0 */
- .volCreateXML = parallelsStorageVolumeCreateXML, /* 0.10.0 */
- .volCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom, /* 0.10.0 */
- .volDelete = parallelsStorageVolumeDelete, /* 0.10.0 */
- .volGetInfo = parallelsStorageVolumeGetInfo, /* 0.10.0 */
- .volGetXMLDesc = parallelsStorageVolumeGetXMLDesc, /* 0.10.0 */
- .volGetPath = parallelsStorageVolumeGetPath, /* 0.10.0 */
- .poolIsActive = parallelsStoragePoolIsActive, /* 0.10.0 */
- .poolIsPersistent = parallelsStoragePoolIsPersistent, /* 0.10.0 */
+ .connectOpen = parallelsStorageOpen, /* 0.10.0 */
+ .connectClose = parallelsStorageClose, /* 0.10.0 */
+
+ .connectNumOfStoragePools = parallelsStorageNumPools, /* 0.10.0 */
+ .connectListStoragePools = parallelsStorageListPools, /* 0.10.0 */
+ .connectNumOfDefinedStoragePools = parallelsStorageNumDefinedPools, /* 0.10.0 */
+ .connectListDefinedStoragePools = parallelsStorageListDefinedPools, /* 0.10.0 */
+ .storagePoolLookupByName = parallelsStoragePoolLookupByName, /* 0.10.0 */
+ .storagePoolLookupByUUID = parallelsStoragePoolLookupByUUID, /* 0.10.0 */
+ .storagePoolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
+ .storagePoolDefineXML = parallelsStoragePoolDefine, /* 0.10.0 */
+ .storagePoolUndefine = parallelsStoragePoolUndefine, /* 0.10.0 */
+ .storagePoolCreate = parallelsStoragePoolStart, /* 0.10.0 */
+ .storagePoolDestroy = parallelsStoragePoolDestroy, /* 0.10.0 */
+ .storagePoolRefresh = parallelsStoragePoolRefresh, /* 0.10.0 */
+ .storagePoolGetInfo = parallelsStoragePoolGetInfo, /* 0.10.0 */
+ .storagePoolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
+ .storagePoolGetAutostart = parallelsStoragePoolGetAutostart, /* 0.10.0 */
+ .storagePoolSetAutostart = parallelsStoragePoolSetAutostart, /* 0.10.0 */
+ .storagePoolNumOfVolumes = parallelsStoragePoolNumVolumes, /* 0.10.0 */
+ .storagePoolListVolumes = parallelsStoragePoolListVolumes, /* 0.10.0 */
+
+ .storageVolLookupByName = parallelsStorageVolumeLookupByName, /* 0.10.0 */
+ .storageVolLookupByKey = parallelsStorageVolumeLookupByKey, /* 0.10.0 */
+ .storageVolLookupByPath = parallelsStorageVolumeLookupByPath, /* 0.10.0 */
+ .storageVolCreateXML = parallelsStorageVolumeCreateXML, /* 0.10.0 */
+ .storageVolCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom, /* 0.10.0 */
+ .storageVolDelete = parallelsStorageVolumeDelete, /* 0.10.0 */
+ .storageVolGetInfo = parallelsStorageVolumeGetInfo, /* 0.10.0 */
+ .storageVolGetXMLDesc = parallelsStorageVolumeGetXMLDesc, /* 0.10.0 */
+ .storageVolGetPath = parallelsStorageVolumeGetPath, /* 0.10.0 */
+ .storagePoolIsActive = parallelsStoragePoolIsActive, /* 0.10.0 */
+ .storagePoolIsPersistent = parallelsStoragePoolIsPersistent, /* 0.10.0 */
};
int
static virDriver phypDriver = {
.no = VIR_DRV_PHYP,
.name = "PHYP",
- .open = phypOpen, /* 0.7.0 */
- .close = phypClose, /* 0.7.0 */
- .getCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
- .listDomains = phypListDomains, /* 0.7.0 */
- .numOfDomains = phypNumDomains, /* 0.7.0 */
+ .connectOpen = phypOpen, /* 0.7.0 */
+ .connectClose = phypClose, /* 0.7.0 */
+ .connectGetCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
+ .connectListDomains = phypListDomains, /* 0.7.0 */
+ .connectNumOfDomains = phypNumDomains, /* 0.7.0 */
.domainCreateXML = phypDomainCreateAndStart, /* 0.7.3 */
.domainLookupByID = phypDomainLookupByID, /* 0.7.0 */
.domainLookupByName = phypDomainLookupByName, /* 0.7.0 */
.domainGetVcpusFlags = phypDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = phypGetLparCPUMAX, /* 0.7.3 */
.domainGetXMLDesc = phypDomainGetXMLDesc, /* 0.7.0 */
- .listDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
- .numOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
+ .connectListDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
+ .connectNumOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
.domainAttachDevice = phypAttachDevice, /* 0.8.2 */
- .isEncrypted = phypIsEncrypted, /* 0.7.3 */
- .isSecure = phypIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = phypIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = phypIsSecure, /* 0.7.3 */
.domainIsUpdated = phypIsUpdated, /* 0.8.6 */
- .isAlive = phypIsAlive, /* 0.9.8 */
+ .connectIsAlive = phypIsAlive, /* 0.9.8 */
};
static virStorageDriver phypStorageDriver = {
.name = "PHYP",
- .open = phypVIOSDriverOpen, /* 0.8.2 */
- .close = phypVIOSDriverClose, /* 0.8.2 */
-
- .numOfPools = phypNumOfStoragePools, /* 0.8.2 */
- .listPools = phypListStoragePools, /* 0.8.2 */
- .poolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
- .poolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
- .poolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
- .poolDestroy = phypDestroyStoragePool, /* 0.8.2 */
- .poolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
- .poolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
- .poolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
-
- .volLookupByName = phypVolumeLookupByName, /* 0.8.2 */
- .volLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
- .volCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
- .volGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
- .volGetPath = phypVolumeGetPath, /* 0.8.2 */
+ .connectOpen = phypVIOSDriverOpen, /* 0.8.2 */
+ .connectClose = phypVIOSDriverClose, /* 0.8.2 */
+
+ .connectNumOfStoragePools = phypNumOfStoragePools, /* 0.8.2 */
+ .connectListStoragePools = phypListStoragePools, /* 0.8.2 */
+ .storagePoolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
+ .storagePoolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
+ .storagePoolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
+ .storagePoolDestroy = phypDestroyStoragePool, /* 0.8.2 */
+ .storagePoolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
+ .storagePoolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
+ .storagePoolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
+
+ .storageVolLookupByName = phypVolumeLookupByName, /* 0.8.2 */
+ .storageVolLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
+ .storageVolCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
+ .storageVolGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
+ .storageVolGetPath = phypVolumeGetPath, /* 0.8.2 */
};
static virInterfaceDriver phypInterfaceDriver = {
.name = "PHYP",
- .open = phypVIOSDriverOpen, /* 0.9.1 */
- .close = phypVIOSDriverClose, /* 0.9.1 */
- .numOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
- .listInterfaces = phypListInterfaces, /* 0.9.1 */
+ .connectOpen = phypVIOSDriverOpen, /* 0.9.1 */
+ .connectClose = phypVIOSDriverClose, /* 0.9.1 */
+ .connectNumOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
+ .connectListInterfaces = phypListInterfaces, /* 0.9.1 */
.interfaceLookupByName = phypInterfaceLookupByName, /* 0.9.1 */
.interfaceDefineXML = phypInterfaceDefineXML, /* 0.9.1 */
.interfaceDestroy = phypInterfaceDestroy, /* 0.9.1 */
if (sec) {
char *base64 = NULL;
- secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
- VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+ secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
+ VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"),
}
if (sec) {
- secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
- VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+ secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
+ VIR_SECRET_GET_VALUE_INTERNAL_CALL);
if (secret == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("could not get the value of the secret for username %s"),
static virDriver qemuDriver = {
.no = VIR_DRV_QEMU,
.name = QEMU_DRIVER_NAME,
- .open = qemuOpen, /* 0.2.0 */
- .close = qemuClose, /* 0.2.0 */
- .supports_feature = qemuSupportsFeature, /* 0.5.0 */
- .type = qemuGetType, /* 0.2.0 */
- .version = qemuGetVersion, /* 0.2.0 */
- .getHostname = virGetHostname, /* 0.3.3 */
- .getSysinfo = qemuGetSysinfo, /* 0.8.8 */
- .getMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
+ .connectOpen = qemuOpen, /* 0.2.0 */
+ .connectClose = qemuClose, /* 0.2.0 */
+ .connectSupportsFeature = qemuSupportsFeature, /* 0.5.0 */
+ .connectGetType = qemuGetType, /* 0.2.0 */
+ .connectGetVersion = qemuGetVersion, /* 0.2.0 */
+ .connectGetHostname = virGetHostname, /* 0.3.3 */
+ .connectGetSysinfo = qemuGetSysinfo, /* 0.8.8 */
+ .connectGetMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
.nodeGetInfo = nodeGetInfo, /* 0.2.0 */
- .getCapabilities = qemuGetCapabilities, /* 0.2.1 */
- .listDomains = qemuListDomains, /* 0.2.0 */
- .numOfDomains = qemuNumDomains, /* 0.2.0 */
- .listAllDomains = qemuListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = qemuGetCapabilities, /* 0.2.1 */
+ .connectListDomains = qemuListDomains, /* 0.2.0 */
+ .connectNumOfDomains = qemuNumDomains, /* 0.2.0 */
+ .connectListAllDomains = qemuListAllDomains, /* 0.9.13 */
.domainCreateXML = qemuDomainCreate, /* 0.2.0 */
.domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */
.domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */
.domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */
.nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */
- .domainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
- .domainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
- .listDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
- .numOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
+ .connectDomainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
+ .connectDomainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
+ .connectListDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
+ .connectNumOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
.domainCreate = qemuDomainStart, /* 0.2.0 */
.domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = qemuDomainDefine, /* 0.2.0 */
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.4.4 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */
- .domainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
- .domainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
+ .connectDomainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
+ .connectDomainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
.domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */
.domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */
.nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */
.domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */
- .isEncrypted = qemuIsEncrypted, /* 0.7.3 */
- .isSecure = qemuIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = qemuIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = qemuIsSecure, /* 0.7.3 */
.domainIsActive = qemuDomainIsActive, /* 0.7.3 */
.domainIsPersistent = qemuDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = qemuDomainIsUpdated, /* 0.8.6 */
- .cpuCompare = qemuCPUCompare, /* 0.7.5 */
- .cpuBaseline = qemuCPUBaseline, /* 0.7.7 */
+ .connectCompareCPU = qemuCPUCompare, /* 0.7.5 */
+ .connectBaselineCPU = qemuCPUBaseline, /* 0.7.7 */
.domainGetJobInfo = qemuDomainGetJobInfo, /* 0.7.7 */
.domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */
.domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */
.domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */
.domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */
.domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */
- .domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
+ .connectDomainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
.domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */
.domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */
.domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */
.domainSnapshotHasMetadata = qemuDomainSnapshotHasMetadata, /* 0.9.13 */
.domainRevertToSnapshot = qemuDomainRevertToSnapshot, /* 0.8.0 */
.domainSnapshotDelete = qemuDomainSnapshotDelete, /* 0.8.0 */
- .qemuDomainMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
- .qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
- .qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
+ .domainQemuMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
+ .domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
+ .domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainOpenConsole = qemuDomainOpenConsole, /* 0.8.6 */
.domainOpenGraphics = qemuDomainOpenGraphics, /* 0.9.7 */
.domainInjectNMI = qemuDomainInjectNMI, /* 0.9.2 */
.domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */
.domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */
.domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */
- .isAlive = qemuIsAlive, /* 0.9.8 */
+ .connectIsAlive = qemuIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */
.domainGetBlockIoTune = qemuDomainGetBlockIoTune, /* 0.9.8 */
static virStateDriver qemuStateDriver = {
.name = "QEMU",
- .initialize = qemuStartup,
- .cleanup = qemuShutdown,
- .reload = qemuReload,
- .stop = qemuStop,
+ .stateInitialize = qemuStartup,
+ .stateCleanup = qemuShutdown,
+ .stateReload = qemuReload,
+ .stateStop = qemuStop,
};
int qemuRegister(void) {
}
if (conn->secretDriver == NULL ||
- conn->secretDriver->lookupByUUID == NULL ||
- conn->secretDriver->getValue == NULL) {
+ conn->secretDriver->secretLookupByUUID == NULL ||
+ conn->secretDriver->secretGetValue == NULL) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("secret storage not supported"));
goto cleanup;
goto cleanup;
}
- secret = conn->secretDriver->lookupByUUID(conn,
- enc->secrets[0]->uuid);
+ secret = conn->secretDriver->secretLookupByUUID(conn,
+ enc->secrets[0]->uuid);
if (secret == NULL)
goto cleanup;
- data = conn->secretDriver->getValue(secret, &size, 0,
- VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+ data = conn->secretDriver->secretGetValue(secret, &size, 0,
+ VIR_SECRET_GET_VALUE_INTERNAL_CALL);
virObjectUnref(secret);
if (data == NULL)
goto cleanup;
.streamSend = remoteStreamSend,
.streamFinish = remoteStreamFinish,
.streamAbort = remoteStreamAbort,
- .streamAddCallback = remoteStreamEventAddCallback,
- .streamUpdateCallback = remoteStreamEventUpdateCallback,
- .streamRemoveCallback = remoteStreamEventRemoveCallback,
+ .streamEventAddCallback = remoteStreamEventAddCallback,
+ .streamEventUpdateCallback = remoteStreamEventUpdateCallback,
+ .streamEventRemoveCallback = remoteStreamEventRemoveCallback,
};
static virDriver remote_driver = {
.no = VIR_DRV_REMOTE,
.name = "remote",
- .open = remoteOpen, /* 0.3.0 */
- .close = remoteClose, /* 0.3.0 */
- .supports_feature = remoteConnectSupportsFeature, /* 0.3.0 */
- .type = remoteConnectGetType, /* 0.3.0 */
- .version = remoteConnectGetVersion, /* 0.3.0 */
- .libvirtVersion = remoteConnectGetLibVersion, /* 0.7.3 */
- .getHostname = remoteConnectGetHostname, /* 0.3.0 */
- .getSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
- .getMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
+ .connectOpen = remoteOpen, /* 0.3.0 */
+ .connectClose = remoteClose, /* 0.3.0 */
+ .connectSupportsFeature = remoteConnectSupportsFeature, /* 0.3.0 */
+ .connectGetType = remoteConnectGetType, /* 0.3.0 */
+ .connectGetVersion = remoteConnectGetVersion, /* 0.3.0 */
+ .connectGetLibVersion = remoteConnectGetLibVersion, /* 0.7.3 */
+ .connectGetHostname = remoteConnectGetHostname, /* 0.3.0 */
+ .connectGetSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
+ .connectGetMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
.nodeGetInfo = remoteNodeGetInfo, /* 0.3.0 */
- .getCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
- .listDomains = remoteConnectListDomains, /* 0.3.0 */
- .numOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
- .listAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
+ .connectListDomains = remoteConnectListDomains, /* 0.3.0 */
+ .connectNumOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
+ .connectListAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
.domainCreateXML = remoteDomainCreateXML, /* 0.3.0 */
.domainLookupByID = remoteDomainLookupByID, /* 0.3.0 */
.domainLookupByUUID = remoteDomainLookupByUUID, /* 0.3.0 */
.domainGetSecurityLabelList = remoteDomainGetSecurityLabelList, /* 0.10.0 */
.nodeGetSecurityModel = remoteNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = remoteDomainGetXMLDesc, /* 0.3.0 */
- .domainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
- .domainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
- .listDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
- .numOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
+ .connectDomainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
+ .connectDomainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
+ .connectListDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
+ .connectNumOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
.domainCreate = remoteDomainCreate, /* 0.3.0 */
.domainCreateWithFlags = remoteDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = remoteDomainDefineXML, /* 0.3.0 */
.nodeGetMemoryStats = remoteNodeGetMemoryStats, /* 0.9.3 */
.nodeGetCellsFreeMemory = remoteNodeGetCellsFreeMemory, /* 0.3.3 */
.nodeGetFreeMemory = remoteNodeGetFreeMemory, /* 0.3.3 */
- .domainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
- .domainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
+ .connectDomainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
+ .connectDomainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
.domainMigratePrepare2 = remoteDomainMigratePrepare2, /* 0.5.0 */
.domainMigrateFinish2 = remoteDomainMigrateFinish2, /* 0.5.0 */
.nodeDeviceDettach = remoteNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = remoteNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = remoteNodeDeviceReset, /* 0.6.1 */
.domainMigratePrepareTunnel = remoteDomainMigratePrepareTunnel, /* 0.7.2 */
- .isEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
- .isSecure = remoteConnectIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = remoteConnectIsSecure, /* 0.7.3 */
.domainIsActive = remoteDomainIsActive, /* 0.7.3 */
.domainIsPersistent = remoteDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = remoteDomainIsUpdated, /* 0.8.6 */
- .cpuCompare = remoteConnectCompareCPU, /* 0.7.5 */
- .cpuBaseline = remoteConnectBaselineCPU, /* 0.7.7 */
+ .connectCompareCPU = remoteConnectCompareCPU, /* 0.7.5 */
+ .connectBaselineCPU = remoteConnectBaselineCPU, /* 0.7.7 */
.domainGetJobInfo = remoteDomainGetJobInfo, /* 0.7.7 */
.domainGetJobStats = remoteDomainGetJobStats, /* 1.0.3 */
.domainAbortJob = remoteDomainAbortJob, /* 0.7.7 */
.domainMigrateSetCompressionCache = remoteDomainMigrateSetCompressionCache, /* 1.0.3 */
.domainMigrateSetMaxSpeed = remoteDomainMigrateSetMaxSpeed, /* 0.9.0 */
.domainMigrateGetMaxSpeed = remoteDomainMigrateGetMaxSpeed, /* 0.9.5 */
- .domainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
+ .connectDomainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
.domainManagedSave = remoteDomainManagedSave, /* 0.8.0 */
.domainHasManagedSaveImage = remoteDomainHasManagedSaveImage, /* 0.8.0 */
.domainManagedSaveRemove = remoteDomainManagedSaveRemove, /* 0.8.0 */
.domainSnapshotIsCurrent = remoteDomainSnapshotIsCurrent, /* 0.9.13 */
.domainSnapshotHasMetadata = remoteDomainSnapshotHasMetadata, /* 0.9.13 */
.domainSnapshotDelete = remoteDomainSnapshotDelete, /* 0.8.0 */
- .qemuDomainMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
- .qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
- .qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
+ .domainQemuMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
+ .domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
+ .domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
.domainOpenConsole = remoteDomainOpenConsole, /* 0.8.6 */
.domainOpenChannel = remoteDomainOpenChannel, /* 1.0.2 */
.domainOpenGraphics = remoteDomainOpenGraphics, /* 0.9.7 */
.domainBlockPull = remoteDomainBlockPull, /* 0.9.4 */
.domainBlockRebase = remoteDomainBlockRebase, /* 0.9.10 */
.domainBlockCommit = remoteDomainBlockCommit, /* 0.10.2 */
- .setKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
- .isAlive = remoteIsAlive, /* 0.9.8 */
+ .connectSetKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
+ .connectIsAlive = remoteIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = remoteNodeSuspendForDuration, /* 0.9.8 */
.domainSetBlockIoTune = remoteDomainSetBlockIoTune, /* 0.9.8 */
.domainGetBlockIoTune = remoteDomainGetBlockIoTune, /* 0.9.8 */
static virNetworkDriver network_driver = {
.name = "remote",
- .open = remoteNetworkOpen, /* 0.3.0 */
- .close = remoteNetworkClose, /* 0.3.0 */
- .numOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
- .listNetworks = remoteConnectListNetworks, /* 0.3.0 */
- .numOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
- .listDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
- .listAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
+ .connectOpen = remoteNetworkOpen, /* 0.3.0 */
+ .connectClose = remoteNetworkClose, /* 0.3.0 */
+ .connectNumOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
+ .connectListNetworks = remoteConnectListNetworks, /* 0.3.0 */
+ .connectNumOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
+ .connectListDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
+ .connectListAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = remoteNetworkLookupByUUID, /* 0.3.0 */
.networkLookupByName = remoteNetworkLookupByName, /* 0.3.0 */
.networkCreateXML = remoteNetworkCreateXML, /* 0.3.0 */
static virInterfaceDriver interface_driver = {
.name = "remote",
- .open = remoteInterfaceOpen, /* 0.7.2 */
- .close = remoteInterfaceClose, /* 0.7.2 */
- .numOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
- .listInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
- .numOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
- .listDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
- .listAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
+ .connectOpen = remoteInterfaceOpen, /* 0.7.2 */
+ .connectClose = remoteInterfaceClose, /* 0.7.2 */
+ .connectNumOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
+ .connectListInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
+ .connectNumOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
+ .connectListDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
+ .connectListAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
.interfaceLookupByName = remoteInterfaceLookupByName, /* 0.7.2 */
.interfaceLookupByMACString = remoteInterfaceLookupByMACString, /* 0.7.2 */
.interfaceGetXMLDesc = remoteInterfaceGetXMLDesc, /* 0.7.2 */
static virStorageDriver storage_driver = {
.name = "remote",
- .open = remoteStorageOpen, /* 0.4.1 */
- .close = remoteStorageClose, /* 0.4.1 */
- .numOfPools = remoteConnectNumOfStoragePools, /* 0.4.1 */
- .listPools = remoteConnectListStoragePools, /* 0.4.1 */
- .numOfDefinedPools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
- .listDefinedPools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
- .listAllPools = remoteConnectListAllStoragePools, /* 0.10.2 */
- .findPoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
- .poolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
- .poolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
- .poolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
- .poolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
- .poolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
- .poolBuild = remoteStoragePoolBuild, /* 0.4.1 */
- .poolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
- .poolCreate = remoteStoragePoolCreate, /* 0.4.1 */
- .poolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
- .poolDelete = remoteStoragePoolDelete, /* 0.4.1 */
- .poolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
- .poolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
- .poolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
- .poolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
- .poolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
- .poolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
- .poolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
- .poolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
-
- .volLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
- .volLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
- .volLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
- .volCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
- .volCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
- .volDownload = remoteStorageVolDownload, /* 0.9.0 */
- .volUpload = remoteStorageVolUpload, /* 0.9.0 */
- .volDelete = remoteStorageVolDelete, /* 0.4.1 */
- .volWipe = remoteStorageVolWipe, /* 0.8.0 */
- .volWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
- .volGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
- .volGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
- .volGetPath = remoteStorageVolGetPath, /* 0.4.1 */
- .volResize = remoteStorageVolResize, /* 0.9.10 */
- .poolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
- .poolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
+ .connectOpen = remoteStorageOpen, /* 0.4.1 */
+ .connectClose = remoteStorageClose, /* 0.4.1 */
+ .connectNumOfStoragePools = remoteConnectNumOfStoragePools, /* 0.4.1 */
+ .connectListStoragePools = remoteConnectListStoragePools, /* 0.4.1 */
+ .connectNumOfDefinedStoragePools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
+ .connectListDefinedStoragePools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
+ .connectListAllStoragePools = remoteConnectListAllStoragePools, /* 0.10.2 */
+ .connectFindStoragePoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
+ .storagePoolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
+ .storagePoolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
+ .storagePoolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
+ .storagePoolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
+ .storagePoolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
+ .storagePoolBuild = remoteStoragePoolBuild, /* 0.4.1 */
+ .storagePoolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
+ .storagePoolCreate = remoteStoragePoolCreate, /* 0.4.1 */
+ .storagePoolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
+ .storagePoolDelete = remoteStoragePoolDelete, /* 0.4.1 */
+ .storagePoolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
+ .storagePoolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
+ .storagePoolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
+ .storagePoolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
+ .storagePoolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
+ .storagePoolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
+ .storagePoolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
+ .storagePoolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
+
+ .storageVolLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
+ .storageVolLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
+ .storageVolLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
+ .storageVolCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
+ .storageVolCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
+ .storageVolDownload = remoteStorageVolDownload, /* 0.9.0 */
+ .storageVolUpload = remoteStorageVolUpload, /* 0.9.0 */
+ .storageVolDelete = remoteStorageVolDelete, /* 0.4.1 */
+ .storageVolWipe = remoteStorageVolWipe, /* 0.8.0 */
+ .storageVolWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
+ .storageVolGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
+ .storageVolGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
+ .storageVolGetPath = remoteStorageVolGetPath, /* 0.4.1 */
+ .storageVolResize = remoteStorageVolResize, /* 0.9.10 */
+ .storagePoolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
+ .storagePoolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
};
static virSecretDriver secret_driver = {
.name = "remote",
- .open = remoteSecretOpen, /* 0.7.1 */
- .close = remoteSecretClose, /* 0.7.1 */
- .numOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
- .listSecrets = remoteConnectListSecrets, /* 0.7.1 */
- .listAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
- .lookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
- .lookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
- .defineXML = remoteSecretDefineXML, /* 0.7.1 */
- .getXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
- .setValue = remoteSecretSetValue, /* 0.7.1 */
- .getValue = remoteSecretGetValue, /* 0.7.1 */
- .undefine = remoteSecretUndefine /* 0.7.1 */
+ .connectOpen = remoteSecretOpen, /* 0.7.1 */
+ .connectClose = remoteSecretClose, /* 0.7.1 */
+ .connectNumOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
+ .connectListSecrets = remoteConnectListSecrets, /* 0.7.1 */
+ .connectListAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
+ .secretLookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
+ .secretLookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
+ .secretDefineXML = remoteSecretDefineXML, /* 0.7.1 */
+ .secretGetXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
+ .secretSetValue = remoteSecretSetValue, /* 0.7.1 */
+ .secretGetValue = remoteSecretGetValue, /* 0.7.1 */
+ .secretUndefine = remoteSecretUndefine /* 0.7.1 */
};
static virDeviceMonitor dev_monitor = {
.name = "remote",
- .open = remoteDevMonOpen, /* 0.5.0 */
- .close = remoteDevMonClose, /* 0.5.0 */
- .numOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
- .listDevices = remoteNodeListDevices, /* 0.5.0 */
- .listAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */
- .deviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
- .deviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
- .deviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
- .deviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
- .deviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
- .deviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
- .deviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
- .deviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
+ .connectOpen = remoteDevMonOpen, /* 0.5.0 */
+ .connectClose = remoteDevMonClose, /* 0.5.0 */
+ .nodeNumOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
+ .nodeListDevices = remoteNodeListDevices, /* 0.5.0 */
+ .connectListAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */
+ .nodeDeviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
+ .nodeDeviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+ .nodeDeviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
+ .nodeDeviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
+ .nodeDeviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
+ .nodeDeviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
+ .nodeDeviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
+ .nodeDeviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
};
static virNWFilterDriver nwfilter_driver = {
.name = "remote",
- .open = remoteNWFilterOpen, /* 0.8.0 */
- .close = remoteNWFilterClose, /* 0.8.0 */
+ .connectOpen = remoteNWFilterOpen, /* 0.8.0 */
+ .connectClose = remoteNWFilterClose, /* 0.8.0 */
.nwfilterLookupByUUID = remoteNWFilterLookupByUUID, /* 0.8.0 */
.nwfilterLookupByName = remoteNWFilterLookupByName, /* 0.8.0 */
- .getXMLDesc = remoteNWFilterGetXMLDesc, /* 0.8.0 */
- .defineXML = remoteNWFilterDefineXML, /* 0.8.0 */
- .undefine = remoteNWFilterUndefine, /* 0.8.0 */
- .numOfNWFilters = remoteConnectNumOfNWFilters, /* 0.8.0 */
- .listNWFilters = remoteConnectListNWFilters, /* 0.8.0 */
- .listAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */
+ .nwfilterGetXMLDesc = remoteNWFilterGetXMLDesc, /* 0.8.0 */
+ .nwfilterDefineXML = remoteNWFilterDefineXML, /* 0.8.0 */
+ .nwfilterUndefine = remoteNWFilterUndefine, /* 0.8.0 */
+ .connectNumOfNWFilters = remoteConnectNumOfNWFilters, /* 0.8.0 */
+ .connectListNWFilters = remoteConnectListNWFilters, /* 0.8.0 */
+ .connectListAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */
};
#ifdef WITH_LIBVIRTD
static virStateDriver state_driver = {
.name = "Remote",
- .initialize = remoteStartup,
+ .stateInitialize = remoteStartup,
};
#endif
static virSecretDriver secretDriver = {
.name = "secret",
- .open = secretOpen, /* 0.7.1 */
- .close = secretClose, /* 0.7.1 */
- .numOfSecrets = secretNumOfSecrets, /* 0.7.1 */
- .listSecrets = secretListSecrets, /* 0.7.1 */
- .listAllSecrets = secretListAllSecrets, /* 0.10.2 */
- .lookupByUUID = secretLookupByUUID, /* 0.7.1 */
- .lookupByUsage = secretLookupByUsage, /* 0.7.1 */
- .defineXML = secretDefineXML, /* 0.7.1 */
- .getXMLDesc = secretGetXMLDesc, /* 0.7.1 */
- .setValue = secretSetValue, /* 0.7.1 */
- .getValue = secretGetValue, /* 0.7.1 */
- .undefine = secretUndefine, /* 0.7.1 */
+ .connectOpen = secretOpen, /* 0.7.1 */
+ .connectClose = secretClose, /* 0.7.1 */
+ .connectNumOfSecrets = secretNumOfSecrets, /* 0.7.1 */
+ .connectListSecrets = secretListSecrets, /* 0.7.1 */
+ .connectListAllSecrets = secretListAllSecrets, /* 0.10.2 */
+ .secretLookupByUUID = secretLookupByUUID, /* 0.7.1 */
+ .secretLookupByUsage = secretLookupByUsage, /* 0.7.1 */
+ .secretDefineXML = secretDefineXML, /* 0.7.1 */
+ .secretGetXMLDesc = secretGetXMLDesc, /* 0.7.1 */
+ .secretSetValue = secretSetValue, /* 0.7.1 */
+ .secretGetValue = secretGetValue, /* 0.7.1 */
+ .secretUndefine = secretUndefine, /* 0.7.1 */
};
static virStateDriver stateDriver = {
.name = "Secret",
- .initialize = secretDriverStartup,
- .cleanup = secretDriverCleanup,
- .reload = secretDriverReload,
+ .stateInitialize = secretDriverStartup,
+ .stateCleanup = secretDriverCleanup,
+ .stateReload = secretDriverReload,
};
int
_("unable to generate uuid"));
return -1;
}
- tmp = conn->secretDriver->lookupByUUID(conn, uuid);
+ tmp = conn->secretDriver->secretLookupByUUID(conn, uuid);
if (tmp == NULL)
return 0;
int ret = -1;
if (conn->secretDriver == NULL ||
- conn->secretDriver->lookupByUUID == NULL ||
- conn->secretDriver->defineXML == NULL ||
- conn->secretDriver->setValue == NULL) {
+ conn->secretDriver->secretLookupByUUID == NULL ||
+ conn->secretDriver->secretDefineXML == NULL ||
+ conn->secretDriver->secretSetValue == NULL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("secret storage not supported"));
goto cleanup;
if (xml == NULL)
goto cleanup;
- secret = conn->secretDriver->defineXML(conn, xml, 0);
+ secret = conn->secretDriver->secretDefineXML(conn, xml, 0);
if (secret == NULL) {
VIR_FREE(xml);
goto cleanup;
if (virStorageGenerateQcowPassphrase(value) < 0)
goto cleanup;
- if (conn->secretDriver->setValue(secret, value, sizeof(value), 0) < 0)
+ if (conn->secretDriver->secretSetValue(secret, value, sizeof(value), 0) < 0)
goto cleanup;
enc_secret->type = VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE;
cleanup:
if (secret != NULL) {
if (ret != 0 &&
- conn->secretDriver->undefine != NULL)
- conn->secretDriver->undefine(secret);
+ conn->secretDriver->secretUndefine != NULL)
+ conn->secretDriver->secretUndefine(secret);
virSecretFree(secret);
}
virBufferFreeAndReset(&buf);
static virStorageDriver storageDriver = {
.name = "storage",
- .open = storageOpen, /* 0.4.0 */
- .close = storageClose, /* 0.4.0 */
- .numOfPools = storageNumPools, /* 0.4.0 */
- .listPools = storageListPools, /* 0.4.0 */
- .numOfDefinedPools = storageNumDefinedPools, /* 0.4.0 */
- .listDefinedPools = storageListDefinedPools, /* 0.4.0 */
- .listAllPools = storageListAllPools, /* 0.10.2 */
- .findPoolSources = storageFindPoolSources, /* 0.4.0 */
- .poolLookupByName = storagePoolLookupByName, /* 0.4.0 */
- .poolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
- .poolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
- .poolCreateXML = storagePoolCreate, /* 0.4.0 */
- .poolDefineXML = storagePoolDefine, /* 0.4.0 */
- .poolBuild = storagePoolBuild, /* 0.4.0 */
- .poolUndefine = storagePoolUndefine, /* 0.4.0 */
- .poolCreate = storagePoolStart, /* 0.4.0 */
- .poolDestroy = storagePoolDestroy, /* 0.4.0 */
- .poolDelete = storagePoolDelete, /* 0.4.0 */
- .poolRefresh = storagePoolRefresh, /* 0.4.0 */
- .poolGetInfo = storagePoolGetInfo, /* 0.4.0 */
- .poolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
- .poolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
- .poolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
- .poolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
- .poolListVolumes = storagePoolListVolumes, /* 0.4.0 */
- .poolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
-
- .volLookupByName = storageVolumeLookupByName, /* 0.4.0 */
- .volLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
- .volLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
- .volCreateXML = storageVolumeCreateXML, /* 0.4.0 */
- .volCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
- .volDownload = storageVolumeDownload, /* 0.9.0 */
- .volUpload = storageVolumeUpload, /* 0.9.0 */
- .volDelete = storageVolumeDelete, /* 0.4.0 */
- .volWipe = storageVolumeWipe, /* 0.8.0 */
- .volWipePattern = storageVolumeWipePattern, /* 0.9.10 */
- .volGetInfo = storageVolumeGetInfo, /* 0.4.0 */
- .volGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
- .volGetPath = storageVolumeGetPath, /* 0.4.0 */
- .volResize = storageVolumeResize, /* 0.9.10 */
-
- .poolIsActive = storagePoolIsActive, /* 0.7.3 */
- .poolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
+ .connectOpen = storageOpen, /* 0.4.0 */
+ .connectClose = storageClose, /* 0.4.0 */
+ .connectNumOfStoragePools = storageNumPools, /* 0.4.0 */
+ .connectListStoragePools = storageListPools, /* 0.4.0 */
+ .connectNumOfDefinedStoragePools = storageNumDefinedPools, /* 0.4.0 */
+ .connectListDefinedStoragePools = storageListDefinedPools, /* 0.4.0 */
+ .connectListAllStoragePools = storageListAllPools, /* 0.10.2 */
+ .connectFindStoragePoolSources = storageFindPoolSources, /* 0.4.0 */
+ .storagePoolLookupByName = storagePoolLookupByName, /* 0.4.0 */
+ .storagePoolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
+ .storagePoolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
+ .storagePoolCreateXML = storagePoolCreate, /* 0.4.0 */
+ .storagePoolDefineXML = storagePoolDefine, /* 0.4.0 */
+ .storagePoolBuild = storagePoolBuild, /* 0.4.0 */
+ .storagePoolUndefine = storagePoolUndefine, /* 0.4.0 */
+ .storagePoolCreate = storagePoolStart, /* 0.4.0 */
+ .storagePoolDestroy = storagePoolDestroy, /* 0.4.0 */
+ .storagePoolDelete = storagePoolDelete, /* 0.4.0 */
+ .storagePoolRefresh = storagePoolRefresh, /* 0.4.0 */
+ .storagePoolGetInfo = storagePoolGetInfo, /* 0.4.0 */
+ .storagePoolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
+ .storagePoolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
+ .storagePoolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
+ .storagePoolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
+ .storagePoolListVolumes = storagePoolListVolumes, /* 0.4.0 */
+ .storagePoolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
+
+ .storageVolLookupByName = storageVolumeLookupByName, /* 0.4.0 */
+ .storageVolLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
+ .storageVolLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
+ .storageVolCreateXML = storageVolumeCreateXML, /* 0.4.0 */
+ .storageVolCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
+ .storageVolDownload = storageVolumeDownload, /* 0.9.0 */
+ .storageVolUpload = storageVolumeUpload, /* 0.9.0 */
+ .storageVolDelete = storageVolumeDelete, /* 0.4.0 */
+ .storageVolWipe = storageVolumeWipe, /* 0.8.0 */
+ .storageVolWipePattern = storageVolumeWipePattern, /* 0.9.10 */
+ .storageVolGetInfo = storageVolumeGetInfo, /* 0.4.0 */
+ .storageVolGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
+ .storageVolGetPath = storageVolumeGetPath, /* 0.4.0 */
+ .storageVolResize = storageVolumeResize, /* 0.9.10 */
+
+ .storagePoolIsActive = storagePoolIsActive, /* 0.7.3 */
+ .storagePoolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
};
static virStateDriver stateDriver = {
.name = "Storage",
- .initialize = storageDriverStartup,
- .cleanup = storageDriverShutdown,
- .reload = storageDriverReload,
+ .stateInitialize = storageDriverStartup,
+ .stateCleanup = storageDriverShutdown,
+ .stateReload = storageDriverReload,
};
int storageRegister(void) {
static virDriver testDriver = {
.no = VIR_DRV_TEST,
.name = "Test",
- .open = testOpen, /* 0.1.1 */
- .close = testClose, /* 0.1.1 */
- .version = testGetVersion, /* 0.1.1 */
- .getHostname = virGetHostname, /* 0.6.3 */
- .getMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
+ .connectOpen = testOpen, /* 0.1.1 */
+ .connectClose = testClose, /* 0.1.1 */
+ .connectGetVersion = testGetVersion, /* 0.1.1 */
+ .connectGetHostname = virGetHostname, /* 0.6.3 */
+ .connectGetMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
.nodeGetInfo = testNodeGetInfo, /* 0.1.1 */
- .getCapabilities = testGetCapabilities, /* 0.2.1 */
- .listDomains = testListDomains, /* 0.1.1 */
- .numOfDomains = testNumOfDomains, /* 0.1.1 */
- .listAllDomains = testListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = testGetCapabilities, /* 0.2.1 */
+ .connectListDomains = testListDomains, /* 0.1.1 */
+ .connectNumOfDomains = testNumOfDomains, /* 0.1.1 */
+ .connectListAllDomains = testListAllDomains, /* 0.9.13 */
.domainCreateXML = testDomainCreateXML, /* 0.1.4 */
.domainLookupByID = testLookupDomainByID, /* 0.1.1 */
.domainLookupByUUID = testLookupDomainByUUID, /* 0.1.1 */
.domainGetVcpus = testDomainGetVcpus, /* 0.7.3 */
.domainGetMaxVcpus = testDomainGetMaxVcpus, /* 0.7.3 */
.domainGetXMLDesc = testDomainGetXMLDesc, /* 0.1.4 */
- .listDefinedDomains = testListDefinedDomains, /* 0.1.11 */
- .numOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
+ .connectListDefinedDomains = testListDefinedDomains, /* 0.1.11 */
+ .connectNumOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
.domainCreate = testDomainCreate, /* 0.1.11 */
.domainCreateWithFlags = testDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = testDomainDefineXML, /* 0.1.11 */
.domainBlockStats = testDomainBlockStats, /* 0.7.0 */
.domainInterfaceStats = testDomainInterfaceStats, /* 0.7.0 */
.nodeGetCellsFreeMemory = testNodeGetCellsFreeMemory, /* 0.4.2 */
- .domainEventRegister = testDomainEventRegister, /* 0.6.0 */
- .domainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
- .isEncrypted = testIsEncrypted, /* 0.7.3 */
- .isSecure = testIsSecure, /* 0.7.3 */
+ .connectDomainEventRegister = testDomainEventRegister, /* 0.6.0 */
+ .connectDomainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
+ .connectIsEncrypted = testIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = testIsSecure, /* 0.7.3 */
.domainIsActive = testDomainIsActive, /* 0.7.3 */
.domainIsPersistent = testDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = testDomainIsUpdated, /* 0.8.6 */
- .domainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
- .isAlive = testIsAlive, /* 0.9.8 */
+ .connectDomainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
+ .connectIsAlive = testIsAlive, /* 0.9.8 */
.nodeGetCPUMap = testNodeGetCPUMap, /* 1.0.0 */
.domainScreenshot = testDomainScreenshot, /* 1.0.5 */
};
static virNetworkDriver testNetworkDriver = {
"Test",
- .open = testOpenNetwork, /* 0.3.2 */
- .close = testCloseNetwork, /* 0.3.2 */
- .numOfNetworks = testNumNetworks, /* 0.3.2 */
- .listNetworks = testListNetworks, /* 0.3.2 */
- .numOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
- .listDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
- .listAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
+ .connectOpen = testOpenNetwork, /* 0.3.2 */
+ .connectClose = testCloseNetwork, /* 0.3.2 */
+ .connectNumOfNetworks = testNumNetworks, /* 0.3.2 */
+ .connectListNetworks = testListNetworks, /* 0.3.2 */
+ .connectNumOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
+ .connectListDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
+ .connectListAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
.networkLookupByUUID = testLookupNetworkByUUID, /* 0.3.2 */
.networkLookupByName = testLookupNetworkByName, /* 0.3.2 */
.networkCreateXML = testNetworkCreate, /* 0.3.2 */
static virInterfaceDriver testInterfaceDriver = {
"Test", /* name */
- .open = testOpenInterface, /* 0.7.0 */
- .close = testCloseInterface, /* 0.7.0 */
- .numOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
- .listInterfaces = testListInterfaces, /* 0.7.0 */
- .numOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
- .listDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
+ .connectOpen = testOpenInterface, /* 0.7.0 */
+ .connectClose = testCloseInterface, /* 0.7.0 */
+ .connectNumOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
+ .connectListInterfaces = testListInterfaces, /* 0.7.0 */
+ .connectNumOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
+ .connectListDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
.interfaceLookupByName = testLookupInterfaceByName, /* 0.7.0 */
.interfaceLookupByMACString = testLookupInterfaceByMACString, /* 0.7.0 */
.interfaceGetXMLDesc = testInterfaceGetXMLDesc, /* 0.7.0 */
static virStorageDriver testStorageDriver = {
.name = "Test",
- .open = testStorageOpen, /* 0.4.1 */
- .close = testStorageClose, /* 0.4.1 */
-
- .numOfPools = testStorageNumPools, /* 0.5.0 */
- .listPools = testStorageListPools, /* 0.5.0 */
- .numOfDefinedPools = testStorageNumDefinedPools, /* 0.5.0 */
- .listDefinedPools = testStorageListDefinedPools, /* 0.5.0 */
- .listAllPools = testStorageListAllPools, /* 0.10.2 */
- .findPoolSources = testStorageFindPoolSources, /* 0.5.0 */
- .poolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
- .poolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
- .poolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
- .poolCreateXML = testStoragePoolCreate, /* 0.5.0 */
- .poolDefineXML = testStoragePoolDefine, /* 0.5.0 */
- .poolBuild = testStoragePoolBuild, /* 0.5.0 */
- .poolUndefine = testStoragePoolUndefine, /* 0.5.0 */
- .poolCreate = testStoragePoolStart, /* 0.5.0 */
- .poolDestroy = testStoragePoolDestroy, /* 0.5.0 */
- .poolDelete = testStoragePoolDelete, /* 0.5.0 */
- .poolRefresh = testStoragePoolRefresh, /* 0.5.0 */
- .poolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
- .poolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
- .poolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
- .poolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
- .poolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
- .poolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
- .poolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
-
- .volLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
- .volLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
- .volLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
- .volCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
- .volCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
- .volDelete = testStorageVolumeDelete, /* 0.5.0 */
- .volGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
- .volGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
- .volGetPath = testStorageVolumeGetPath, /* 0.5.0 */
- .poolIsActive = testStoragePoolIsActive, /* 0.7.3 */
- .poolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
+ .connectOpen = testStorageOpen, /* 0.4.1 */
+ .connectClose = testStorageClose, /* 0.4.1 */
+
+ .connectNumOfStoragePools = testStorageNumPools, /* 0.5.0 */
+ .connectListStoragePools = testStorageListPools, /* 0.5.0 */
+ .connectNumOfDefinedStoragePools = testStorageNumDefinedPools, /* 0.5.0 */
+ .connectListDefinedStoragePools = testStorageListDefinedPools, /* 0.5.0 */
+ .connectListAllStoragePools = testStorageListAllPools, /* 0.10.2 */
+ .connectFindStoragePoolSources = testStorageFindPoolSources, /* 0.5.0 */
+ .storagePoolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
+ .storagePoolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
+ .storagePoolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
+ .storagePoolCreateXML = testStoragePoolCreate, /* 0.5.0 */
+ .storagePoolDefineXML = testStoragePoolDefine, /* 0.5.0 */
+ .storagePoolBuild = testStoragePoolBuild, /* 0.5.0 */
+ .storagePoolUndefine = testStoragePoolUndefine, /* 0.5.0 */
+ .storagePoolCreate = testStoragePoolStart, /* 0.5.0 */
+ .storagePoolDestroy = testStoragePoolDestroy, /* 0.5.0 */
+ .storagePoolDelete = testStoragePoolDelete, /* 0.5.0 */
+ .storagePoolRefresh = testStoragePoolRefresh, /* 0.5.0 */
+ .storagePoolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
+ .storagePoolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
+ .storagePoolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
+ .storagePoolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
+ .storagePoolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
+ .storagePoolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
+ .storagePoolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
+
+ .storageVolLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
+ .storageVolLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
+ .storageVolLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
+ .storageVolCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
+ .storageVolCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
+ .storageVolDelete = testStorageVolumeDelete, /* 0.5.0 */
+ .storageVolGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
+ .storageVolGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
+ .storageVolGetPath = testStorageVolumeGetPath, /* 0.5.0 */
+ .storagePoolIsActive = testStoragePoolIsActive, /* 0.7.3 */
+ .storagePoolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
};
static virDeviceMonitor testDevMonitor = {
.name = "Test",
- .open = testDevMonOpen, /* 0.6.0 */
- .close = testDevMonClose, /* 0.6.0 */
-
- .numOfDevices = testNodeNumOfDevices, /* 0.7.2 */
- .listDevices = testNodeListDevices, /* 0.7.2 */
- .deviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
- .deviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
- .deviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
- .deviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
- .deviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
- .deviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
- .deviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
+ .connectOpen = testDevMonOpen, /* 0.6.0 */
+ .connectClose = testDevMonClose, /* 0.6.0 */
+
+ .nodeNumOfDevices = testNodeNumOfDevices, /* 0.7.2 */
+ .nodeListDevices = testNodeListDevices, /* 0.7.2 */
+ .nodeDeviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
+ .nodeDeviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
+ .nodeDeviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
+ .nodeDeviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
+ .nodeDeviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
+ .nodeDeviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
+ .nodeDeviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
};
static virSecretDriver testSecretDriver = {
.name = "Test",
- .open = testSecretOpen, /* 0.7.1 */
- .close = testSecretClose, /* 0.7.1 */
+ .connectOpen = testSecretOpen, /* 0.7.1 */
+ .connectClose = testSecretClose, /* 0.7.1 */
};
static virNWFilterDriver testNWFilterDriver = {
.name = "Test",
- .open = testNWFilterOpen, /* 0.8.0 */
- .close = testNWFilterClose, /* 0.8.0 */
+ .connectOpen = testNWFilterOpen, /* 0.8.0 */
+ .connectClose = testNWFilterClose, /* 0.8.0 */
};
/**
static virDriver umlDriver = {
.no = VIR_DRV_UML,
.name = "UML",
- .open = umlOpen, /* 0.5.0 */
- .close = umlClose, /* 0.5.0 */
- .type = umlGetType, /* 0.5.0 */
- .version = umlGetVersion, /* 0.5.0 */
- .getHostname = virGetHostname, /* 0.5.0 */
+ .connectOpen = umlOpen, /* 0.5.0 */
+ .connectClose = umlClose, /* 0.5.0 */
+ .connectGetType = umlGetType, /* 0.5.0 */
+ .connectGetVersion = umlGetVersion, /* 0.5.0 */
+ .connectGetHostname = virGetHostname, /* 0.5.0 */
.nodeGetInfo = nodeGetInfo, /* 0.5.0 */
- .getCapabilities = umlGetCapabilities, /* 0.5.0 */
- .listDomains = umlListDomains, /* 0.5.0 */
- .numOfDomains = umlNumDomains, /* 0.5.0 */
- .listAllDomains = umlListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = umlGetCapabilities, /* 0.5.0 */
+ .connectListDomains = umlListDomains, /* 0.5.0 */
+ .connectNumOfDomains = umlNumDomains, /* 0.5.0 */
+ .connectListAllDomains = umlListAllDomains, /* 0.9.13 */
.domainCreateXML = umlDomainCreate, /* 0.5.0 */
.domainLookupByID = umlDomainLookupByID, /* 0.5.0 */
.domainLookupByUUID = umlDomainLookupByUUID, /* 0.5.0 */
.domainGetInfo = umlDomainGetInfo, /* 0.5.0 */
.domainGetState = umlDomainGetState, /* 0.9.2 */
.domainGetXMLDesc = umlDomainGetXMLDesc, /* 0.5.0 */
- .listDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
- .numOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
+ .connectListDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
+ .connectNumOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
.domainCreate = umlDomainStart, /* 0.5.0 */
.domainCreateWithFlags = umlDomainStartWithFlags, /* 0.8.2 */
.domainDefineXML = umlDomainDefine, /* 0.5.0 */
.nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.5.0 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.5.0 */
.nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
- .domainEventRegister = umlDomainEventRegister, /* 0.9.4 */
- .domainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
- .isEncrypted = umlIsEncrypted, /* 0.7.3 */
- .isSecure = umlIsSecure, /* 0.7.3 */
+ .connectDomainEventRegister = umlDomainEventRegister, /* 0.9.4 */
+ .connectDomainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
+ .connectIsEncrypted = umlIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = umlIsSecure, /* 0.7.3 */
.domainIsActive = umlDomainIsActive, /* 0.7.3 */
.domainIsPersistent = umlDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = umlDomainIsUpdated, /* 0.8.6 */
- .domainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
- .domainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
+ .connectDomainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
+ .connectDomainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
.domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
- .isAlive = umlIsAlive, /* 0.9.8 */
+ .connectIsAlive = umlIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
static virStateDriver umlStateDriver = {
.name = "UML",
- .initialize = umlStartup,
- .cleanup = umlShutdown,
- .reload = umlReload,
+ .stateInitialize = umlStartup,
+ .stateCleanup = umlShutdown,
+ .stateReload = umlReload,
};
int umlRegister(void) {
static virDriver vboxDriverDummy = {
VIR_DRV_VBOX,
"VBOX",
- .open = vboxOpenDummy,
+ .connectOpen = vboxOpenDummy,
};
virDriver NAME(Driver) = {
.no = VIR_DRV_VBOX,
.name = "VBOX",
- .open = vboxOpen, /* 0.6.3 */
- .close = vboxClose, /* 0.6.3 */
- .version = vboxGetVersion, /* 0.6.3 */
- .getHostname = virGetHostname, /* 0.6.3 */
- .getMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
+ .connectOpen = vboxOpen, /* 0.6.3 */
+ .connectClose = vboxClose, /* 0.6.3 */
+ .connectGetVersion = vboxGetVersion, /* 0.6.3 */
+ .connectGetHostname = virGetHostname, /* 0.6.3 */
+ .connectGetMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
.nodeGetInfo = nodeGetInfo, /* 0.6.3 */
- .getCapabilities = vboxGetCapabilities, /* 0.6.3 */
- .listDomains = vboxListDomains, /* 0.6.3 */
- .numOfDomains = vboxNumOfDomains, /* 0.6.3 */
- .listAllDomains = vboxListAllDomains, /* 0.9.13 */
+ .connectGetCapabilities = vboxGetCapabilities, /* 0.6.3 */
+ .connectListDomains = vboxListDomains, /* 0.6.3 */
+ .connectNumOfDomains = vboxNumOfDomains, /* 0.6.3 */
+ .connectListAllDomains = vboxListAllDomains, /* 0.9.13 */
.domainCreateXML = vboxDomainCreateXML, /* 0.6.3 */
.domainLookupByID = vboxDomainLookupByID, /* 0.6.3 */
.domainLookupByUUID = vboxDomainLookupByUUID, /* 0.6.3 */
.domainGetVcpusFlags = vboxDomainGetVcpusFlags, /* 0.8.5 */
.domainGetMaxVcpus = vboxDomainGetMaxVcpus, /* 0.7.1 */
.domainGetXMLDesc = vboxDomainGetXMLDesc, /* 0.6.3 */
- .listDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
- .numOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
+ .connectListDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
+ .connectNumOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
.domainCreate = vboxDomainCreate, /* 0.6.3 */
.domainCreateWithFlags = vboxDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = vboxDomainDefineXML, /* 0.6.3 */
.domainScreenshot = vboxDomainScreenshot, /* 0.9.2 */
#endif
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
- .domainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
- .domainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
+ .connectDomainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
+ .connectDomainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
#endif
- .isEncrypted = vboxIsEncrypted, /* 0.7.3 */
- .isSecure = vboxIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = vboxIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = vboxIsSecure, /* 0.7.3 */
.domainIsActive = vboxDomainIsActive, /* 0.7.3 */
.domainIsPersistent = vboxDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = vboxDomainIsUpdated, /* 0.8.6 */
#if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
- .domainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
+ .connectDomainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
#endif
.domainSnapshotCreateXML = vboxDomainSnapshotCreateXML, /* 0.8.0 */
.domainSnapshotGetXMLDesc = vboxDomainSnapshotGetXMLDesc, /* 0.8.0 */
.domainSnapshotHasMetadata = vboxDomainSnapshotHasMetadata, /* 0.9.13 */
.domainRevertToSnapshot = vboxDomainRevertToSnapshot, /* 0.8.0 */
.domainSnapshotDelete = vboxDomainSnapshotDelete, /* 0.8.0 */
- .isAlive = vboxIsAlive, /* 0.9.8 */
+ .connectIsAlive = vboxIsAlive, /* 0.9.8 */
};
virNetworkDriver NAME(NetworkDriver) = {
"VBOX",
- .open = vboxNetworkOpen, /* 0.6.4 */
- .close = vboxNetworkClose, /* 0.6.4 */
- .numOfNetworks = vboxNumOfNetworks, /* 0.6.4 */
- .listNetworks = vboxListNetworks, /* 0.6.4 */
- .numOfDefinedNetworks = vboxNumOfDefinedNetworks, /* 0.6.4 */
- .listDefinedNetworks = vboxListDefinedNetworks, /* 0.6.4 */
- .networkLookupByUUID = vboxNetworkLookupByUUID, /* 0.6.4 */
- .networkLookupByName = vboxNetworkLookupByName, /* 0.6.4 */
- .networkCreateXML = vboxNetworkCreateXML, /* 0.6.4 */
- .networkDefineXML = vboxNetworkDefineXML, /* 0.6.4 */
- .networkUndefine = vboxNetworkUndefine, /* 0.6.4 */
- .networkCreate = vboxNetworkCreate, /* 0.6.4 */
- .networkDestroy = vboxNetworkDestroy, /* 0.6.4 */
- .networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
+ .connectOpen = vboxNetworkOpen, /* 0.6.4 */
+ .connectClose = vboxNetworkClose, /* 0.6.4 */
+ .connectNumOfNetworks = vboxNumOfNetworks, /* 0.6.4 */
+ .connectListNetworks = vboxListNetworks, /* 0.6.4 */
+ .connectNumOfDefinedNetworks = vboxNumOfDefinedNetworks, /* 0.6.4 */
+ .connectListDefinedNetworks = vboxListDefinedNetworks, /* 0.6.4 */
+ .networkLookupByUUID = vboxNetworkLookupByUUID, /* 0.6.4 */
+ .networkLookupByName = vboxNetworkLookupByName, /* 0.6.4 */
+ .networkCreateXML = vboxNetworkCreateXML, /* 0.6.4 */
+ .networkDefineXML = vboxNetworkDefineXML, /* 0.6.4 */
+ .networkUndefine = vboxNetworkUndefine, /* 0.6.4 */
+ .networkCreate = vboxNetworkCreate, /* 0.6.4 */
+ .networkDestroy = vboxNetworkDestroy, /* 0.6.4 */
+ .networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
};
virStorageDriver NAME(StorageDriver) = {
.name = "VBOX",
- .open = vboxStorageOpen, /* 0.7.1 */
- .close = vboxStorageClose, /* 0.7.1 */
- .numOfPools = vboxStorageNumOfPools, /* 0.7.1 */
- .listPools = vboxStorageListPools, /* 0.7.1 */
- .poolLookupByName = vboxStoragePoolLookupByName, /* 0.7.1 */
- .poolNumOfVolumes = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
- .poolListVolumes = vboxStoragePoolListVolumes, /* 0.7.1 */
-
- .volLookupByName = vboxStorageVolLookupByName, /* 0.7.1 */
- .volLookupByKey = vboxStorageVolLookupByKey, /* 0.7.1 */
- .volLookupByPath = vboxStorageVolLookupByPath, /* 0.7.1 */
- .volCreateXML = vboxStorageVolCreateXML, /* 0.7.1 */
- .volDelete = vboxStorageVolDelete, /* 0.7.1 */
- .volGetInfo = vboxStorageVolGetInfo, /* 0.7.1 */
- .volGetXMLDesc = vboxStorageVolGetXMLDesc, /* 0.7.1 */
- .volGetPath = vboxStorageVolGetPath /* 0.7.1 */
+ .connectOpen = vboxStorageOpen, /* 0.7.1 */
+ .connectClose = vboxStorageClose, /* 0.7.1 */
+ .connectNumOfStoragePools = vboxStorageNumOfPools, /* 0.7.1 */
+ .connectListStoragePools = vboxStorageListPools, /* 0.7.1 */
+ .storagePoolLookupByName = vboxStoragePoolLookupByName, /* 0.7.1 */
+ .storagePoolNumOfVolumes = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
+ .storagePoolListVolumes = vboxStoragePoolListVolumes, /* 0.7.1 */
+
+ .storageVolLookupByName = vboxStorageVolLookupByName, /* 0.7.1 */
+ .storageVolLookupByKey = vboxStorageVolLookupByKey, /* 0.7.1 */
+ .storageVolLookupByPath = vboxStorageVolLookupByPath, /* 0.7.1 */
+ .storageVolCreateXML = vboxStorageVolCreateXML, /* 0.7.1 */
+ .storageVolDelete = vboxStorageVolDelete, /* 0.7.1 */
+ .storageVolGetInfo = vboxStorageVolGetInfo, /* 0.7.1 */
+ .storageVolGetXMLDesc = vboxStorageVolGetXMLDesc, /* 0.7.1 */
+ .storageVolGetPath = vboxStorageVolGetPath /* 0.7.1 */
};
static virDriver vmwareDriver = {
.no = VIR_DRV_VMWARE,
.name = "VMWARE",
- .open = vmwareOpen, /* 0.8.7 */
- .close = vmwareClose, /* 0.8.7 */
- .type = vmwareGetType, /* 0.8.7 */
- .version = vmwareGetVersion, /* 0.8.7 */
- .listDomains = vmwareListDomains, /* 0.8.7 */
- .numOfDomains = vmwareNumDomains, /* 0.8.7 */
- .listAllDomains = vmwareListAllDomains, /* 0.9.13 */
+ .connectOpen = vmwareOpen, /* 0.8.7 */
+ .connectClose = vmwareClose, /* 0.8.7 */
+ .connectGetType = vmwareGetType, /* 0.8.7 */
+ .connectGetVersion = vmwareGetVersion, /* 0.8.7 */
+ .connectListDomains = vmwareListDomains, /* 0.8.7 */
+ .connectNumOfDomains = vmwareNumDomains, /* 0.8.7 */
+ .connectListAllDomains = vmwareListAllDomains, /* 0.9.13 */
.domainCreateXML = vmwareDomainCreateXML, /* 0.8.7 */
.domainLookupByID = vmwareDomainLookupByID, /* 0.8.7 */
.domainLookupByUUID = vmwareDomainLookupByUUID, /* 0.8.7 */
.domainGetInfo = vmwareDomainGetInfo, /* 0.8.7 */
.domainGetState = vmwareDomainGetState, /* 0.9.2 */
.domainGetXMLDesc = vmwareDomainGetXMLDesc, /* 0.8.7 */
- .domainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
- .listDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
- .numOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
+ .connectDomainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
+ .connectListDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
+ .connectNumOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
.domainCreate = vmwareDomainCreate, /* 0.8.7 */
.domainCreateWithFlags = vmwareDomainCreateWithFlags, /* 0.8.7 */
.domainDefineXML = vmwareDomainDefineXML, /* 0.8.7 */
.domainUndefineFlags = vmwareDomainUndefineFlags, /* 0.9.4 */
.domainIsActive = vmwareDomainIsActive, /* 0.8.7 */
.domainIsPersistent = vmwareDomainIsPersistent, /* 0.8.7 */
- .isAlive = vmwareIsAlive, /* 0.9.8 */
+ .connectIsAlive = vmwareIsAlive, /* 0.9.8 */
};
int
static virStateDriver state_driver = {
.name = "Xen",
- .initialize = xenInitialize,
+ .stateInitialize = xenInitialize,
};
#endif
static virDriver xenUnifiedDriver = {
.no = VIR_DRV_XEN_UNIFIED,
.name = "Xen",
- .open = xenUnifiedOpen, /* 0.0.3 */
- .close = xenUnifiedClose, /* 0.0.3 */
- .supports_feature = xenUnifiedSupportsFeature, /* 0.3.2 */
- .type = xenUnifiedType, /* 0.0.3 */
- .version = xenUnifiedGetVersion, /* 0.0.3 */
- .getHostname = virGetHostname, /* 0.7.3 */
- .getMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
+ .connectOpen = xenUnifiedOpen, /* 0.0.3 */
+ .connectClose = xenUnifiedClose, /* 0.0.3 */
+ .connectSupportsFeature = xenUnifiedSupportsFeature, /* 0.3.2 */
+ .connectGetType = xenUnifiedType, /* 0.0.3 */
+ .connectGetVersion = xenUnifiedGetVersion, /* 0.0.3 */
+ .connectGetHostname = virGetHostname, /* 0.7.3 */
+ .connectGetMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
.nodeGetInfo = xenUnifiedNodeGetInfo, /* 0.1.0 */
- .getCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
- .listDomains = xenUnifiedListDomains, /* 0.0.3 */
- .numOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
+ .connectGetCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
+ .connectListDomains = xenUnifiedListDomains, /* 0.0.3 */
+ .connectNumOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
.domainCreateXML = xenUnifiedDomainCreateXML, /* 0.0.3 */
.domainLookupByID = xenUnifiedDomainLookupByID, /* 0.0.3 */
.domainLookupByUUID = xenUnifiedDomainLookupByUUID, /* 0.0.5 */
.domainGetVcpus = xenUnifiedDomainGetVcpus, /* 0.1.4 */
.domainGetMaxVcpus = xenUnifiedDomainGetMaxVcpus, /* 0.2.1 */
.domainGetXMLDesc = xenUnifiedDomainGetXMLDesc, /* 0.0.3 */
- .domainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
- .domainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
- .listDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
- .numOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
+ .connectDomainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
+ .connectDomainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
+ .connectListDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
+ .connectNumOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
.domainCreate = xenUnifiedDomainCreate, /* 0.1.1 */
.domainCreateWithFlags = xenUnifiedDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenUnifiedDomainDefineXML, /* 0.1.1 */
.domainBlockPeek = xenUnifiedDomainBlockPeek, /* 0.4.4 */
.nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, /* 0.3.3 */
.nodeGetFreeMemory = xenUnifiedNodeGetFreeMemory, /* 0.3.3 */
- .domainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
- .domainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
+ .connectDomainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
+ .connectDomainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
.nodeDeviceDettach = xenUnifiedNodeDeviceDettach, /* 0.6.1 */
.nodeDeviceReAttach = xenUnifiedNodeDeviceReAttach, /* 0.6.1 */
.nodeDeviceReset = xenUnifiedNodeDeviceReset, /* 0.6.1 */
- .isEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
- .isSecure = xenUnifiedIsSecure, /* 0.7.3 */
+ .connectIsEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
+ .connectIsSecure = xenUnifiedIsSecure, /* 0.7.3 */
.domainIsActive = xenUnifiedDomainIsActive, /* 0.7.3 */
.domainIsPersistent = xenUnifiedDomainIsPersistent, /* 0.7.3 */
.domainIsUpdated = xenUnifiedDomainIsUpdated, /* 0.8.6 */
- .domainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
- .domainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
+ .connectDomainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
+ .connectDomainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
.domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */
- .isAlive = xenUnifiedIsAlive, /* 0.9.8 */
+ .connectIsAlive = xenUnifiedIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
.nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
.nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
static virDriver xenapiDriver = {
.no = VIR_DRV_XENAPI,
.name = "XenAPI",
- .open = xenapiOpen, /* 0.8.0 */
- .close = xenapiClose, /* 0.8.0 */
- .supports_feature = xenapiSupportsFeature, /* 0.8.0 */
- .type = xenapiType, /* 0.8.0 */
- .version = xenapiGetVersion, /* 0.8.0 */
- .getHostname = xenapiGetHostname, /* 0.8.0 */
- .getMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
+ .connectOpen = xenapiOpen, /* 0.8.0 */
+ .connectClose = xenapiClose, /* 0.8.0 */
+ .connectSupportsFeature = xenapiSupportsFeature, /* 0.8.0 */
+ .connectGetType = xenapiType, /* 0.8.0 */
+ .connectGetVersion = xenapiGetVersion, /* 0.8.0 */
+ .connectGetHostname = xenapiGetHostname, /* 0.8.0 */
+ .connectGetMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
.nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */
- .getCapabilities = xenapiGetCapabilities, /* 0.8.0 */
- .listDomains = xenapiListDomains, /* 0.8.0 */
- .numOfDomains = xenapiNumOfDomains, /* 0.8.0 */
+ .connectGetCapabilities = xenapiGetCapabilities, /* 0.8.0 */
+ .connectListDomains = xenapiListDomains, /* 0.8.0 */
+ .connectNumOfDomains = xenapiNumOfDomains, /* 0.8.0 */
.domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */
.domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */
.domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */
.domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */
.domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */
.domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */
- .listDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
- .numOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
+ .connectListDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
+ .connectNumOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
.domainCreate = xenapiDomainCreate, /* 0.8.0 */
.domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */
.domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */
.nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */
.nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */
.domainIsUpdated = xenapiDomainIsUpdated, /* 0.8.6 */
- .isAlive = xenapiIsAlive, /* 0.9.8 */
+ .connectIsAlive = xenapiIsAlive, /* 0.9.8 */
};
/**
static virSecretDriver fakeSecretDriver = {
.name = "fake_secret",
- .open = NULL,
- .close = fakeSecretClose,
- .numOfSecrets = NULL,
- .listSecrets = NULL,
- .lookupByUUID = NULL,
- .lookupByUsage = fakeSecretLookupByUsage,
- .defineXML = NULL,
- .getXMLDesc = NULL,
- .setValue = NULL,
- .getValue = fakeSecretGetValue,
- .undefine = NULL,
+ .connectOpen = NULL,
+ .connectClose = fakeSecretClose,
+ .connectNumOfSecrets = NULL,
+ .connectListSecrets = NULL,
+ .secretLookupByUUID = NULL,
+ .secretLookupByUsage = fakeSecretLookupByUsage,
+ .secretDefineXML = NULL,
+ .secretGetXMLDesc = NULL,
+ .secretSetValue = NULL,
+ .secretGetValue = fakeSecretGetValue,
+ .secretUndefine = NULL,
};
typedef enum {
projects / thirdparty / libvirt.git / commitdiff
