External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-23 14:15:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

vbox: Rewrite vboxConnectListDomains

Browse Source
This commit is contained in:
Taowei 2014-08-11 18:06:14 +08:00 committed by Michal Privoznik
parent 30a95f30ef
commit 0958334ac0
3 changed files with 105 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/vbox/vbox_common.c
View File

@ -97,6 +97,10 @@ if (!data->vboxObj) {\
#define VBOX_IID_INITIALIZE(iid) gVBoxAPI.UIID.vboxIIDInitialize(iid)
#define ARRAY_GET_MACHINES \
(gVBoxAPI.UArray.handleGetMachines(data->vboxObj))
/* global vbox API, used for all common codes. */
static vboxUniformedAPI gVBoxAPI;
@ -474,3 +478,41 @@ char *vboxConnectGetCapabilities(virConnectPtr conn)
return ret;
}
int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
VBOX_OBJECT_CHECK(conn, int, -1);
vboxArray machines = VBOX_ARRAY_INITIALIZER;
PRUint32 state;
nsresult rc;
size_t i, j;
rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not get list of Domains, rc=%08x"),
(unsigned)rc);
goto cleanup;
}
ret = 0;
for (i = 0, j = 0; (i < machines.count) && (j < nids); ++i) {
IMachine *machine = machines.items[i];
if (machine) {
PRBool isAccessible = PR_FALSE;
gVBoxAPI.UIMachine.GetAccessible(machine, &isAccessible);
if (isAccessible) {
gVBoxAPI.UIMachine.GetState(machine, &state);
if (gVBoxAPI.machineStateChecker.Online(state)) {
ret++;
ids[j++] = i + 1;
}
}
}
}
cleanup:
gVBoxAPI.UArray.vboxArrayRelease(&machines);
return ret;
}

80
src/vbox/vbox_tmpl.c
View File

@ -921,45 +921,6 @@ vboxSocketParseAddrUtf16(vboxGlobalData *data, const PRUnichar *utf16,
return result;
}
static int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids)
{
VBOX_OBJECT_CHECK(conn, int, -1);
vboxArray machines = VBOX_ARRAY_INITIALIZER;
PRUint32 state;
nsresult rc;
size_t i, j;
rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
if (NS_FAILED(rc)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not get list of Domains, rc=%08x"),
(unsigned)rc);
goto cleanup;
}
ret = 0;
for (i = 0, j = 0; (i < machines.count) && (j < nids); ++i) {
IMachine *machine = machines.items[i];
if (machine) {
PRBool isAccessible = PR_FALSE;
machine->vtbl->GetAccessible(machine, &isAccessible);
if (isAccessible) {
machine->vtbl->GetState(machine, &state);
if ((state >= MachineState_FirstOnline) &&
(state <= MachineState_LastOnline)) {
ret++;
ids[j++] = i + 1;
}
}
}
}
cleanup:
vboxArrayRelease(&machines);
return ret;
}
static int vboxConnectNumOfDomains(virConnectPtr conn)
{
VBOX_OBJECT_CHECK(conn, int, -1);
@ -11290,6 +11251,11 @@ static void _DEBUGIID(const char *msg, vboxIIDUnion *iidu)
#endif /* VBOX_API_VERSION != 2002000 */
static void* _handleGetMachines(IVirtualBox *vboxObj)
{
return vboxObj->vtbl->GetMachines;
}
static nsresult _nsisupportsRelease(nsISupports *nsi)
{
return nsi->vtbl->Release(nsi);
@ -11325,6 +11291,18 @@ _virtualboxGetSystemProperties(IVirtualBox *vboxObj, ISystemProperties **systemP
return vboxObj->vtbl->GetSystemProperties(vboxObj, systemProperties);
}
static nsresult
_machineGetAccessible(IMachine *machine, PRBool *isAccessible)
{
return machine->vtbl->GetAccessible(machine, isAccessible);
}
static nsresult
_machineGetState(IMachine *machine, PRUint32 *state)
{
return machine->vtbl->GetState(machine, state);
}
#if VBOX_API_VERSION < 4000000
static nsresult
@ -11389,6 +11367,12 @@ _systemPropertiesGetMaxGuestCPUCount(ISystemProperties *systemProperties, PRUint
return systemProperties->vtbl->GetMaxGuestCPUCount(systemProperties, maxCPUCount);
}
static bool _machineStateOnline(PRUint32 state)
{
return ((state >= MachineState_FirstOnline) &&
(state <= MachineState_LastOnline));
}
static vboxUniformedPFN _UPFN = {
.Initialize = _pfnInitialize,
.Uninitialize = _pfnUninitialize,
@ -11409,6 +11393,12 @@ static vboxUniformedIID _UIID = {
.DEBUGIID = _DEBUGIID,
};
static vboxUniformedArray _UArray = {
.vboxArrayGet = vboxArrayGet,
.vboxArrayRelease = vboxArrayRelease,
.handleGetMachines = _handleGetMachines,
};
static vboxUniformednsISupports _nsUISupports = {
.Release = _nsisupportsRelease,
};
@ -11419,6 +11409,11 @@ static vboxUniformedIVirtualBox _UIVirtualBox = {
.GetSystemProperties = _virtualboxGetSystemProperties,
};
static vboxUniformedIMachine _UIMachine = {
.GetAccessible = _machineGetAccessible,
.GetState = _machineGetState,
};
static vboxUniformedISession _UISession = {
.OpenExisting = _sessionOpenExisting,
.GetConsole = _sessionGetConsole,
@ -11438,6 +11433,10 @@ static vboxUniformedISystemProperties _UISystemProperties = {
.GetMaxGuestCPUCount = _systemPropertiesGetMaxGuestCPUCount,
};
static uniformedMachineStateChecker _machineStateChecker = {
.Online = _machineStateOnline,
};
void NAME(InstallUniformedAPI)(vboxUniformedAPI *pVBoxAPI)
{
pVBoxAPI->APIVersion = VBOX_API_VERSION;
@ -11446,12 +11445,15 @@ void NAME(InstallUniformedAPI)(vboxUniformedAPI *pVBoxAPI)
pVBoxAPI->registerGlobalData = _registerGlobalData;
pVBoxAPI->UPFN = _UPFN;
pVBoxAPI->UIID = _UIID;
pVBoxAPI->UArray = _UArray;
pVBoxAPI->nsUISupports = _nsUISupports;
pVBoxAPI->UIVirtualBox = _UIVirtualBox;
pVBoxAPI->UIMachine = _UIMachine;
pVBoxAPI->UISession = _UISession;
pVBoxAPI->UIConsole = _UIConsole;
pVBoxAPI->UIProgress = _UIProgress;
pVBoxAPI->UISystemProperties = _UISystemProperties;
pVBoxAPI->machineStateChecker = _machineStateChecker;
#if VBOX_API_VERSION <= 2002000 || VBOX_API_VERSION >= 4000000
pVBoxAPI->domainEventCallbacks = 0;

22
src/vbox/vbox_uniformed_api.h
View File

@ -162,6 +162,14 @@ typedef struct {
void (*DEBUGIID)(const char *msg, vboxIIDUnion *iidu);
} vboxUniformedIID;
/* Functions for vboxArray */
typedef struct {
nsresult (*vboxArrayGet)(vboxArray *array, void *self, void *getter);
void (*vboxArrayRelease)(vboxArray *array);
/* Generate function pointers for vboxArrayGet */
void* (*handleGetMachines)(IVirtualBox *vboxObj);
} vboxUniformedArray;
/* Functions for nsISupports */
typedef struct {
nsresult (*Release)(nsISupports *nsi);
@ -174,6 +182,12 @@ typedef struct {
nsresult (*GetSystemProperties)(IVirtualBox *vboxObj, ISystemProperties **systemProperties);
} vboxUniformedIVirtualBox;
/* Functions for IMachine */
typedef struct {
nsresult (*GetAccessible)(IMachine *machine, PRBool *isAccessible);
nsresult (*GetState)(IMachine *machine, PRUint32 *state);
} vboxUniformedIMachine;
/* Functions for ISession */
typedef struct {
nsresult (*OpenExisting)(vboxGlobalData *data, vboxIIDUnion *iidu, IMachine *machine);
@ -197,6 +211,10 @@ typedef struct {
nsresult (*GetMaxGuestCPUCount)(ISystemProperties *systemProperties, PRUint32 *maxCPUCount);
} vboxUniformedISystemProperties;
typedef struct {
bool (*Online)(PRUint32 state);
} uniformedMachineStateChecker;
typedef struct {
/* vbox API version */
uint32_t APIVersion;
@ -206,12 +224,15 @@ typedef struct {
void (*registerGlobalData)(vboxGlobalData *data);
vboxUniformedPFN UPFN;
vboxUniformedIID UIID;
vboxUniformedArray UArray;
vboxUniformednsISupports nsUISupports;
vboxUniformedIVirtualBox UIVirtualBox;
vboxUniformedIMachine UIMachine;
vboxUniformedISession UISession;
vboxUniformedIConsole UIConsole;
vboxUniformedIProgress UIProgress;
vboxUniformedISystemProperties UISystemProperties;
uniformedMachineStateChecker machineStateChecker;
/* vbox API features */
bool domainEventCallbacks;
bool hasStaticGlobalData;
@ -234,6 +255,7 @@ int vboxConnectIsEncrypted(virConnectPtr conn);
int vboxConnectIsAlive(virConnectPtr conn);
int vboxConnectGetMaxVcpus(virConnectPtr conn, const char *type);
char *vboxConnectGetCapabilities(virConnectPtr conn);
int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids);
/* Version specified functions for installing uniformed API */
void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);