Changeset 27815 in vbox for trunk/src

Timestamp:

Mar 30, 2010 8:43:53 AM (15 years ago)

Author:

vboxsync

Message:

VBoxHDD: Fix VDGetFormat, we don't have disk structure at this point

File:

• trunk/src/VBox/Devices/Storage/VBoxHDD.cpp (modified) (10 diffs)

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -215 +215 @@
 typedef struct VDIOSTORAGE
 {
-    /** Storage handle */
-    void                        *pStorage;
+    union
+    {
+        /** Storage handle */
+        void                        *pStorage;
+        /** File handle for the limited I/O version. */
+        RTFILE                       hFile;
+    } u;
 } VDIOSTORAGE;
 
@@ -1200 +1205 @@
                                                     vdIOReqCompleted,
                                                     pDisk->pVDIfsDisk,
-                                                    &pIoStorage->pStorage);
+                                                    &pIoStorage->u.pStorage);
     if (RT_SUCCESS(rc))
         *ppIoStorage = pIoStorage;
@@ -1214 +1219 @@
 
     int rc = pDisk->pInterfaceAsyncIOCallbacks->pfnClose(pDisk->pInterfaceAsyncIO->pvUser,
-                                                         pIoStorage->pStorage);
+                                                         pIoStorage->u.pStorage);
     AssertRC(rc);
 
@@ -1227 +1232 @@
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnGetSize(pDisk->pInterfaceAsyncIO->pvUser,
-                                                         pIoStorage->pStorage,
+                                                         pIoStorage->u.pStorage,
                                                          pcbSize);
 }
@@ -1237 +1242 @@
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnSetSize(pDisk->pInterfaceAsyncIO->pvUser,
-                                                         pIoStorage->pStorage,
+                                                         pIoStorage->u.pStorage,
                                                          cbSize);
 }
@@ -1247 +1252 @@
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnWriteSync(pDisk->pInterfaceAsyncIO->pvUser,
-                                                           pIoStorage->pStorage,
+                                                           pIoStorage->u.pStorage,
                                                            uOffset, cbWrite, pvBuf,
                                                            pcbWritten);
@@ -1258 +1263 @@
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnReadSync(pDisk->pInterfaceAsyncIO->pvUser,
-                                                          pIoStorage->pStorage,
+                                                          pIoStorage->u.pStorage,
                                                           uOffset, cbRead, pvBuf,
                                                           pcbRead);
@@ -1268 +1273 @@
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnFlushSync(pDisk->pInterfaceAsyncIO->pvUser,
-                                                           pIoStorage->pStorage);
+                                                           pIoStorage->u.pStorage);
 }
 
@@ -1326 +1331 @@
     return vdIoCtxSet(pIoCtx, ch, cb);
 }
+
+/**
+ * VD I/O interface callback for opening a file (limited version for VDGetFormat).
+ */
+static int vdIOOpenLimited(void *pvUser, const char *pszLocation,
+                           unsigned uOpenFlags, PPVDIOSTORAGE ppIoStorage)
+{
+    int rc = VINF_SUCCESS;
+    PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
+
+    if (!pIoStorage)
+        return VERR_NO_MEMORY;
+
+    uint32_t fOpen = 0;
+
+    if (uOpenFlags & VD_INTERFACEASYNCIO_OPEN_FLAGS_READONLY)
+        fOpen |= RTFILE_O_READ      | RTFILE_O_DENY_NONE;
+    else
+        fOpen |= RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
+
+    if (uOpenFlags & VD_INTERFACEASYNCIO_OPEN_FLAGS_CREATE)
+        fOpen |= RTFILE_O_CREATE;
+    else
+        fOpen |= RTFILE_O_OPEN;
+
+    rc = RTFileOpen(&pIoStorage->u.hFile, pszLocation, fOpen);
+    if (RT_SUCCESS(rc))
+        *ppIoStorage = pIoStorage;
+    else
+        RTMemFree(pIoStorage);
+
+    return rc;
+}
+
+static int vdIOCloseLimited(void *pvUser, PVDIOSTORAGE pIoStorage)
+{
+    int rc = RTFileClose(pIoStorage->u.hFile);
+    AssertRC(rc);
+
+    RTMemFree(pIoStorage);
+    return VINF_SUCCESS;
+}
+
+static int vdIOGetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
+                       uint64_t *pcbSize)
+{
+    return RTFileGetSize(pIoStorage->u.hFile, pcbSize);
+}
+
+static int vdIOSetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
+                       uint64_t cbSize)
+{
+    return RTFileSetSize(pIoStorage->u.hFile, cbSize);
+}
+
+static int vdIOWriteSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                         size_t cbWrite, const void *pvBuf, size_t *pcbWritten)
+{
+    return RTFileWriteAt(pIoStorage->u.hFile, uOffset, pvBuf, cbWrite, pcbWritten);
+}
+
+static int vdIOReadSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                        size_t cbRead, void *pvBuf, size_t *pcbRead)
+{
+    return RTFileReadAt(pIoStorage->u.hFile, uOffset, pvBuf, cbRead, pcbRead);
+}
+
+static int vdIOFlushSyncLimited(void *pvUser, PVDIOSTORAGE pIoStorage)
+{
+    return RTFileFlush(pIoStorage->u.hFile);
+}
+
 
 /**
@@ -1643 +1720 @@
     VDIIOCallbacks.cbSize            = sizeof(VDINTERFACEIO);
     VDIIOCallbacks.enmInterface      = VDINTERFACETYPE_IO;
-    VDIIOCallbacks.pfnOpen           = vdIOOpen;
-    VDIIOCallbacks.pfnClose          = vdIOClose;
-    VDIIOCallbacks.pfnGetSize        = vdIOGetSize;
-    VDIIOCallbacks.pfnSetSize        = vdIOSetSize;
-    VDIIOCallbacks.pfnReadSync       = vdIOReadSync;
-    VDIIOCallbacks.pfnWriteSync      = vdIOWriteSync;
-    VDIIOCallbacks.pfnFlushSync      = vdIOFlushSync;
+    VDIIOCallbacks.pfnOpen           = vdIOOpenLimited;
+    VDIIOCallbacks.pfnClose          = vdIOCloseLimited;
+    VDIIOCallbacks.pfnGetSize        = vdIOGetSizeLimited;
+    VDIIOCallbacks.pfnSetSize        = vdIOSetSizeLimited;
+    VDIIOCallbacks.pfnReadSync       = vdIOReadSyncLimited;
+    VDIIOCallbacks.pfnWriteSync      = vdIOWriteSyncLimited;
+    VDIIOCallbacks.pfnFlushSync      = vdIOFlushSyncLimited;
     VDIIOCallbacks.pfnReadUserAsync  = NULL;
     VDIIOCallbacks.pfnWriteUserAsync = NULL;