We should follow the rules that CHECK macro only do checking works. But this VBOX_OBJECT_CHECK and VBOX_OBJECT_HOST_CHECK declared some varibles at the same time, which broke the rule. So the patch removed this macros and dispatched it in source code. The storage driver is still not rewriten at this point. So, I remains the VBOX_OBJECT_CHECK macro in vbox_tmpl.c. But this will finally be removed in patch 'vbox: Remove unused things in vbox_tmpl.c' --- src/vbox/vbox_common.c | 301 +++++++++++++++++++++++++++++++++++++++--------- src/vbox/vbox_tmpl.c | 48 +++++--- 2 files changed, 275 insertions(+), 74 deletions(-) diff --git a/src/vbox/vbox_common.c b/src/vbox/vbox_common.c index 9ac93c8..46f6968 100644 --- a/src/vbox/vbox_common.c +++ b/src/vbox/vbox_common.c @@ -100,13 +100,6 @@ VIR_LOG_INIT("vbox.vbox_common"); } \ } while (0) -#define VBOX_OBJECT_CHECK(conn, type, value) \ -vboxGlobalData *data = conn->privateData;\ -type ret = value;\ -if (!data->vboxObj) {\ - return ret;\ -} - #define vboxIIDUnalloc(iid) gVBoxAPI.UIID.vboxIIDUnalloc(data, iid) #define vboxIIDToUUID(iid, uuid) gVBoxAPI.UIID.vboxIIDToUUID(data, iid, uuid) #define vboxIIDFromUUID(iid, uuid) gVBoxAPI.UIID.vboxIIDFromUUID(data, iid, uuid) @@ -537,13 +530,17 @@ static int vboxConnectClose(virConnectPtr conn) static int vboxDomainSave(virDomainPtr dom, const char *path ATTRIBUTE_UNUSED) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IConsole *console = NULL; vboxIIDUnion iid; IMachine *machine = NULL; IProgress *progress = NULL; resultCodeUnion resultCode; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; /* VirtualBox currently doesn't support saving to a file * at a location other then the machine folder and thus @@ -632,8 +629,12 @@ static int vboxConnectIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED) static int vboxConnectGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; PRUint32 maxCPUCount = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; /* VirtualBox Supports only hvm and thus the type passed to it * has no meaning, setting it to ATTRIBUTE_UNUSED @@ -655,7 +656,11 @@ vboxConnectGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) static char *vboxConnectGetCapabilities(virConnectPtr conn) { - VBOX_OBJECT_CHECK(conn, char *, NULL); + vboxGlobalData *data = conn->privateData; + char *ret = NULL; + + if (!data->vboxObj) + return ret; vboxDriverLock(data); ret = virCapabilitiesFormatXML(data->caps); @@ -666,11 +671,15 @@ static char *vboxConnectGetCapabilities(virConnectPtr conn) static int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; PRUint32 state; nsresult rc; size_t i, j; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); if (NS_FAILED(rc)) { @@ -704,11 +713,15 @@ static int vboxConnectListDomains(virConnectPtr conn, int *ids, int nids) static int vboxConnectNumOfDomains(virConnectPtr conn) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; PRUint32 state; nsresult rc; size_t i; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); if (NS_FAILED(rc)) { @@ -739,7 +752,7 @@ static int vboxConnectNumOfDomains(virConnectPtr conn) static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) { - VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; IMachine *machine; PRBool isAccessible = PR_FALSE; @@ -749,6 +762,10 @@ static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) unsigned char uuid[VIR_UUID_BUFLEN]; PRUint32 state; nsresult rc; + virDomainPtr ret = NULL; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); /* Internal vbox IDs start from 0, the public libvirt ID @@ -813,7 +830,7 @@ static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid) { - VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; vboxIIDUnion iid; char *machineNameUtf8 = NULL; @@ -822,6 +839,10 @@ virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, size_t i; bool matched = false; nsresult rc; + virDomainPtr ret = NULL; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); @@ -886,7 +907,7 @@ virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name) { - VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; vboxIIDUnion iid; char *machineNameUtf8 = NULL; @@ -895,6 +916,10 @@ vboxDomainLookupByName(virConnectPtr conn, const char *name) size_t i; bool matched = false; nsresult rc; + virDomainPtr ret = NULL; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); @@ -1870,13 +1895,17 @@ vboxAttachSharedFolder(virDomainDefPtr def, vboxGlobalData *data, IMachine *mach static virDomainPtr vboxDomainDefineXML(virConnectPtr conn, const char *xml) { - VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL); + vboxGlobalData *data = conn->privateData; IMachine *machine = NULL; IBIOSSettings *bios = NULL; vboxIIDUnion mchiid; virDomainDefPtr def = NULL; nsresult rc; char uuidstr[VIR_UUID_STRING_BUFLEN]; + virDomainPtr ret = NULL; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&mchiid); if (!(def = virDomainDefParseString(xml, data->caps, data->xmlopt, @@ -2039,10 +2068,14 @@ detachDevices_common(vboxGlobalData *data, vboxIIDUnion *iidu) static int vboxDomainUndefineFlags(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; gVBoxAPI.UIID.vboxIIDInitialize(&iid); /* No managed save, so we explicitly reject @@ -2078,7 +2111,7 @@ static int vboxDomainUndefine(virDomainPtr dom) static int vboxStartMachine(virDomainPtr dom, int maxDomID, IMachine *machine, vboxIIDUnion *iid) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; int vrdpPresent = 0; int sdlPresent = 0; int guiPresent = 0; @@ -2094,6 +2127,10 @@ vboxStartMachine(virDomainPtr dom, int maxDomID, IMachine *machine, vboxIIDUnion PRUnichar *env = NULL; PRUnichar *sessionType = NULL; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16); gVBoxAPI.UIMachine.GetExtraData(machine, keyTypeUtf16, &valueTypeUtf16); @@ -2228,11 +2265,15 @@ vboxStartMachine(virDomainPtr dom, int maxDomID, IMachine *machine, vboxIIDUnion static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; unsigned char uuid[VIR_UUID_BUFLEN] = {0}; nsresult rc; size_t i = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -2329,7 +2370,7 @@ static virDomainPtr vboxDomainCreateXML(virConnectPtr conn, const char *xml, static int vboxDomainIsActive(virDomainPtr dom) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; vboxIIDUnion iid; char *machineNameUtf8 = NULL; @@ -2338,6 +2379,10 @@ static int vboxDomainIsActive(virDomainPtr dom) size_t i; bool matched = false; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); @@ -2397,9 +2442,13 @@ static int vboxDomainIsPersistent(virDomainPtr dom) { /* All domains are persistent. However, we do want to check for * existence. */ - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; + int ret = -1; + + if (!data->vboxObj) + return ret; if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0) goto cleanup; @@ -2416,9 +2465,13 @@ static int vboxDomainIsUpdated(virDomainPtr dom) { /* VBox domains never have a persistent state that differs from * current state. However, we do want to check for existence. */ - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; + int ret = -1; + + if (!data->vboxObj) + return ret; if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0) goto cleanup; @@ -2433,12 +2486,16 @@ static int vboxDomainIsUpdated(virDomainPtr dom) static int vboxDomainSuspend(virDomainPtr dom) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; IConsole *console = NULL; PRBool isAccessible = PR_FALSE; PRUint32 state; + int ret = -1; + + if (!data->vboxObj) + return ret; if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0) goto cleanup; @@ -2480,12 +2537,16 @@ static int vboxDomainSuspend(virDomainPtr dom) static int vboxDomainResume(virDomainPtr dom) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; IConsole *console = NULL; PRUint32 state; PRBool isAccessible = PR_FALSE; + int ret = -1; + + if (!data->vboxObj) + return ret; if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0) goto cleanup; @@ -2527,12 +2588,16 @@ static int vboxDomainResume(virDomainPtr dom) static int vboxDomainShutdownFlags(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; IConsole *console = NULL; PRUint32 state; PRBool isAccessible = PR_FALSE; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -2580,12 +2645,16 @@ static int vboxDomainShutdown(virDomainPtr dom) static int vboxDomainReboot(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; IConsole *console = NULL; PRUint32 state; PRBool isAccessible = PR_FALSE; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -2624,12 +2693,16 @@ static int vboxDomainReboot(virDomainPtr dom, unsigned int flags) static int vboxDomainDestroyFlags(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; IConsole *console = NULL; PRUint32 state; PRBool isAccessible = PR_FALSE; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -2686,12 +2759,16 @@ static char *vboxDomainGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) { static int vboxDomainSetMemory(virDomainPtr dom, unsigned long memory) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; PRUint32 state; PRBool isAccessible = PR_FALSE; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0) goto cleanup; @@ -2740,12 +2817,16 @@ static int vboxDomainSetMemory(virDomainPtr dom, unsigned long memory) static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; char *machineName = NULL; PRUnichar *machineNameUtf16 = NULL; nsresult rc; size_t i = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); if (NS_FAILED(rc)) { @@ -2820,10 +2901,14 @@ static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) static int vboxDomainGetState(virDomainPtr dom, int *state, int *reason, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; PRUint32 mstate; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -2847,11 +2932,15 @@ static int vboxDomainGetState(virDomainPtr dom, int *state, static int vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; PRUint32 CPUCount = nvcpus; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; if (flags != VIR_DOMAIN_AFFECT_LIVE) { virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); @@ -2897,9 +2986,13 @@ static int vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) static int vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; ISystemProperties *systemProperties = NULL; PRUint32 maxCPUCount = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; if (flags != (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) { virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags); @@ -3789,7 +3882,7 @@ vboxDumpParallel(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine, P static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, char *, NULL); + vboxGlobalData *data = dom->conn->privateData; virDomainDefPtr def = NULL; IMachine *machine = NULL; vboxIIDUnion iid; @@ -3808,6 +3901,10 @@ static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) IBIOSSettings *bios = NULL; PRUint32 chipsetType = ChipsetType_Null; ISystemProperties *systemProperties = NULL; + char *ret = NULL; + + if (!data->vboxObj) + return ret; /* Flags checked by virDomainDefFormat */ @@ -3948,13 +4045,17 @@ static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) static int vboxConnectListDefinedDomains(virConnectPtr conn, char ** const names, int maxnames) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; char *machineName = NULL; PRUnichar *machineNameUtf16 = NULL; PRUint32 state; nsresult rc; size_t i, j; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); @@ -4006,11 +4107,15 @@ static int vboxConnectListDefinedDomains(virConnectPtr conn, static int vboxConnectNumOfDefinedDomains(virConnectPtr conn) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; PRUint32 state; nsresult rc; size_t i; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = gVBoxAPI.UArray.vboxArrayGet(&machines, data->vboxObj, ARRAY_GET_MACHINES); @@ -4048,13 +4153,17 @@ static int vboxDomainAttachDeviceImpl(virDomainPtr dom, const char *xml, int mediaChangeOnly ATTRIBUTE_UNUSED) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; PRUint32 state; virDomainDefPtr def = NULL; virDomainDeviceDefPtr dev = NULL; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); if (VIR_ALLOC(def) < 0) @@ -4187,13 +4296,17 @@ static int vboxDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml, static int vboxDomainDetachDevice(virDomainPtr dom, const char *xml) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IMachine *machine = NULL; vboxIIDUnion iid; PRUint32 state; virDomainDefPtr def = NULL; virDomainDeviceDefPtr dev = NULL; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&iid); if (VIR_ALLOC(def) < 0) @@ -4296,13 +4409,17 @@ static int vboxDomainDetachDeviceFlags(virDomainPtr dom, const char *xml, static int vboxCloseDisksRecursively(virDomainPtr dom, char *location) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; nsresult rc; size_t i = 0; PRUnichar *locationUtf = NULL; IMedium *medium = NULL; IMedium **children = NULL; PRUint32 childrenSize = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; if (!gVBoxAPI.vboxSnapshotRedefine) VIR_WARN("This function may not work in current version"); @@ -4393,7 +4510,7 @@ vboxSnapshotRedefine(virDomainPtr dom, * * Finally, we register the machine with the new virtualbox description file. */ - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; nsresult rc; @@ -4417,6 +4534,10 @@ vboxSnapshotRedefine(virDomainPtr dom, char *nameTmpUse = NULL; bool snapshotFileExists = false; bool needToChangeStorageController = false; + int ret = -1; + + if (!data->vboxObj) + return ret; if (!gVBoxAPI.vboxSnapshotRedefine) VIR_WARN("This function may not work in current version"); @@ -5252,7 +5373,7 @@ vboxDomainSnapshotCreateXML(virDomainPtr dom, const char *xmlDesc, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL); + vboxGlobalData *data = dom->conn->privateData; virDomainSnapshotDefPtr def = NULL; vboxIIDUnion domiid; IMachine *machine = NULL; @@ -5264,6 +5385,10 @@ vboxDomainSnapshotCreateXML(virDomainPtr dom, PRUint32 state; nsresult rc; resultCodeUnion result; + virDomainSnapshotPtr ret = NULL; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&domiid); /* VBox has no snapshot metadata, so this flag is trivial. */ @@ -5505,7 +5630,7 @@ static int vboxSnapshotGetReadWriteDisks(virDomainSnapshotDefPtr def, virDomainSnapshotPtr snapshot) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; ISnapshot *snap = NULL; @@ -5518,6 +5643,10 @@ static int vboxSnapshotGetReadWriteDisks(virDomainSnapshotDefPtr def, vboxIIDUnion snapIid; char *snapshotUuidStr = NULL; size_t i = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; if (!gVBoxAPI.vboxSnapshotRedefine) VIR_WARN("This function may not work in current version"); @@ -5723,7 +5852,7 @@ int vboxSnapshotGetReadOnlyDisks(virDomainSnapshotPtr snapshot, virDomainSnapshotDefPtr def) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; ISnapshot *snap = NULL; IMachine *machine = NULL; @@ -5736,6 +5865,10 @@ int vboxSnapshotGetReadOnlyDisks(virDomainSnapshotPtr snapshot, PRUint32 maxPortPerInst[StorageBus_Floppy + 1] = {}; PRUint32 maxSlotPerPort[StorageBus_Floppy + 1] = {}; int diskCount = 0; + int ret = -1; + + if (!data->vboxObj) + return ret; if (!gVBoxAPI.vboxSnapshotRedefine) VIR_WARN("This function may not work in current version"); @@ -5938,7 +6071,7 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, char *, NULL); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; ISnapshot *snap = NULL; @@ -5950,6 +6083,10 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot, PRInt64 timestamp; PRBool online = PR_FALSE; char uuidstr[VIR_UUID_STRING_BUFLEN]; + char *ret = NULL; + + if (!data->vboxObj) + return ret; virCheckFlags(0, NULL); @@ -6075,11 +6212,15 @@ static char *vboxDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot, static int vboxDomainSnapshotNum(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; nsresult rc; PRUint32 snapshotCount; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS | VIR_DOMAIN_SNAPSHOT_LIST_METADATA, -1); @@ -6116,13 +6257,17 @@ static int vboxDomainSnapshotNum(virDomainPtr dom, unsigned int flags) static int vboxDomainSnapshotListNames(virDomainPtr dom, char **names, int nameslen, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; nsresult rc; ISnapshot **snapshots = NULL; int count = 0; size_t i; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS | VIR_DOMAIN_SNAPSHOT_LIST_METADATA, -1); @@ -6196,10 +6341,14 @@ static virDomainSnapshotPtr vboxDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snapshot = NULL; + virDomainSnapshotPtr ret = NULL; + + if (!data->vboxObj) + return ret; virCheckFlags(0, NULL); @@ -6221,11 +6370,15 @@ vboxDomainSnapshotLookupByName(virDomainPtr dom, const char *name, static int vboxDomainHasCurrentSnapshot(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snapshot = NULL; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -6255,7 +6408,7 @@ vboxDomainSnapshotGetParent(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snap = NULL; @@ -6263,6 +6416,10 @@ vboxDomainSnapshotGetParent(virDomainSnapshotPtr snapshot, PRUnichar *nameUtf16 = NULL; char *name = NULL; nsresult rc; + virDomainSnapshotPtr ret = NULL; + + if (!data->vboxObj) + return ret; virCheckFlags(0, NULL); @@ -6314,13 +6471,17 @@ vboxDomainSnapshotGetParent(virDomainSnapshotPtr snapshot, static virDomainSnapshotPtr vboxDomainSnapshotCurrent(virDomainPtr dom, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, virDomainSnapshotPtr, NULL); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snapshot = NULL; PRUnichar *nameUtf16 = NULL; char *name = NULL; nsresult rc; + virDomainSnapshotPtr ret = NULL; + + if (!data->vboxObj) + return ret; virCheckFlags(0, NULL); @@ -6368,7 +6529,7 @@ static int vboxDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snap = NULL; @@ -6376,6 +6537,10 @@ static int vboxDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, PRUnichar *nameUtf16 = NULL; char *name = NULL; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -6425,10 +6590,14 @@ static int vboxDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion iid; IMachine *machine = NULL; ISnapshot *snap = NULL; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -6452,7 +6621,7 @@ static int vboxDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; ISnapshot *newSnapshot = NULL; @@ -6460,6 +6629,10 @@ static int vboxDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, PRBool online = PR_FALSE; PRUint32 state; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(0, -1); @@ -6612,7 +6785,7 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot) */ virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; virDomainSnapshotDefPtr def = NULL; char *defXml = NULL; vboxIIDUnion domiid; @@ -6629,6 +6802,10 @@ vboxDomainSnapshotDeleteMetadataOnly(virDomainSnapshotPtr snapshot) char *machineLocationPath = NULL; PRUint32 aMediaSize = 0; IMedium **aMedia = NULL; + int ret = -1; + + if (!data->vboxObj) + return ret; VBOX_IID_INITIALIZE(&domiid); if (!gVBoxAPI.vboxSnapshotRedefine) @@ -7049,7 +7226,7 @@ static int vboxDomainSnapshotDelete(virDomainSnapshotPtr snapshot, unsigned int flags) { virDomainPtr dom = snapshot->domain; - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIIDUnion domiid; IMachine *machine = NULL; ISnapshot *snap = NULL; @@ -7057,6 +7234,10 @@ static int vboxDomainSnapshotDelete(virDomainSnapshotPtr snapshot, PRUint32 state; nsresult rc; vboxArray snapChildren = VBOX_ARRAY_INITIALIZER; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN | VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY, -1); @@ -7131,7 +7312,7 @@ vboxDomainScreenshot(virDomainPtr dom, unsigned int screen, unsigned int flags) { - VBOX_OBJECT_CHECK(dom->conn, char *, NULL); + vboxGlobalData *data = dom->conn->privateData; IConsole *console = NULL; vboxIIDUnion iid; IMachine *machine = NULL; @@ -7139,6 +7320,10 @@ vboxDomainScreenshot(virDomainPtr dom, char *tmp; int tmp_fd = -1; unsigned int max_screen; + char *ret = NULL; + + if (!data->vboxObj) + return ret; if (!gVBoxAPI.supportScreenshot) { virReportError(VIR_ERR_NO_SUPPORT, "%s", @@ -7258,7 +7443,7 @@ vboxConnectListAllDomains(virConnectPtr conn, virDomainPtr **domains, unsigned int flags) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; vboxArray machines = VBOX_ARRAY_INITIALIZER; char *machineNameUtf8 = NULL; PRUnichar *machineNameUtf16 = NULL; @@ -7272,6 +7457,10 @@ vboxConnectListAllDomains(virConnectPtr conn, int count = 0; bool active; PRUint32 snapshotCount; + int ret = -1; + + if (!data->vboxObj) + return ret; virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1); diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index db98c90..8fa03ba 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -159,18 +159,6 @@ if (!data->vboxObj) {\ return ret;\ } -#define VBOX_OBJECT_HOST_CHECK(conn, type, value) \ -vboxGlobalData *data = conn->privateData;\ -type ret = value;\ -IHost *host = NULL;\ -if (!data->vboxObj) {\ - return ret;\ -}\ -data->vboxObj->vtbl->GetHost(data->vboxObj, &host);\ -if (!host) {\ - return ret;\ -} - #if VBOX_API_VERSION < 3001000 # define VBOX_MEDIUM_RELEASE(arg) \ @@ -1350,9 +1338,13 @@ _vboxDomainSnapshotRestore(virDomainPtr dom, IMachine *machine, ISnapshot *snapshot) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; vboxIID iid = VBOX_IID_INITIALIZER; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = snapshot->vtbl->GetId(snapshot, &iid.value); if (NS_FAILED(rc)) { @@ -1380,13 +1372,17 @@ _vboxDomainSnapshotRestore(virDomainPtr dom, IMachine *machine, ISnapshot *snapshot) { - VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxGlobalData *data = dom->conn->privateData; IConsole *console = NULL; IProgress *progress = NULL; PRUint32 state; nsresult rc; PRInt32 result; vboxIID domiid = VBOX_IID_INITIALIZER; + int ret = -1; + + if (!data->vboxObj) + return ret; rc = machine->vtbl->GetId(machine, &domiid.value); if (NS_FAILED(rc)) { @@ -1815,9 +1811,13 @@ vboxConnectDomainEventRegister(virConnectPtr conn, void *opaque, virFreeCallback freecb) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; int vboxRet = -1; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; /* Locking has to be there as callbacks are not * really fully thread safe @@ -1878,8 +1878,12 @@ static int vboxConnectDomainEventDeregister(virConnectPtr conn, virConnectDomainEventCallback callback) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; int cnt; + int ret = -1; + + if (!data->vboxObj) + return ret; /* Locking has to be there as callbacks are not * really fully thread safe @@ -1913,9 +1917,13 @@ static int vboxConnectDomainEventRegisterAny(virConnectPtr conn, void *opaque, virFreeCallback freecb) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; int vboxRet = -1; nsresult rc; + int ret = -1; + + if (!data->vboxObj) + return ret; /* Locking has to be there as callbacks are not * really fully thread safe @@ -1978,8 +1986,12 @@ static int vboxConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID) { - VBOX_OBJECT_CHECK(conn, int, -1); + vboxGlobalData *data = conn->privateData; int cnt; + int ret = -1; + + if (!data->vboxObj) + return ret; /* Locking has to be there as callbacks are not * really fully thread safe -- 1.7.9.5

This patch rewrites the following functions *vboxStorageOpen *vboxStorageClose *vboxConnectNumOfStoragePools *vboxConnectListStoragePools *vboxStoragePoolLookupByName These functions do not call any vbox API, so I directly move it from vbox_tmpl.c to vbox_storage.c A small improvement is made on vboxConnectListStoragePools. The if condition nnames == 1 is modified to nnames > 0. So if the caller put more than one slot to get active storage pools, the new function will return exactly one, while the old one would only return 0. --- src/Makefile.am | 1 + src/vbox/vbox_storage.c | 106 +++++++++++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 69 --------------------------- src/vbox/vbox_uniformed_api.h | 6 +++ 4 files changed, 113 insertions(+), 69 deletions(-) create mode 100644 src/vbox/vbox_storage.c diff --git a/src/Makefile.am b/src/Makefile.am index 7521bde..b245dd1 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -679,6 +679,7 @@ VBOX_DRIVER_SOURCES = \ vbox/vbox_V4_3.c vbox/vbox_CAPI_v4_3.h \ vbox/vbox_V4_3_4.c vbox/vbox_CAPI_v4_3_4.h \ vbox/vbox_common.c vbox/vbox_common.h \ + vbox/vbox_storage.c \ vbox/vbox_uniformed_api.h \ vbox/vbox_get_driver.h diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c new file mode 100644 index 0000000..8fa7782 --- /dev/null +++ b/src/vbox/vbox_storage.c @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2014 Taowei Luo (uaedante@gmail.com) + * Copyright (C) 2010-2014 Red Hat, Inc. + * Copyright (C) 2008-2009 Sun Microsystems, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include "internal.h" +#include "datatypes.h" +#include "domain_conf.h" +#include "domain_event.h" +#include "virlog.h" +#include "virstring.h" + +#include "vbox_common.h" +#include "vbox_uniformed_api.h" + +#define VIR_FROM_THIS VIR_FROM_VBOX + +VIR_LOG_INIT("vbox.vbox_storage"); + +/** + * The Storage Functions here on + */ + +virDrvOpenStatus vboxStorageOpen(virConnectPtr conn, + virConnectAuthPtr auth ATTRIBUTE_UNUSED, + unsigned int flags) +{ + vboxGlobalData *data = conn->privateData; + + virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); + + if (STRNEQ(conn->driver->name, "VBOX")) + return VIR_DRV_OPEN_DECLINED; + + if ((!data->pFuncs) || (!data->vboxObj) || (!data->vboxSession)) + return VIR_DRV_OPEN_ERROR; + + VIR_DEBUG("vbox storage initialized"); + /* conn->storagePrivateData = some storage specific data */ + return VIR_DRV_OPEN_SUCCESS; +} + +int vboxStorageClose(virConnectPtr conn) +{ + VIR_DEBUG("vbox storage uninitialized"); + conn->storagePrivateData = NULL; + return 0; +} + +int vboxConnectNumOfStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED) +{ + + /** Currently only one pool supported, the default one + * given by ISystemProperties::defaultHardDiskFolder() + */ + + return 1; +} + +int vboxConnectListStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED, + char **const names, int nnames) +{ + int numActive = 0; + + if (nnames > 0 && + VIR_STRDUP(names[numActive], "default-pool") > 0) + numActive++; + return numActive; +} + +virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const char *name) +{ + virStoragePoolPtr ret = NULL; + + /** Current limitation of the function: since + * the default pool doesn't have UUID just assign + * one till vbox can handle pools + */ + if (STREQ("default-pool", name)) { + unsigned char uuid[VIR_UUID_BUFLEN]; + const char *uuidstr = "1deff1ff-1481-464f-967f-a50fe8936cc4"; + + ignore_value(virUUIDParse(uuidstr, uuid)); + + ret = virGetStoragePool(conn, name, uuid, NULL, NULL); + } + + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 8fa03ba..c952331 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2033,75 +2033,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static virDrvOpenStatus vboxStorageOpen(virConnectPtr conn, - virConnectAuthPtr auth ATTRIBUTE_UNUSED, - unsigned int flags) -{ - vboxGlobalData *data = conn->privateData; - - virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); - - if (STRNEQ(conn->driver->name, "VBOX")) - return VIR_DRV_OPEN_DECLINED; - - if ((data->pFuncs == NULL) || - (data->vboxObj == NULL) || - (data->vboxSession == NULL)) - return VIR_DRV_OPEN_ERROR; - - VIR_DEBUG("vbox storage initialized"); - /* conn->storagePrivateData = some storage specific data */ - return VIR_DRV_OPEN_SUCCESS; -} - -static int vboxStorageClose(virConnectPtr conn) -{ - VIR_DEBUG("vbox storage uninitialized"); - conn->storagePrivateData = NULL; - return 0; -} - -static int vboxConnectNumOfStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED) -{ - - /** Currently only one pool supported, the default one - * given by ISystemProperties::defaultHardDiskFolder() - */ - - return 1; -} - -static int vboxConnectListStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED, - char **const names, int nnames) { - int numActive = 0; - - if (nnames == 1 && - VIR_STRDUP(names[numActive], "default-pool") > 0) - numActive++; - return numActive; -} - -static virStoragePoolPtr -vboxStoragePoolLookupByName(virConnectPtr conn, const char *name) -{ - virStoragePoolPtr ret = NULL; - - /** Current limitation of the function: since - * the default pool doesn't have UUID just assign - * one till vbox can handle pools - */ - if (STREQ("default-pool", name)) { - unsigned char uuid[VIR_UUID_BUFLEN]; - const char *uuidstr = "1deff1ff-1481-464f-967f-a50fe8936cc4"; - - ignore_value(virUUIDParse(uuidstr, uuid)); - - ret = virGetStoragePool(conn, name, uuid, NULL, NULL); - } - - return ret; -} - static int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool) { VBOX_OBJECT_CHECK(pool->conn, int, -1); diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index e1790cd..352d170 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -586,6 +586,12 @@ typedef struct { virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid); +virDrvOpenStatus vboxStorageOpen(virConnectPtr conn, virConnectAuthPtr auth, + unsigned int flags); +int vboxStorageClose(virConnectPtr conn); +int vboxConnectNumOfStoragePools(virConnectPtr conn); +int vboxConnectListStoragePools(virConnectPtr conn, char **const names, int nnames); +virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const char *name); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

--- src/vbox/vbox_storage.c | 56 +++++++++++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 54 +++++---------------------------------- src/vbox/vbox_uniformed_api.h | 2 ++ 3 files changed, 64 insertions(+), 48 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 804f723..ffa91a9 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -147,3 +147,59 @@ int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool) return ret; } + +int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames) +{ + vboxGlobalData *data = pool->conn->privateData; + vboxArray hardDisks = VBOX_ARRAY_INITIALIZER; + PRUint32 numActive = 0; + nsresult rc; + size_t i; + int ret = -1; + + if (!data->vboxObj) { + return ret; + } + + rc = gVBoxAPI.UArray.vboxArrayGet(&hardDisks, data->vboxObj, + gVBoxAPI.UArray.handleGetHardDisks(data->vboxObj)); + if (NS_FAILED(rc)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("could not get the volume list in the pool: %s, rc=%08x"), + pool->name, (unsigned)rc); + return ret; + } + + for (i = 0; i < hardDisks.count && numActive < nnames; ++i) { + IHardDisk *hardDisk = hardDisks.items[i]; + PRUint32 hddstate; + char *nameUtf8 = NULL; + PRUnichar *nameUtf16 = NULL; + + if (!hardDisk) + continue; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + continue; + + gVBoxAPI.UIMedium.GetName(hardDisk, &nameUtf16); + + VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8); + VBOX_UTF16_FREE(nameUtf16); + + if (!nameUtf8) + continue; + + VIR_DEBUG("nnames[%d]: %s", numActive, nameUtf8); + if (VIR_STRDUP(names[numActive], nameUtf8) > 0) + numActive++; + + VBOX_UTF8_FREE(nameUtf8); + } + + gVBoxAPI.UArray.vboxArrayRelease(&hardDisks); + ret = numActive; + + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index c78cd44..ac712d8 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2033,54 +2033,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames) { - VBOX_OBJECT_CHECK(pool->conn, int, -1); - vboxArray hardDisks = VBOX_ARRAY_INITIALIZER; - PRUint32 numActive = 0; - nsresult rc; - size_t i; - - rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks); - if (NS_SUCCEEDED(rc)) { - for (i = 0; i < hardDisks.count && numActive < nnames; ++i) { - IHardDisk *hardDisk = hardDisks.items[i]; - - if (hardDisk) { - PRUint32 hddstate; - char *nameUtf8 = NULL; - PRUnichar *nameUtf16 = NULL; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &nameUtf16); - - VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8); - VBOX_UTF16_FREE(nameUtf16); - - if (nameUtf8) { - VIR_DEBUG("nnames[%d]: %s", numActive, nameUtf8); - if (VIR_STRDUP(names[numActive], nameUtf8) > 0) - numActive++; - - VBOX_UTF8_FREE(nameUtf8); - } - } - } - } - - vboxArrayRelease(&hardDisks); - - ret = numActive; - } else { - ret = -1; - virReportError(VIR_ERR_INTERNAL_ERROR, - _("could not get the volume list in the pool: %s, rc=%08x"), - pool->name, (unsigned)rc); - } - - return ret; -} - static virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name) { @@ -4904,6 +4856,11 @@ static nsresult _mediumGetState(IMedium *medium, PRUint32 *state) return medium->vtbl->GetState(medium, state); } +static nsresult _mediumGetName(IMedium *medium, PRUnichar **name) +{ + return medium->vtbl->GetName(medium, name); +} + static nsresult _mediumGetReadOnly(IMedium *medium ATTRIBUTE_UNUSED, PRBool *readOnly ATTRIBUTE_UNUSED) { @@ -5626,6 +5583,7 @@ static vboxUniformedIMedium _UIMedium = { .GetId = _mediumGetId, .GetLocation = _mediumGetLocation, .GetState = _mediumGetState, + .GetName = _mediumGetName, .GetReadOnly = _mediumGetReadOnly, .GetParent = _mediumGetParent, .GetChildren = _mediumGetChildren, diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 4c17051..4a6ec33 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -409,6 +409,7 @@ typedef struct { nsresult (*GetId)(IMedium *medium, vboxIIDUnion *iidu); nsresult (*GetLocation)(IMedium *medium, PRUnichar **location); nsresult (*GetState)(IMedium *medium, PRUint32 *state); + nsresult (*GetName)(IMedium *medium, PRUnichar **name); nsresult (*GetReadOnly)(IMedium *medium, PRBool *readOnly); nsresult (*GetParent)(IMedium *medium, IMedium **parent); nsresult (*GetChildren)(IMedium *medium, PRUint32 *childrenSize, IMedium ***children); @@ -595,6 +596,7 @@ int vboxConnectNumOfStoragePools(virConnectPtr conn); int vboxConnectListStoragePools(virConnectPtr conn, char **const names, int nnames); virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const char *name); int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool); +int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

--- src/vbox/vbox_storage.c | 67 +++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 88 +++++++++-------------------------------- src/vbox/vbox_uniformed_api.h | 3 +- 3 files changed, 88 insertions(+), 70 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 75711f7..805d0d2 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -276,3 +276,70 @@ virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char * return ret; } + +virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key) +{ + vboxGlobalData *data = conn->privateData; + vboxIIDUnion hddIID; + unsigned char uuid[VIR_UUID_BUFLEN]; + IHardDisk *hardDisk = NULL; + PRUnichar *hddNameUtf16 = NULL; + char *hddNameUtf8 = NULL; + PRUint32 hddstate; + nsresult rc; + virStorageVolPtr ret = NULL; + + if (!data->vboxObj) { + return ret; + } + + VBOX_IID_INITIALIZE(&hddIID); + if (!key) + return ret; + + if (virUUIDParse(key, uuid) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("Could not parse UUID from '%s'"), key); + return NULL; + } + + vboxIIDFromUUID(&hddIID, uuid); + rc = gVBoxAPI.UIVirtualBox.GetHardDiskByIID(data->vboxObj, &hddIID, &hardDisk); + if (NS_FAILED(rc)) + goto cleanup; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + goto cleanup; + + gVBoxAPI.UIMedium.GetName(hardDisk, &hddNameUtf16); + if (!hddNameUtf16) + goto cleanup; + + VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8); + if (!hddNameUtf8) { + VBOX_UTF16_FREE(hddNameUtf16); + goto cleanup; + } + + if (vboxConnectNumOfStoragePools(conn) == 1) { + ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key, + NULL, NULL); + VIR_DEBUG("Storage Volume Pool: %s", "default-pool"); + } else { + /* TODO: currently only one default pool and thus + * nothing here, change it when pools are supported + */ + } + + VIR_DEBUG("Storage Volume Name: %s", key); + VIR_DEBUG("Storage Volume key : %s", hddNameUtf8); + + VBOX_UTF8_FREE(hddNameUtf8); + VBOX_UTF16_FREE(hddNameUtf16); + + cleanup: + VBOX_MEDIUM_RELEASE(hardDisk); + vboxIIDUnalloc(&hddIID); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index cc7e35e..e8cfa98 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -104,7 +104,10 @@ typedef IUSBDeviceFilters IUSBCommon; #if VBOX_API_VERSION < 3001000 typedef IHardDiskAttachment IMediumAttachment; -#endif /* VBOX_API_VERSION < 3001000 */ +#else /* VBOX_API_VERSION >= 3001000 */ +typedef IMedium IHardDisk; +typedef IMediumAttachment IHardDiskAttachment; +#endif /* VBOX_API_VERSION >= 3001000 */ #include "vbox_uniformed_api.h" @@ -171,8 +174,6 @@ if (arg)\ #else /* VBOX_API_VERSION >= 3001000 */ -typedef IMedium IHardDisk; -typedef IMediumAttachment IHardDiskAttachment; # define MediaState_Inaccessible MediumState_Inaccessible # define HardDiskVariant_Standard MediumVariant_Standard # define HardDiskVariant_Fixed MediumVariant_Fixed @@ -2034,72 +2035,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) */ static virStorageVolPtr -vboxStorageVolLookupByKey(virConnectPtr conn, const char *key) -{ - VBOX_OBJECT_CHECK(conn, virStorageVolPtr, NULL); - vboxIID hddIID = VBOX_IID_INITIALIZER; - unsigned char uuid[VIR_UUID_BUFLEN]; - IHardDisk *hardDisk = NULL; - nsresult rc; - - if (!key) - return ret; - - if (virUUIDParse(key, uuid) < 0) { - virReportError(VIR_ERR_INVALID_ARG, - _("Could not parse UUID from '%s'"), key); - return NULL; - } - - vboxIIDFromUUID(&hddIID, uuid); -#if VBOX_API_VERSION < 4000000 - rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk); -#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 - rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, &hardDisk); -#else - rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, AccessMode_ReadWrite, - PR_FALSE, &hardDisk); -#endif /* VBOX_API_VERSION >= 4000000 */ - if (NS_SUCCEEDED(rc)) { - PRUint32 hddstate; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { - PRUnichar *hddNameUtf16 = NULL; - char *hddNameUtf8 = NULL; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &hddNameUtf16); - VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8); - - if (hddNameUtf8) { - if (vboxConnectNumOfStoragePools(conn) == 1) { - ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key, - NULL, NULL); - VIR_DEBUG("Storage Volume Pool: %s", "default-pool"); - } else { - /* TODO: currently only one default pool and thus - * nothing here, change it when pools are supported - */ - } - - VIR_DEBUG("Storage Volume Name: %s", key); - VIR_DEBUG("Storage Volume key : %s", hddNameUtf8); - - VBOX_UTF8_FREE(hddNameUtf8); - VBOX_UTF16_FREE(hddNameUtf16); - } - } - - VBOX_MEDIUM_RELEASE(hardDisk); - } - - vboxIIDUnalloc(&hddIID); - return ret; -} - -static virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path) { VBOX_OBJECT_CHECK(conn, virStorageVolPtr, NULL); @@ -3661,6 +3596,20 @@ _virtualboxOpenMedium(IVirtualBox *vboxObj ATTRIBUTE_UNUSED, } static nsresult +_virtualboxGetHardDiskByIID(IVirtualBox *vboxObj, vboxIIDUnion *iidu, IHardDisk **hardDisk) +{ +#if VBOX_API_VERSION < 4000000 + return vboxObj->vtbl->GetHardDisk(vboxObj, IID_MEMBER(value), hardDisk); +#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 + return vboxObj->vtbl->FindMedium(vboxObj, IID_MEMBER(value), DeviceType_HardDisk, + hardDisk); +#else /* VBOX_API_VERSION >= 4002000 */ + return vboxObj->vtbl->OpenMedium(vboxObj, IID_MEMBER(value), DeviceType_HardDisk, + AccessMode_ReadWrite, PR_FALSE, hardDisk); +#endif /* VBOX_API_VERSION >= 4002000 */ +} + +static nsresult _virtualboxFindDHCPServerByNetworkName(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer **server) { return vboxObj->vtbl->FindDHCPServerByNetworkName(vboxObj, name, server); @@ -5340,6 +5289,7 @@ static vboxUniformedIVirtualBox _UIVirtualBox = { .RegisterMachine = _virtualboxRegisterMachine, .FindMedium = _virtualboxFindMedium, .OpenMedium = _virtualboxOpenMedium, + .GetHardDiskByIID = _virtualboxGetHardDiskByIID, .FindDHCPServerByNetworkName = _virtualboxFindDHCPServerByNetworkName, .CreateDHCPServer = _virtualboxCreateDHCPServer, .RemoveDHCPServer = _virtualboxRemoveDHCPServer, diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index a6eb3ef..cdc2ebe 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -198,6 +198,7 @@ typedef struct { nsresult (*RegisterMachine)(IVirtualBox *vboxObj, IMachine *machine); nsresult (*FindMedium)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType, PRUint32 accessMode, IMedium **medium); nsresult (*OpenMedium)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType, PRUint32 accessMode, IMedium **medium); + nsresult (*GetHardDiskByIID)(IVirtualBox *vboxObj, vboxIIDUnion *iidu, IHardDisk **hardDisk); nsresult (*FindDHCPServerByNetworkName)(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer **server); nsresult (*CreateDHCPServer)(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer **server); nsresult (*RemoveDHCPServer)(IVirtualBox *vboxObj, IDHCPServer *server); @@ -598,7 +599,7 @@ virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const char *na int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool); int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames); virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name); - +virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

--- src/vbox/vbox_storage.c | 77 +++++++++++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 77 ----------------------------------------- src/vbox/vbox_uniformed_api.h | 1 + 3 files changed, 78 insertions(+), 77 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 805d0d2..1878139 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -343,3 +343,80 @@ virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key) vboxIIDUnalloc(&hddIID); return ret; } + +virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path) +{ + vboxGlobalData *data = conn->privateData; + PRUnichar *hddPathUtf16 = NULL; + IHardDisk *hardDisk = NULL; + PRUnichar *hddNameUtf16 = NULL; + char *hddNameUtf8 = NULL; + unsigned char uuid[VIR_UUID_BUFLEN]; + char key[VIR_UUID_STRING_BUFLEN] = ""; + vboxIIDUnion hddIID; + PRUint32 hddstate; + nsresult rc; + virStorageVolPtr ret = NULL; + + if (!data->vboxObj) { + return ret; + } + + VBOX_IID_INITIALIZE(&hddIID); + + if (!path) + return ret; + + VBOX_UTF8_TO_UTF16(path, &hddPathUtf16); + + if (!hddPathUtf16) + return ret; + + rc = gVBoxAPI.UIVirtualBox.FindHardDisk(data->vboxObj, hddPathUtf16, + DeviceType_HardDisk, AccessMode_ReadWrite, &hardDisk); + if (NS_FAILED(rc)) + goto cleanup; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + goto cleanup; + + gVBoxAPI.UIMedium.GetName(hardDisk, &hddNameUtf16); + + if (!hddNameUtf16) + goto cleanup; + + VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8); + VBOX_UTF16_FREE(hddNameUtf16); + + if (!hddNameUtf8) + goto cleanup; + + rc = gVBoxAPI.UIMedium.GetId(hardDisk, &hddIID); + if (NS_FAILED(rc)) { + VBOX_UTF8_FREE(hddNameUtf8); + goto cleanup; + } + + vboxIIDToUUID(&hddIID, uuid); + virUUIDFormat(uuid, key); + + /* TODO: currently only one default pool and thus + * the check below, change it when pools are supported + */ + if (vboxConnectNumOfStoragePools(conn) == 1) + ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key, + NULL, NULL); + + VIR_DEBUG("Storage Volume Pool: %s", "default-pool"); + VIR_DEBUG("Storage Volume Name: %s", hddNameUtf8); + VIR_DEBUG("Storage Volume key : %s", key); + + vboxIIDUnalloc(&hddIID); + VBOX_UTF8_FREE(hddNameUtf8); + + cleanup: + VBOX_MEDIUM_RELEASE(hardDisk); + VBOX_UTF16_FREE(hddPathUtf16); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 6c4cd73..224c896 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2034,83 +2034,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static virStorageVolPtr -vboxStorageVolLookupByPath(virConnectPtr conn, const char *path) -{ - VBOX_OBJECT_CHECK(conn, virStorageVolPtr, NULL); - PRUnichar *hddPathUtf16 = NULL; - IHardDisk *hardDisk = NULL; - nsresult rc; - - if (!path) - return ret; - - VBOX_UTF8_TO_UTF16(path, &hddPathUtf16); - - if (!hddPathUtf16) - return ret; - -#if VBOX_API_VERSION < 4000000 - rc = data->vboxObj->vtbl->FindHardDisk(data->vboxObj, hddPathUtf16, &hardDisk); -#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 - rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddPathUtf16, - DeviceType_HardDisk, &hardDisk); -#else - rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj, hddPathUtf16, - DeviceType_HardDisk, AccessMode_ReadWrite, - PR_FALSE, &hardDisk); -#endif /* VBOX_API_VERSION >= 4000000 */ - if (NS_SUCCEEDED(rc)) { - PRUint32 hddstate; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { - PRUnichar *hddNameUtf16 = NULL; - char *hddNameUtf8 = NULL; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetName, &hddNameUtf16); - - if (hddNameUtf16) { - VBOX_UTF16_TO_UTF8(hddNameUtf16, &hddNameUtf8); - VBOX_UTF16_FREE(hddNameUtf16); - } - - if (hddNameUtf8) { - vboxIID hddIID = VBOX_IID_INITIALIZER; - unsigned char uuid[VIR_UUID_BUFLEN]; - char key[VIR_UUID_STRING_BUFLEN] = ""; - - rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID.value); - if (NS_SUCCEEDED(rc)) { - vboxIIDToUUID(&hddIID, uuid); - virUUIDFormat(uuid, key); - - /* TODO: currently only one default pool and thus - * the check below, change it when pools are supported - */ - if (vboxConnectNumOfStoragePools(conn) == 1) - ret = virGetStorageVol(conn, "default-pool", hddNameUtf8, key, - NULL, NULL); - - VIR_DEBUG("Storage Volume Pool: %s", "default-pool"); - VIR_DEBUG("Storage Volume Name: %s", hddNameUtf8); - VIR_DEBUG("Storage Volume key : %s", key); - } - - vboxIIDUnalloc(&hddIID); - } - - VBOX_UTF8_FREE(hddNameUtf8); - } - - VBOX_MEDIUM_RELEASE(hardDisk); - } - - VBOX_UTF16_FREE(hddPathUtf16); - - return ret; -} - static virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, const char *xml, unsigned int flags) diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 385502f..f3650e5 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -601,6 +601,7 @@ int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool); int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames); virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name); virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key); +virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

If the <path> in target element is not given, libvirt will put the new volume in ~/.VirtualBox by default. --- src/vbox/vbox_common.h | 10 ++++ src/vbox/vbox_storage.c | 110 +++++++++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 114 ++++++----------------------------------- src/vbox/vbox_uniformed_api.h | 11 ++++ 4 files changed, 147 insertions(+), 98 deletions(-) diff --git a/src/vbox/vbox_common.h b/src/vbox/vbox_common.h index 9af3129..d318921 100644 --- a/src/vbox/vbox_common.h +++ b/src/vbox/vbox_common.h @@ -290,6 +290,16 @@ enum MediaState MediaState_Deleting = 6 }; +enum HardDiskVariant +{ + HardDiskVariant_Standard = 0, + HardDiskVariant_VmdkSplit2G = 0x01, + HardDiskVariant_VmdkStreamOptimized = 0x04, + HardDiskVariant_VmdkESX = 0x08, + HardDiskVariant_Fixed = 0x10000, + HardDiskVariant_Diff = 0x20000 +}; + # define VBOX_E_OBJECT_NOT_FOUND 0x80BB0001 # define VBOX_E_INVALID_VM_STATE 0x80BB0002 # define VBOX_E_VM_ERROR 0x80BB0003 diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 1878139..1e6ca67 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -26,6 +26,7 @@ #include "domain_event.h" #include "virlog.h" #include "virstring.h" +#include "storage_conf.h" #include "vbox_common.h" #include "vbox_uniformed_api.h" @@ -420,3 +421,112 @@ virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path VBOX_UTF16_FREE(hddPathUtf16); return ret; } + +virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, + const char *xml, unsigned int flags) +{ + vboxGlobalData *data = pool->conn->privateData; + virStorageVolDefPtr def = NULL; + PRUnichar *hddFormatUtf16 = NULL; + PRUnichar *hddNameUtf16 = NULL; + virStoragePoolDef poolDef; + nsresult rc; + vboxIIDUnion hddIID; + unsigned char uuid[VIR_UUID_BUFLEN]; + char key[VIR_UUID_STRING_BUFLEN] = ""; + IHardDisk *hardDisk = NULL; + IProgress *progress = NULL; + PRUint64 logicalSize = 0; + PRUint32 variant = HardDiskVariant_Standard; + resultCodeUnion resultCode; + virStorageVolPtr ret = NULL; + + if (!data->vboxObj) { + return ret; + } + + virCheckFlags(0, NULL); + + /* since there is currently one default pool now + * and virStorageVolDefFormat() just checks it type + * so just assign it for now, change the behaviour + * when vbox supports pools. + */ + memset(&poolDef, 0, sizeof(poolDef)); + poolDef.type = VIR_STORAGE_POOL_DIR; + + if ((def = virStorageVolDefParseString(&poolDef, xml)) == NULL) + goto cleanup; + + if (!def->name || + (def->type != VIR_STORAGE_VOL_FILE)) + goto cleanup; + + /* For now only the vmdk, vpc and vdi type harddisk + * variants can be created. For historical reason, we default to vdi */ + if (def->target.format == VIR_STORAGE_FILE_VMDK) { + VBOX_UTF8_TO_UTF16("VMDK", &hddFormatUtf16); + } else if (def->target.format == VIR_STORAGE_FILE_VPC) { + VBOX_UTF8_TO_UTF16("VHD", &hddFormatUtf16); + } else { + VBOX_UTF8_TO_UTF16("VDI", &hddFormatUtf16); + } + + /* If target.path isn't given, use default path ~/.VirtualBox/image_name */ + if (def->target.path == NULL && + virAsprintf(&def->target.path, "%s/.VirtualBox/%s", virGetUserDirectory(), def->name) < 0) + goto cleanup; + VBOX_UTF8_TO_UTF16(def->target.path, &hddNameUtf16); + + if (!hddFormatUtf16 || !hddNameUtf16) + goto cleanup; + + rc = gVBoxAPI.UIVirtualBox.CreateHardDisk(data->vboxObj, hddFormatUtf16, hddNameUtf16, &hardDisk); + if (NS_FAILED(rc)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not create harddisk, rc=%08x"), + (unsigned)rc); + goto cleanup; + } + + logicalSize = VIR_DIV_UP(def->target.capacity, 1024 * 1024); + + if (def->target.capacity == def->target.allocation) + variant = HardDiskVariant_Fixed; + + rc = gVBoxAPI.UIHardDisk.CreateBaseStorage(hardDisk, logicalSize, variant, &progress); + if (NS_FAILED(rc) || !progress) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not create base storage, rc=%08x"), + (unsigned)rc); + goto cleanup; + } + + gVBoxAPI.UIProgress.WaitForCompletion(progress, -1); + gVBoxAPI.UIProgress.GetResultCode(progress, &resultCode); + if (RC_FAILED(resultCode)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Could not create base storage, rc=%08x"), + (unsigned)resultCode.uResultCode); + goto cleanup; + } + + VBOX_IID_INITIALIZE(&hddIID); + rc = gVBoxAPI.UIMedium.GetId(hardDisk, &hddIID); + if (NS_FAILED(rc)) + goto cleanup; + + vboxIIDToUUID(&hddIID, uuid); + virUUIDFormat(uuid, key); + + ret = virGetStorageVol(pool->conn, pool->name, def->name, key, + NULL, NULL); + + cleanup: + vboxIIDUnalloc(&hddIID); + VBOX_RELEASE(progress); + VBOX_UTF16_FREE(hddFormatUtf16); + VBOX_UTF16_FREE(hddNameUtf16); + virStorageVolDefFree(def); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index c6f027e..7c14c0d 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2034,104 +2034,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, - const char *xml, - unsigned int flags) -{ - VBOX_OBJECT_CHECK(pool->conn, virStorageVolPtr, NULL); - virStorageVolDefPtr def = NULL; - PRUnichar *hddFormatUtf16 = NULL; - PRUnichar *hddNameUtf16 = NULL; - virStoragePoolDef poolDef; - nsresult rc; - - virCheckFlags(0, NULL); - - /* since there is currently one default pool now - * and virStorageVolDefFormat() just checks it type - * so just assign it for now, change the behaviour - * when vbox supports pools. - */ - memset(&poolDef, 0, sizeof(poolDef)); - poolDef.type = VIR_STORAGE_POOL_DIR; - - if ((def = virStorageVolDefParseString(&poolDef, xml)) == NULL) - goto cleanup; - - if (!def->name || - (def->type != VIR_STORAGE_VOL_FILE)) - goto cleanup; - - /* For now only the vmdk, vpc and vdi type harddisk - * variants can be created. For historical reason, we default to vdi */ - if (def->target.format == VIR_STORAGE_FILE_VMDK) { - VBOX_UTF8_TO_UTF16("VMDK", &hddFormatUtf16); - } else if (def->target.format == VIR_STORAGE_FILE_VPC) { - VBOX_UTF8_TO_UTF16("VHD", &hddFormatUtf16); - } else { - VBOX_UTF8_TO_UTF16("VDI", &hddFormatUtf16); - } - - VBOX_UTF8_TO_UTF16(def->name, &hddNameUtf16); - - if (hddFormatUtf16 && hddNameUtf16) { - IHardDisk *hardDisk = NULL; - - rc = data->vboxObj->vtbl->CreateHardDisk(data->vboxObj, hddFormatUtf16, hddNameUtf16, &hardDisk); - if (NS_SUCCEEDED(rc)) { - IProgress *progress = NULL; - PRUint64 logicalSize = VIR_DIV_UP(def->target.capacity, - 1024 * 1024); - PRUint32 variant = HardDiskVariant_Standard; - - if (def->target.capacity == def->target.allocation) - variant = HardDiskVariant_Fixed; - -#if VBOX_API_VERSION < 4003000 - rc = hardDisk->vtbl->CreateBaseStorage(hardDisk, logicalSize, variant, &progress); -#else - rc = hardDisk->vtbl->CreateBaseStorage(hardDisk, logicalSize, 1, &variant, &progress); -#endif - if (NS_SUCCEEDED(rc) && progress) { -#if VBOX_API_VERSION == 2002000 - nsresult resultCode; -#else - PRInt32 resultCode; -#endif - - progress->vtbl->WaitForCompletion(progress, -1); - progress->vtbl->GetResultCode(progress, &resultCode); - - if (NS_SUCCEEDED(resultCode)) { - vboxIID hddIID = VBOX_IID_INITIALIZER; - unsigned char uuid[VIR_UUID_BUFLEN]; - char key[VIR_UUID_STRING_BUFLEN] = ""; - - rc = VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetId, &hddIID.value); - if (NS_SUCCEEDED(rc)) { - vboxIIDToUUID(&hddIID, uuid); - virUUIDFormat(uuid, key); - - ret = virGetStorageVol(pool->conn, pool->name, def->name, key, - NULL, NULL); - } - - vboxIIDUnalloc(&hddIID); - } - - VBOX_RELEASE(progress); - } - } - } - - VBOX_UTF16_FREE(hddFormatUtf16); - VBOX_UTF16_FREE(hddNameUtf16); - - cleanup: - virStorageVolDefFree(def); - return ret; -} - static int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags) { @@ -5123,6 +5025,17 @@ _dhcpServerStop(IDHCPServer *dhcpServer) return dhcpServer->vtbl->Stop(dhcpServer); } +static nsresult +_hardDiskCreateBaseStorage(IHardDisk *hardDisk, PRUint64 logicalSize, + PRUint32 variant, IProgress **progress) +{ +#if VBOX_API_VERSION < 4003000 + return hardDisk->vtbl->CreateBaseStorage(hardDisk, logicalSize, variant, progress); +#else + return hardDisk->vtbl->CreateBaseStorage(hardDisk, logicalSize, 1, &variant, progress); +#endif +} + static bool _machineStateOnline(PRUint32 state) { return ((state >= MachineState_FirstOnline) && @@ -5464,6 +5377,10 @@ static vboxUniformedIDHCPServer _UIDHCPServer = { .Stop = _dhcpServerStop, }; +static vboxUniformedIHardDisk _UIHardDisk = { + .CreateBaseStorage = _hardDiskCreateBaseStorage, +}; + static uniformedMachineStateChecker _machineStateChecker = { .Online = _machineStateOnline, .Inactive = _machineStateInactive, @@ -5520,6 +5437,7 @@ void NAME(InstallUniformedAPI)(vboxUniformedAPI *pVBoxAPI) pVBoxAPI->UIHost = _UIHost; pVBoxAPI->UIHNInterface = _UIHNInterface; pVBoxAPI->UIDHCPServer = _UIDHCPServer; + pVBoxAPI->UIHardDisk = _UIHardDisk; pVBoxAPI->machineStateChecker = _machineStateChecker; #if VBOX_API_VERSION <= 2002000 || VBOX_API_VERSION >= 4000000 diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 39d5d98..d0403ad 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -517,6 +517,14 @@ typedef struct { nsresult (*Stop)(IDHCPServer *dhcpServer); } vboxUniformedIDHCPServer; +/* Functions for IHardDisk, in vbox3.1 and later, it will call the + * corresponding functions in IMedium as IHardDisk does't exist in + * these versions. */ +typedef struct { + nsresult (*CreateBaseStorage)(IHardDisk *hardDisk, PRUint64 logicalSize, + PRUint32 variant, IProgress **progress); +} vboxUniformedIHardDisk; + typedef struct { bool (*Online)(PRUint32 state); bool (*Inactive)(PRUint32 state); @@ -574,6 +582,7 @@ typedef struct { vboxUniformedIHost UIHost; vboxUniformedIHNInterface UIHNInterface; vboxUniformedIDHCPServer UIDHCPServer; + vboxUniformedIHardDisk UIHardDisk; uniformedMachineStateChecker machineStateChecker; /* vbox API features */ bool domainEventCallbacks; @@ -602,6 +611,8 @@ int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int n virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name); virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key); virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path); +virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, + const char *xml, unsigned int flags); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

The API on IHardDiskAttachment is merged into IMediumAttachment. So, we don't need it anymore. --- src/vbox/vbox_storage.c | 160 ++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 202 ++++++----------------------------------- src/vbox/vbox_uniformed_api.h | 6 ++ 3 files changed, 192 insertions(+), 176 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 1e6ca67..45090eb 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -530,3 +530,163 @@ virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, virStorageVolDefFree(def); return ret; } + +int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags) +{ + vboxGlobalData *data = vol->conn->privateData; + unsigned char uuid[VIR_UUID_BUFLEN]; + IHardDisk *hardDisk = NULL; + int deregister = 0; + PRUint32 hddstate = 0; + size_t i = 0; + size_t j = 0; + PRUint32 machineIdsSize = 0; + vboxArray machineIds = VBOX_ARRAY_INITIALIZER; + vboxIIDUnion hddIID; + nsresult rc; + int ret = -1; + + if (!data->vboxObj) { + return ret; + } + + VBOX_IID_INITIALIZE(&hddIID); + virCheckFlags(0, -1); + + if (virUUIDParse(vol->key, uuid) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("Could not parse UUID from '%s'"), vol->key); + return -1; + } + + vboxIIDFromUUID(&hddIID, uuid); + rc = gVBoxAPI.UIVirtualBox.GetHardDiskByIID(data->vboxObj, &hddIID, &hardDisk); + if (NS_FAILED(rc)) + goto cleanup; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + goto cleanup; + + gVBoxAPI.UArray.vboxArrayGet(&machineIds, hardDisk, + gVBoxAPI.UArray.handleMediumGetMachineIds(hardDisk)); + +#if defined WIN32 + /* VirtualBox 2.2 on Windows represents IIDs as GUIDs and the + * machineIds array contains direct instances of the GUID struct + * instead of pointers to the actual struct instances. But there + * is no 128bit width simple item type for a SafeArray to fit a + * GUID in. The largest simple type it 64bit width and VirtualBox + * uses two of this 64bit items to represents one GUID. Therefore, + * we divide the size of the SafeArray by two, to compensate for + * this workaround in VirtualBox */ + if (gVBoxAPI.uVersion >= 2001052 && gVBoxAPI.uVersion < 2002051) + machineIds.count /= 2; +#endif /* !defined WIN32 */ + + machineIdsSize = machineIds.count; + + for (i = 0; i < machineIds.count; i++) { + IMachine *machine = NULL; + vboxIIDUnion machineId; + vboxArray hddAttachments = VBOX_ARRAY_INITIALIZER; + + VBOX_IID_INITIALIZE(&machineId); + vboxIIDFromArrayItem(&machineId, &machineIds, i); + + if (gVBoxAPI.getMachineForSession) { + rc = gVBoxAPI.UIVirtualBox.GetMachine(data->vboxObj, &machineId, &machine); + if (NS_FAILED(rc)) { + virReportError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching uuid")); + break; + } + } + + rc = gVBoxAPI.UISession.Open(data, &machineId, machine); + + if (NS_FAILED(rc)) { + vboxIIDUnalloc(&machineId); + continue; + } + + rc = gVBoxAPI.UISession.GetMachine(data->vboxSession, &machine); + if (NS_FAILED(rc)) + goto cleanupLoop; + + gVBoxAPI.UArray.vboxArrayGet(&hddAttachments, machine, + gVBoxAPI.UArray.handleMachineGetMediumAttachments(machine)); + + for (j = 0; j < hddAttachments.count; j++) { + IMediumAttachment *hddAttachment = hddAttachments.items[j]; + IHardDisk *hdd = NULL; + vboxIIDUnion iid; + + if (!hddAttachment) + continue; + + rc = gVBoxAPI.UIMediumAttachment.GetMedium(hddAttachment, &hdd); + if (NS_FAILED(rc) || !hdd) + continue; + + VBOX_IID_INITIALIZE(&iid); + rc = gVBoxAPI.UIMedium.GetId(hdd, &iid); + if (NS_FAILED(rc)) { + VBOX_MEDIUM_RELEASE(hdd); + continue; + } + + DEBUGIID("HardDisk (to delete) UUID", &hddIID); + DEBUGIID("HardDisk (currently processing) UUID", &iid); + + if (vboxIIDIsEqual(&hddIID, &iid)) { + PRUnichar *controller = NULL; + PRInt32 port = 0; + PRInt32 device = 0; + + DEBUGIID("Found HardDisk to delete, UUID", &hddIID); + + gVBoxAPI.UIMediumAttachment.GetController(hddAttachment, &controller); + gVBoxAPI.UIMediumAttachment.GetPort(hddAttachment, &port); + gVBoxAPI.UIMediumAttachment.GetDevice(hddAttachment, &device); + + rc = gVBoxAPI.UIMachine.DetachDevice(machine, controller, port, device); + if (NS_SUCCEEDED(rc)) { + rc = gVBoxAPI.UIMachine.SaveSettings(machine); + VIR_DEBUG("saving machine settings"); + deregister++; + VIR_DEBUG("deregistering hdd:%d", deregister); + } + + VBOX_UTF16_FREE(controller); + } + vboxIIDUnalloc(&iid); + VBOX_MEDIUM_RELEASE(hdd); + } + + cleanupLoop: + gVBoxAPI.UArray.vboxArrayRelease(&hddAttachments); + VBOX_RELEASE(machine); + gVBoxAPI.UISession.Close(data->vboxSession); + vboxIIDUnalloc(&machineId); + } + + gVBoxAPI.UArray.vboxArrayUnalloc(&machineIds); + + if (machineIdsSize == 0 || machineIdsSize == deregister) { + IProgress *progress = NULL; + rc = gVBoxAPI.UIHardDisk.DeleteStorage(hardDisk, &progress); + + if (NS_SUCCEEDED(rc) && progress) { + gVBoxAPI.UIProgress.WaitForCompletion(progress, -1); + VBOX_RELEASE(progress); + DEBUGIID("HardDisk deleted, UUID", &hddIID); + ret = 0; + } + } + + cleanup: + VBOX_MEDIUM_RELEASE(hardDisk); + vboxIIDUnalloc(&hddIID); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 8aed0d6..71dbedd 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -106,7 +106,6 @@ typedef IUSBDeviceFilters IUSBCommon; typedef IHardDiskAttachment IMediumAttachment; #else /* VBOX_API_VERSION >= 3001000 */ typedef IMedium IHardDisk; -typedef IMediumAttachment IHardDiskAttachment; #endif /* VBOX_API_VERSION >= 3001000 */ #include "vbox_uniformed_api.h" @@ -2034,181 +2033,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static int vboxStorageVolDelete(virStorageVolPtr vol, - unsigned int flags) -{ - VBOX_OBJECT_CHECK(vol->conn, int, -1); - vboxIID hddIID = VBOX_IID_INITIALIZER; - unsigned char uuid[VIR_UUID_BUFLEN]; - IHardDisk *hardDisk = NULL; - int deregister = 0; - nsresult rc; - size_t i = 0; - size_t j = 0; - - virCheckFlags(0, -1); - - if (virUUIDParse(vol->key, uuid) < 0) { - virReportError(VIR_ERR_INVALID_ARG, - _("Could not parse UUID from '%s'"), vol->key); - return -1; - } - - vboxIIDFromUUID(&hddIID, uuid); -#if VBOX_API_VERSION < 4000000 - rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk); -#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 - rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, &hardDisk); -#else - rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, AccessMode_ReadWrite, - PR_FALSE, &hardDisk); -#endif /* VBOX_API_VERSION >= 4000000 */ - if (NS_SUCCEEDED(rc)) { - PRUint32 hddstate; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { - PRUint32 machineIdsSize = 0; - vboxArray machineIds = VBOX_ARRAY_INITIALIZER; - -#if VBOX_API_VERSION < 3001000 - vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->imedium.GetMachineIds); -#else /* VBOX_API_VERSION >= 3001000 */ - vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->GetMachineIds); -#endif /* VBOX_API_VERSION >= 3001000 */ - -#if VBOX_API_VERSION == 2002000 && defined WIN32 - /* VirtualBox 2.2 on Windows represents IIDs as GUIDs and the - * machineIds array contains direct instances of the GUID struct - * instead of pointers to the actual struct instances. But there - * is no 128bit width simple item type for a SafeArray to fit a - * GUID in. The largest simple type it 64bit width and VirtualBox - * uses two of this 64bit items to represents one GUID. Therefore, - * we divide the size of the SafeArray by two, to compensate for - * this workaround in VirtualBox */ - machineIds.count /= 2; -#endif /* VBOX_API_VERSION >= 2002000 */ - - machineIdsSize = machineIds.count; - - for (i = 0; i < machineIds.count; i++) { - IMachine *machine = NULL; - vboxIID machineId = VBOX_IID_INITIALIZER; - - vboxIIDFromArrayItem(&machineId, &machineIds, i); - -#if VBOX_API_VERSION >= 4000000 - rc = VBOX_OBJECT_GET_MACHINE(machineId.value, &machine); - if (NS_FAILED(rc)) { - virReportError(VIR_ERR_NO_DOMAIN, "%s", - _("no domain with matching uuid")); - break; - } -#endif - - rc = VBOX_SESSION_OPEN(machineId.value, machine); - - if (NS_SUCCEEDED(rc)) { - - rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine); - if (NS_SUCCEEDED(rc)) { - vboxArray hddAttachments = VBOX_ARRAY_INITIALIZER; - -#if VBOX_API_VERSION < 3001000 - vboxArrayGet(&hddAttachments, machine, - machine->vtbl->GetHardDiskAttachments); -#else /* VBOX_API_VERSION >= 3001000 */ - vboxArrayGet(&hddAttachments, machine, - machine->vtbl->GetMediumAttachments); -#endif /* VBOX_API_VERSION >= 3001000 */ - for (j = 0; j < hddAttachments.count; j++) { - IHardDiskAttachment *hddAttachment = hddAttachments.items[j]; - - if (hddAttachment) { - IHardDisk *hdd = NULL; - -#if VBOX_API_VERSION < 3001000 - rc = hddAttachment->vtbl->GetHardDisk(hddAttachment, &hdd); -#else /* VBOX_API_VERSION >= 3001000 */ - rc = hddAttachment->vtbl->GetMedium(hddAttachment, &hdd); -#endif /* VBOX_API_VERSION >= 3001000 */ - if (NS_SUCCEEDED(rc) && hdd) { - vboxIID iid = VBOX_IID_INITIALIZER; - - rc = VBOX_MEDIUM_FUNC_ARG1(hdd, GetId, &iid.value); - if (NS_SUCCEEDED(rc)) { - - DEBUGIID("HardDisk (to delete) UUID", hddIID.value); - DEBUGIID("HardDisk (currently processing) UUID", iid.value); - - if (vboxIIDIsEqual(&hddIID, &iid)) { - PRUnichar *controller = NULL; - PRInt32 port = 0; - PRInt32 device = 0; - - DEBUGIID("Found HardDisk to delete, UUID", hddIID.value); - - hddAttachment->vtbl->GetController(hddAttachment, &controller); - hddAttachment->vtbl->GetPort(hddAttachment, &port); - hddAttachment->vtbl->GetDevice(hddAttachment, &device); - -#if VBOX_API_VERSION < 3001000 - rc = machine->vtbl->DetachHardDisk(machine, controller, port, device); -#else /* VBOX_API_VERSION >= 3001000 */ - rc = machine->vtbl->DetachDevice(machine, controller, port, device); -#endif /* VBOX_API_VERSION >= 3001000 */ - if (NS_SUCCEEDED(rc)) { - rc = machine->vtbl->SaveSettings(machine); - VIR_DEBUG("saving machine settings"); - } - - if (NS_SUCCEEDED(rc)) { - deregister++; - VIR_DEBUG("deregistering hdd:%d", deregister); - } - - VBOX_UTF16_FREE(controller); - } - vboxIIDUnalloc(&iid); - } - VBOX_MEDIUM_RELEASE(hdd); - } - } - } - vboxArrayRelease(&hddAttachments); - VBOX_RELEASE(machine); - } - VBOX_SESSION_CLOSE(); - } - - vboxIIDUnalloc(&machineId); - } - - vboxArrayUnalloc(&machineIds); - - if (machineIdsSize == 0 || machineIdsSize == deregister) { - IProgress *progress = NULL; - rc = hardDisk->vtbl->DeleteStorage(hardDisk, &progress); - - if (NS_SUCCEEDED(rc) && progress) { - progress->vtbl->WaitForCompletion(progress, -1); - VBOX_RELEASE(progress); - DEBUGIID("HardDisk deleted, UUID", hddIID.value); - ret = 0; - } - } - } - - VBOX_MEDIUM_RELEASE(hardDisk); - } - - vboxIIDUnalloc(&hddIID); - - return ret; -} - static int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info) { @@ -3236,6 +3060,11 @@ static void* _handleMediumGetSnapshotIds(IMedium *medium) return medium->vtbl->GetSnapshotIds; } +static void* _handleMediumGetMachineIds(IMedium *medium) +{ + return medium->vtbl->GetMachineIds; +} + static void* _handleHostGetNetworkInterfaces(IHost *host) { return host->vtbl->GetNetworkInterfaces; @@ -3548,6 +3377,17 @@ _machineFindSnapshot(IMachine *machine, vboxIIDUnion *iidu, ISnapshot **snapshot } static nsresult +_machineDetachDevice(IMachine *machine, PRUnichar *name, + PRInt32 controllerPort, PRInt32 device) +{ +#if VBOX_API_VERSION < 3001000 + return machine->vtbl->DetachHardDisk(machine, name, controllerPort, device); +#else /* VBOX_API_VERSION >= 3001000 */ + return machine->vtbl->DetachDevice(machine, name, controllerPort, device); +#endif /* VBOX_API_VERSION >= 3001000 */ +} + +static nsresult _machineGetAccessible(IMachine *machine, PRBool *isAccessible) { return machine->vtbl->GetAccessible(machine, isAccessible); @@ -5035,6 +4875,12 @@ _hardDiskCreateBaseStorage(IHardDisk *hardDisk, PRUint64 logicalSize, #endif } +static nsresult +_hardDiskDeleteStorage(IHardDisk *hardDisk, IProgress **progress) +{ + return hardDisk->vtbl->DeleteStorage(hardDisk, progress); +} + static bool _machineStateOnline(PRUint32 state) { return ((state >= MachineState_FirstOnline) && @@ -5094,6 +4940,7 @@ static vboxUniformedArray _UArray = { .vboxArrayGet = vboxArrayGet, .vboxArrayGetWithIIDArg = _vboxArrayGetWithIIDArg, .vboxArrayRelease = vboxArrayRelease, + .vboxArrayUnalloc = vboxArrayUnalloc, .handleGetMachines = _handleGetMachines, .handleGetHardDisks = _handleGetHardDisks, .handleUSBGetDeviceFilters = _handleUSBGetDeviceFilters, @@ -5102,6 +4949,7 @@ static vboxUniformedArray _UArray = { .handleSnapshotGetChildren = _handleSnapshotGetChildren, .handleMediumGetChildren = _handleMediumGetChildren, .handleMediumGetSnapshotIds = _handleMediumGetSnapshotIds, + .handleMediumGetMachineIds = _handleMediumGetMachineIds, .handleHostGetNetworkInterfaces = _handleHostGetNetworkInterfaces, }; @@ -5136,6 +4984,7 @@ static vboxUniformedIMachine _UIMachine = { .LaunchVMProcess = _machineLaunchVMProcess, .Unregister = _machineUnregister, .FindSnapshot = _machineFindSnapshot, + .DetachDevice = _machineDetachDevice, .GetAccessible = _machineGetAccessible, .GetState = _machineGetState, .GetName = _machineGetName, @@ -5378,6 +5227,7 @@ static vboxUniformedIDHCPServer _UIDHCPServer = { static vboxUniformedIHardDisk _UIHardDisk = { .CreateBaseStorage = _hardDiskCreateBaseStorage, + .DeleteStorage = _hardDiskDeleteStorage, }; static uniformedMachineStateChecker _machineStateChecker = { diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 337ae9c..75299e3 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -168,6 +168,7 @@ typedef struct { nsresult (*vboxArrayGet)(vboxArray *array, void *self, void *getter); nsresult (*vboxArrayGetWithIIDArg)(vboxArray *array, void *self, void *getter, vboxIIDUnion *iidu); void (*vboxArrayRelease)(vboxArray *array); + void (*vboxArrayUnalloc)(vboxArray *array); /* Generate function pointers for vboxArrayGet */ void* (*handleGetMachines)(IVirtualBox *vboxObj); void* (*handleGetHardDisks)(IVirtualBox *vboxObj); @@ -177,6 +178,7 @@ typedef struct { void* (*handleSnapshotGetChildren)(ISnapshot *snapshot); void* (*handleMediumGetChildren)(IMedium *medium); void* (*handleMediumGetSnapshotIds)(IMedium *medium); + void* (*handleMediumGetMachineIds)(IMedium *medium); void* (*handleHostGetNetworkInterfaces)(IHost *host); } vboxUniformedArray; @@ -225,6 +227,8 @@ typedef struct { nsresult (*Unregister)(IMachine *machine, PRUint32 cleanupMode, PRUint32 *aMediaSize, IMedium ***aMedia); nsresult (*FindSnapshot)(IMachine *machine, vboxIIDUnion *iidu, ISnapshot **snapshot); + nsresult (*DetachDevice)(IMachine *machine, PRUnichar *name, + PRInt32 controllerPort, PRInt32 device); nsresult (*GetAccessible)(IMachine *machine, PRBool *isAccessible); nsresult (*GetState)(IMachine *machine, PRUint32 *state); nsresult (*GetName)(IMachine *machine, PRUnichar **name); @@ -523,6 +527,7 @@ typedef struct { typedef struct { nsresult (*CreateBaseStorage)(IHardDisk *hardDisk, PRUint64 logicalSize, PRUint32 variant, IProgress **progress); + nsresult (*DeleteStorage)(IHardDisk *hardDisk, IProgress **progress); } vboxUniformedIHardDisk; typedef struct { @@ -613,6 +618,7 @@ virStorageVolPtr vboxStorageVolLookupByKey(virConnectPtr conn, const char *key); virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path); virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, const char *xml, unsigned int flags); +int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

--- src/vbox/vbox_storage.c | 56 +++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 100 +++++++++++++---------------------------- src/vbox/vbox_uniformed_api.h | 3 ++ 3 files changed, 89 insertions(+), 70 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 45090eb..e96d159 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -690,3 +690,59 @@ int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags) vboxIIDUnalloc(&hddIID); return ret; } + +int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info) +{ + vboxGlobalData *data = vol->conn->privateData; + IHardDisk *hardDisk = NULL; + unsigned char uuid[VIR_UUID_BUFLEN]; + PRUint32 hddstate; + PRUint64 hddLogicalSize = 0; + PRUint64 hddActualSize = 0; + vboxIIDUnion hddIID; + nsresult rc; + int ret = -1; + + if (!data->vboxObj) { + return ret; + } + + if (!info) + return ret; + + if (virUUIDParse(vol->key, uuid) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("Could not parse UUID from '%s'"), vol->key); + return ret; + } + + VBOX_IID_INITIALIZE(&hddIID); + vboxIIDFromUUID(&hddIID, uuid); + rc = gVBoxAPI.UIVirtualBox.GetHardDiskByIID(data->vboxObj, &hddIID, &hardDisk); + if (NS_FAILED(rc)) + goto cleanup; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + goto cleanup; + + info->type = VIR_STORAGE_VOL_FILE; + + gVBoxAPI.UIHardDisk.GetLogicalSizeInByte(hardDisk, &hddLogicalSize); + info->capacity = hddLogicalSize; + + gVBoxAPI.UIMedium.GetSize(hardDisk, &hddActualSize); + info->allocation = hddActualSize; + + ret = 0; + + VIR_DEBUG("Storage Volume Name: %s", vol->name); + VIR_DEBUG("Storage Volume Type: %s", info->type == VIR_STORAGE_VOL_BLOCK ? "Block" : "File"); + VIR_DEBUG("Storage Volume Capacity: %llu", info->capacity); + VIR_DEBUG("Storage Volume Allocation: %llu", info->allocation); + + cleanup: + VBOX_MEDIUM_RELEASE(hardDisk); + vboxIIDUnalloc(&hddIID); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 71dbedd..5293710 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2033,76 +2033,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) * The Storage Functions here on */ -static int -vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info) -{ - VBOX_OBJECT_CHECK(vol->conn, int, -1); - IHardDisk *hardDisk = NULL; - unsigned char uuid[VIR_UUID_BUFLEN]; - vboxIID hddIID = VBOX_IID_INITIALIZER; - nsresult rc; - - if (!info) - return ret; - - if (virUUIDParse(vol->key, uuid) < 0) { - virReportError(VIR_ERR_INVALID_ARG, - _("Could not parse UUID from '%s'"), vol->key); - return ret; - } - - vboxIIDFromUUID(&hddIID, uuid); -#if VBOX_API_VERSION < 4000000 - rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk); -#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 - rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, &hardDisk); -#else - rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, AccessMode_ReadWrite, - PR_FALSE, &hardDisk); -#endif /* VBOX_API_VERSION >= 4000000 */ - if (NS_SUCCEEDED(rc)) { - PRUint32 hddstate; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { -#if VBOX_API_VERSION < 4000000 - PRUint64 hddLogicalSize; - PRUint64 hddActualSize; -#else /* VBOX_API_VERSION >= 4000000 */ - PRInt64 hddLogicalSize; - PRInt64 hddActualSize; -#endif /* VBOX_API_VERSION >= 4000000 */ - - info->type = VIR_STORAGE_VOL_FILE; - - hardDisk->vtbl->GetLogicalSize(hardDisk, &hddLogicalSize); -#if VBOX_API_VERSION < 4000000 - info->capacity = hddLogicalSize * 1024 * 1024; /* MB => Bytes */ -#else /* VBOX_API_VERSION >= 4000000 */ - info->capacity = hddLogicalSize; -#endif /* VBOX_API_VERSION >= 4000000 */ - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetSize, &hddActualSize); - info->allocation = hddActualSize; - - ret = 0; - - VIR_DEBUG("Storage Volume Name: %s", vol->name); - VIR_DEBUG("Storage Volume Type: %s", info->type == VIR_STORAGE_VOL_BLOCK ? "Block" : "File"); - VIR_DEBUG("Storage Volume Capacity: %llu", info->capacity); - VIR_DEBUG("Storage Volume Allocation: %llu", info->allocation); - } - - VBOX_MEDIUM_RELEASE(hardDisk); - } - - vboxIIDUnalloc(&hddIID); - - return ret; -} - static char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags) { VBOX_OBJECT_CHECK(vol->conn, char *, NULL); @@ -4407,6 +4337,19 @@ static nsresult _mediumGetName(IMedium *medium, PRUnichar **name) return medium->vtbl->GetName(medium, name); } +static nsresult _mediumGetSize(IMedium *medium, PRUint64 *uSize) +{ +#if VBOX_API_VERSION < 4000000 + return medium->vtbl->GetSize(medium, uSize); +#else /* VBOX_API_VERSION >= 4000000 */ + nsresult rc; + PRInt64 Size; + rc = medium->vtbl->GetSize(medium, &Size); + *uSize = Size; + return rc; +#endif /* VBOX_API_VERSION >= 4000000 */ +} + static nsresult _mediumGetReadOnly(IMedium *medium ATTRIBUTE_UNUSED, PRBool *readOnly ATTRIBUTE_UNUSED) { @@ -4881,6 +4824,21 @@ _hardDiskDeleteStorage(IHardDisk *hardDisk, IProgress **progress) return hardDisk->vtbl->DeleteStorage(hardDisk, progress); } +static nsresult +_hardDiskGetLogicalSizeInByte(IHardDisk *hardDisk, PRUint64 *uLogicalSize) +{ + nsresult rc; +#if VBOX_API_VERSION < 4000000 + rc = hardDisk->vtbl->GetLogicalSize(hardDisk, uLogicalSize); + *uLogicalSize *= 1024 * 1024; /* MB => Bytes */ +#else /* VBOX_API_VERSION >= 4000000 */ + PRInt64 logicalSize; + rc = hardDisk->vtbl->GetLogicalSize(hardDisk, &logicalSize); + *uLogicalSize = logicalSize; +#endif /* VBOX_API_VERSION >= 4000000 */ + return rc; +} + static bool _machineStateOnline(PRUint32 state) { return ((state >= MachineState_FirstOnline) && @@ -5150,6 +5108,7 @@ static vboxUniformedIMedium _UIMedium = { .GetLocation = _mediumGetLocation, .GetState = _mediumGetState, .GetName = _mediumGetName, + .GetSize = _mediumGetSize, .GetReadOnly = _mediumGetReadOnly, .GetParent = _mediumGetParent, .GetChildren = _mediumGetChildren, @@ -5228,6 +5187,7 @@ static vboxUniformedIDHCPServer _UIDHCPServer = { static vboxUniformedIHardDisk _UIHardDisk = { .CreateBaseStorage = _hardDiskCreateBaseStorage, .DeleteStorage = _hardDiskDeleteStorage, + .GetLogicalSizeInByte = _hardDiskGetLogicalSizeInByte, }; static uniformedMachineStateChecker _machineStateChecker = { diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 75299e3..5360fa4 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -416,6 +416,7 @@ typedef struct { nsresult (*GetLocation)(IMedium *medium, PRUnichar **location); nsresult (*GetState)(IMedium *medium, PRUint32 *state); nsresult (*GetName)(IMedium *medium, PRUnichar **name); + nsresult (*GetSize)(IMedium *medium, PRUint64 *uSize); nsresult (*GetReadOnly)(IMedium *medium, PRBool *readOnly); nsresult (*GetParent)(IMedium *medium, IMedium **parent); nsresult (*GetChildren)(IMedium *medium, PRUint32 *childrenSize, IMedium ***children); @@ -528,6 +529,7 @@ typedef struct { nsresult (*CreateBaseStorage)(IHardDisk *hardDisk, PRUint64 logicalSize, PRUint32 variant, IProgress **progress); nsresult (*DeleteStorage)(IHardDisk *hardDisk, IProgress **progress); + nsresult (*GetLogicalSizeInByte)(IHardDisk *hardDisk, PRUint64 *uLogicalSize); } vboxUniformedIHardDisk; typedef struct { @@ -619,6 +621,7 @@ virStorageVolPtr vboxStorageVolLookupByPath(virConnectPtr conn, const char *path virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, const char *xml, unsigned int flags); int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags); +int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

--- src/vbox/vbox_storage.c | 55 +++++++++++++++++++++++++++++++++++++ src/vbox/vbox_tmpl.c | 61 ----------------------------------------- src/vbox/vbox_uniformed_api.h | 1 + 3 files changed, 56 insertions(+), 61 deletions(-) diff --git a/src/vbox/vbox_storage.c b/src/vbox/vbox_storage.c index 8a3b5a0..2211630 100644 --- a/src/vbox/vbox_storage.c +++ b/src/vbox/vbox_storage.c @@ -839,3 +839,58 @@ char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags) vboxIIDUnalloc(&hddIID); return ret; } + +char *vboxStorageVolGetPath(virStorageVolPtr vol) +{ + vboxGlobalData *data = vol->conn->privateData; + IHardDisk *hardDisk = NULL; + PRUnichar *hddLocationUtf16 = NULL; + char *hddLocationUtf8 = NULL; + unsigned char uuid[VIR_UUID_BUFLEN]; + vboxIIDUnion hddIID; + PRUint32 hddstate; + nsresult rc; + char *ret = NULL; + + if (!data->vboxObj) { + return ret; + } + + if (virUUIDParse(vol->key, uuid) < 0) { + virReportError(VIR_ERR_INVALID_ARG, + _("Could not parse UUID from '%s'"), vol->key); + return ret; + } + + VBOX_IID_INITIALIZE(&hddIID); + vboxIIDFromUUID(&hddIID, uuid); + rc = gVBoxAPI.UIVirtualBox.GetHardDiskByIID(data->vboxObj, &hddIID, &hardDisk); + if (NS_FAILED(rc)) + goto cleanup; + + gVBoxAPI.UIMedium.GetState(hardDisk, &hddstate); + if (hddstate == MediaState_Inaccessible) + goto cleanup; + + gVBoxAPI.UIMedium.GetLocation(hardDisk, &hddLocationUtf16); + if (!hddLocationUtf16) + goto cleanup; + + VBOX_UTF16_TO_UTF8(hddLocationUtf16, &hddLocationUtf8); + if (!hddLocationUtf8) + goto cleanup; + + ignore_value(VIR_STRDUP(ret, hddLocationUtf8)); + + VIR_DEBUG("Storage Volume Name: %s", vol->name); + VIR_DEBUG("Storage Volume Path: %s", hddLocationUtf8); + VIR_DEBUG("Storage Volume Pool: %s", vol->pool); + + VBOX_UTF8_FREE(hddLocationUtf8); + + cleanup: + VBOX_UTF16_FREE(hddLocationUtf16); + VBOX_MEDIUM_RELEASE(hardDisk); + vboxIIDUnalloc(&hddIID); + return ret; +} diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 3c8490a..e74c3c4 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -2029,67 +2029,6 @@ _registerDomainEvent(virHypervisorDriverPtr driver) #endif /* !(VBOX_API_VERSION == 2002000 || VBOX_API_VERSION >= 4000000) */ -/** - * The Storage Functions here on - */ - -static char *vboxStorageVolGetPath(virStorageVolPtr vol) { - VBOX_OBJECT_CHECK(vol->conn, char *, NULL); - IHardDisk *hardDisk = NULL; - unsigned char uuid[VIR_UUID_BUFLEN]; - vboxIID hddIID = VBOX_IID_INITIALIZER; - nsresult rc; - - if (virUUIDParse(vol->key, uuid) < 0) { - virReportError(VIR_ERR_INVALID_ARG, - _("Could not parse UUID from '%s'"), vol->key); - return ret; - } - - vboxIIDFromUUID(&hddIID, uuid); -#if VBOX_API_VERSION < 4000000 - rc = data->vboxObj->vtbl->GetHardDisk(data->vboxObj, hddIID.value, &hardDisk); -#elif VBOX_API_VERSION >= 4000000 && VBOX_API_VERSION < 4002000 - rc = data->vboxObj->vtbl->FindMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, &hardDisk); -#else - rc = data->vboxObj->vtbl->OpenMedium(data->vboxObj, hddIID.value, - DeviceType_HardDisk, AccessMode_ReadWrite, - PR_FALSE, &hardDisk); -#endif /* VBOX_API_VERSION >= 4000000 */ - if (NS_SUCCEEDED(rc)) { - PRUint32 hddstate; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate); - if (hddstate != MediaState_Inaccessible) { - PRUnichar *hddLocationUtf16 = NULL; - char *hddLocationUtf8 = NULL; - - VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetLocation, &hddLocationUtf16); - - VBOX_UTF16_TO_UTF8(hddLocationUtf16, &hddLocationUtf8); - if (hddLocationUtf8) { - - ignore_value(VIR_STRDUP(ret, hddLocationUtf8)); - - VIR_DEBUG("Storage Volume Name: %s", vol->name); - VIR_DEBUG("Storage Volume Path: %s", hddLocationUtf8); - VIR_DEBUG("Storage Volume Pool: %s", vol->pool); - - VBOX_UTF8_FREE(hddLocationUtf8); - } - - VBOX_UTF16_FREE(hddLocationUtf16); - } - - VBOX_MEDIUM_RELEASE(hardDisk); - } - - vboxIIDUnalloc(&hddIID); - - return ret; -} - static int _pfnInitialize(vboxGlobalData *data) { data->pFuncs = g_pfnGetFunctions(VBOX_XPCOMC_VERSION); diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h index 70deb33..c426f8a 100644 --- a/src/vbox/vbox_uniformed_api.h +++ b/src/vbox/vbox_uniformed_api.h @@ -624,6 +624,7 @@ virStorageVolPtr vboxStorageVolCreateXML(virStoragePoolPtr pool, int vboxStorageVolDelete(virStorageVolPtr vol, unsigned int flags); int vboxStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info); char *vboxStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags); +char *vboxStorageVolGetPath(virStorageVolPtr vol); /* Version specified functions for installing uniformed API */ void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI); -- 1.7.9.5

After rewriting the whole driver, Only version specified code is remained in vbox_tmpl.c. So, this patch removes those unused macros header files in vbox_tmpl.c. --- src/vbox/vbox_tmpl.c | 60 +------------------------------------------------- 1 file changed, 1 insertion(+), 59 deletions(-) diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index b4d67c3..acaada0 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -42,24 +42,10 @@ #include "internal.h" #include "datatypes.h" #include "domain_conf.h" -#include "snapshot_conf.h" -#include "vbox_snapshot_conf.h" -#include "network_conf.h" -#include "virerror.h" #include "domain_event.h" -#include "storage_conf.h" -#include "virstoragefile.h" -#include "viruuid.h" #include "viralloc.h" -#include "nodeinfo.h" #include "virlog.h" -#include "vbox_driver.h" -#include "configmake.h" -#include "virfile.h" -#include "fdstream.h" -#include "viruri.h" #include "virstring.h" -#include "virtime.h" #include "virutil.h" /* This one changes from version to version. */ @@ -133,19 +119,9 @@ VIR_LOG_INIT("vbox.vbox_tmpl"); } \ } while (0) -#define VBOX_COM_UNALLOC_MEM(arg) \ - do { \ - if (arg) { \ - data->pFuncs->pfnComUnallocMem(arg); \ - (arg) = NULL; \ - } \ - } while (0) - #define VBOX_UTF16_TO_UTF8(arg1, arg2) data->pFuncs->pfnUtf16ToUtf8(arg1, arg2) #define VBOX_UTF8_TO_UTF16(arg1, arg2) data->pFuncs->pfnUtf8ToUtf16(arg1, arg2) -#define VBOX_ADDREF(arg) (arg)->vtbl->nsisupports.AddRef((nsISupports *)(arg)) - #define VBOX_RELEASE(arg) \ do { \ if (arg) { \ @@ -154,34 +130,12 @@ VIR_LOG_INIT("vbox.vbox_tmpl"); } \ } while (0) -#define VBOX_OBJECT_CHECK(conn, type, value) \ -vboxGlobalData *data = conn->privateData;\ -type ret = value;\ -if (!data->vboxObj) {\ - return ret;\ -} - #if VBOX_API_VERSION < 3001000 - # define VBOX_MEDIUM_RELEASE(arg) \ if (arg)\ (arg)->vtbl->imedium.nsisupports.Release((nsISupports *)(arg)) -# define VBOX_MEDIUM_FUNC_ARG1(object, func, arg1) \ - (object)->vtbl->imedium.func((IMedium *)(object), arg1) -# define VBOX_MEDIUM_FUNC_ARG2(object, func, arg1, arg2) \ - (object)->vtbl->imedium.func((IMedium *)(object), arg1, arg2) - #else /* VBOX_API_VERSION >= 3001000 */ - -# define MediaState_Inaccessible MediumState_Inaccessible -# define HardDiskVariant_Standard MediumVariant_Standard -# define HardDiskVariant_Fixed MediumVariant_Fixed # define VBOX_MEDIUM_RELEASE(arg) VBOX_RELEASE(arg) -# define VBOX_MEDIUM_FUNC_ARG1(object, func, arg1) \ - (object)->vtbl->func(object, arg1) -# define VBOX_MEDIUM_FUNC_ARG2(object, func, arg1, arg2) \ - (object)->vtbl->func(object, arg1, arg2) - #endif /* VBOX_API_VERSION >= 3001000 */ #define DEBUGPRUnichar(msg, strUtf16) \ @@ -229,29 +183,17 @@ static vboxGlobalData *g_pVBoxGlobalData = NULL; #if VBOX_API_VERSION < 4000000 -# define VBOX_OBJECT_GET_MACHINE(/* in */ iid_value, /* out */ machine) \ - data->vboxObj->vtbl->GetMachine(data->vboxObj, iid_value, machine) - # define VBOX_SESSION_OPEN(/* in */ iid_value, /* unused */ machine) \ data->vboxObj->vtbl->OpenSession(data->vboxObj, data->vboxSession, iid_value) -# define VBOX_SESSION_OPEN_EXISTING(/* in */ iid_value, /* unused */ machine) \ - data->vboxObj->vtbl->OpenExistingSession(data->vboxObj, data->vboxSession, iid_value) - # define VBOX_SESSION_CLOSE() \ data->vboxSession->vtbl->Close(data->vboxSession) #else /* VBOX_API_VERSION >= 4000000 */ -# define VBOX_OBJECT_GET_MACHINE(/* in */ iid_value, /* out */ machine) \ - data->vboxObj->vtbl->FindMachine(data->vboxObj, iid_value, machine) - # define VBOX_SESSION_OPEN(/* unused */ iid_value, /* in */ machine) \ machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Write) -# define VBOX_SESSION_OPEN_EXISTING(/* unused */ iid_value, /* in */ machine) \ - machine->vtbl->LockMachine(machine, data->vboxSession, LockType_Shared) - # define VBOX_SESSION_CLOSE() \ data->vboxSession->vtbl->UnlockMachine(data->vboxSession) @@ -2163,7 +2105,7 @@ _unregisterMachine(vboxGlobalData *data, vboxIIDUnion *iidu, IMachine **machine) { nsresult rc; vboxArray media = VBOX_ARRAY_INITIALIZER; - rc = VBOX_OBJECT_GET_MACHINE(IID_MEMBER(value), machine); + rc = data->vboxObj->vtbl->FindMachine(data->vboxObj, IID_MEMBER(value), machine); if (NS_FAILED(rc)) { virReportError(VIR_ERR_NO_DOMAIN, "%s", _("no domain with matching uuid")); -- 1.7.9.5