VirtualBox

Changeset 50988 in vbox


Ignore:
Timestamp:
Apr 7, 2014 7:36:54 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
93172
Message:

Storage/VD: Cleanup VD plugin handling. One shared object can now support an arbitrary number of image backends instead of just one like before

Location:
trunk
Files:
1 added
14 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vd-cache-backend.h

    r50981 r50988  
    6666
    6767    /**
    68      * Handle of loaded plugin library, NIL_RTLDRMOD for static backends.
    69      */
    70     RTLDRMOD hPlugin;
    71 
    72     /**
    7368     * Probes the given image.
    7469     *
    … …  
    318313
    319314} VDCACHEBACKEND;
    320 
    321 /** Pointer to VD backend. */
     315/** Pointer to VD cache backend. */
    322316typedef VDCACHEBACKEND *PVDCACHEBACKEND;
    323 
    324317/** Constant pointer to VD backend. */
    325318typedef const VDCACHEBACKEND *PCVDCACHEBACKEND;
    326319
    327 /** Initialization entry point. */
    328 typedef DECLCALLBACK(int) FNVDCACHEFORMATLOAD(PVDCACHEBACKEND *ppBackendTable);
    329 typedef FNVDCACHEFORMATLOAD *PFNVDCACHEFORMATLOAD;
    330 #define VD_CACHEFORMAT_LOAD_NAME "VDCacheFormatLoad"
    331 
    332 /** The prefix to identify Storage Plugins. */
    333 #define VD_CACHEFORMAT_PLUGIN_PREFIX "VDCache"
    334 /** The size of the prefix excluding the '\\0' terminator. */
    335 #define VD_CACHEFORMAT_PLUGIN_PREFIX_LENGTH (sizeof(VD_CACHEFORMAT_PLUGIN_PREFIX)-1)
    336 
    337320#endif

  • trunk/include/VBox/vd-ifs-internal.h

    r49833 r50988  
    586586
    587587
     588/**
     589 * Interface for the metadata traverse callback.
     590 *
     591 * Per-operation interface. Present only for the metadata traverse callback.
     592 */
     593typedef struct VDINTERFACETRAVERSEMETADATA
     594{
     595    /**
     596     * Common interface header.
     597     */
     598    VDINTERFACE    Core;
     599
     600    /**
     601     * Traverse callback.
     602     *
     603     * @returns VBox status code.
     604     * @param   pvUser          The opaque data passed for the operation.
     605     * @param   pvMetadataChunk Pointer to a chunk of the image metadata.
     606     * @param   cbMetadataChunk Size of the metadata chunk
     607     */
     608    DECLR3CALLBACKMEMBER(int, pfnMetadataCallback, (void *pvUser, const void *pvMetadataChunk,
     609                                                    size_t cbMetadataChunk));
     610
     611} VDINTERFACETRAVERSEMETADATA, *PVDINTERFACETRAVERSEMETADATA;
     612
     613
     614/**
     615 * Get parent state interface from interface list.
     616 *
     617 * @return Pointer to the first parent state interface in the list.
     618 * @param  pVDIfs    Pointer to the interface list.
     619 */
     620DECLINLINE(PVDINTERFACETRAVERSEMETADATA) VDIfTraverseMetadataGet(PVDINTERFACE pVDIfs)
     621{
     622    PVDINTERFACE pIf = VDInterfaceGet(pVDIfs, VDINTERFACETYPE_TRAVERSEMETADATA);
     623
     624    /* Check that the interface descriptor the correct interface. */
     625    AssertMsgReturn(   !pIf
     626                    || (   (pIf->enmInterface == VDINTERFACETYPE_TRAVERSEMETADATA)
     627                        && (pIf->cbSize == sizeof(VDINTERFACETRAVERSEMETADATA))),
     628                    ("Not a traverse metadata interface"), NULL);
     629
     630    return (PVDINTERFACETRAVERSEMETADATA)pIf;
     631}
     632
    588633RT_C_DECLS_END
    589634

  • trunk/include/VBox/vd-ifs.h

    r48871 r50988  
    6868    /** Interface to query the use of block ranges on the disk. Per-operation. */
    6969    VDINTERFACETYPE_QUERYRANGEUSE,
     70    /** Interface for the metadata traverse callback. Per-operation. */
     71    VDINTERFACETYPE_TRAVERSEMETADATA,
    7072    /** invalid interface. */
    7173    VDINTERFACETYPE_INVALID

  • trunk/include/VBox/vd-image-backend.h

    r50981 r50988  
    11/** @file
    2  * Internal hard disk format support API for VBoxHDD.
     2 * VD: Image backend interface.
    33 */
    44
    55/*
    6  * Copyright (C) 2006-2013 Oracle Corporation
     6 * Copyright (C) 2006-2014 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2424 */
    2525
    26 #ifndef __VBoxHDD_Plugin_h__
    27 #define __VBoxHDD_Plugin_h__
     26#ifndef __vd_image_backend_h__
     27#define __vd_image_backend_h__
    2828
    2929#include <VBox/vd.h>
    … …  
    5050/** @}*/
    5151
     52/** @name VBox HDD backend metadata traverse flags
     53 * @{
     54 */
     55/** Include per block metadata while traversing the metadata.
     56 * This might take much longer instead of traversing just global metadata. */
     57#define VD_TRAVERSE_METADATA_INCLUDE_PER_BLOCK_METADATA RT_BIT(0)
     58/** @}*/
    5259
    5360/**
    … …  
    8592     */
    8693    PCVDCONFIGINFO paConfigInfo;
    87 
    88     /**
    89      * Handle of loaded plugin library, NIL_RTLDRMOD for static backends.
    90      */
    91     RTLDRMOD hPlugin;
    9294
    9395    /**
    … …  
    566568                                          PVDINTERFACE pVDIfsImage, uint32_t fFlags));
    567569
     570    /**
     571     * Traverse all metadata of the opened image.
     572     *
     573     * @returns VBox status code.
     574     * @param   pBackendData    Opaque state data for this image.
     575     * @param   fFlags          Traverse flags, combination of VD_TRAVERSE_METDATA_* defines.
     576     * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
     577     * @param   pVDIfsImage     Pointer to the per-image VD interface list.
     578     * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
     579     */
     580    DECLR3CALLBACKMEMBER(int, pfnTraverseMetadata, (void *pBackendData, uint32_t fFlags,
     581                                                    PVDINTERFACE pVDIfsDisk,
     582                                                    PVDINTERFACE pVDIfsImage,
     583                                                    PVDINTERFACE pVDIfsOperation));
     584
    568585} VBOXHDDBACKEND;
    569586
    570587/** Pointer to VD backend. */
    571588typedef VBOXHDDBACKEND *PVBOXHDDBACKEND;
    572 
    573589/** Constant pointer to VD backend. */
    574590typedef const VBOXHDDBACKEND *PCVBOXHDDBACKEND;
    … …  
    587603}
    588604
    589 /** Initialization entry point. */
    590 typedef DECLCALLBACK(int) VBOXHDDFORMATLOAD(PVBOXHDDBACKEND *ppBackendTable);
    591 typedef VBOXHDDFORMATLOAD *PFNVBOXHDDFORMATLOAD;
    592 #define VBOX_HDDFORMAT_LOAD_NAME "VBoxHDDFormatLoad"
    593 
    594 /** The prefix to identify Storage Plugins. */
    595 #define VBOX_HDDFORMAT_PLUGIN_PREFIX "VBoxHDD"
    596 /** The size of the prefix excluding the '\\0' terminator. */
    597 #define VBOX_HDDFORMAT_PLUGIN_PREFIX_LENGTH (sizeof(VBOX_HDDFORMAT_PLUGIN_PREFIX)-1)
    598 
    599605#endif

  • trunk/src/VBox/Storage/DMG.cpp

    r48871 r50988  
    3535#include <iprt/formats/xar.h>
    3636
     37#include "VDBackends.h"
    3738
    3839/*******************************************************************************
    … …  
    24712472
    24722473
    2473 VBOXHDDBACKEND g_DmgBackend =
     2474const VBOXHDDBACKEND g_DmgBackend =
    24742475{
    24752476    /* pszBackendName */
    … …  
    24832484    /* paConfigInfo */
    24842485    NULL,
    2485     /* hPlugin */
    2486     NIL_RTLDRMOD,
    24872486    /* pfnCheckIfValid */
    24882487    dmgCheckIfValid,
    … …  
    25662565    NULL,
    25672566    /* pfnRepair */
     2567    NULL,
     2568    /* pfnTraverseMetadata */
    25682569    NULL
    25692570};

  • trunk/src/VBox/Storage/ISCSI.cpp

    r50304 r50988  
    3737#include <VBox/scsi.h>
    3838
     39#include "VDBackends.h"
    3940
    4041/*******************************************************************************
    … …  
    54595460
    54605461
    5461 VBOXHDDBACKEND g_ISCSIBackend =
     5462const VBOXHDDBACKEND g_ISCSIBackend =
    54625463{
    54635464    /* pszBackendName */
    … …  
    54715472    /* paConfigInfo */
    54725473    s_iscsiConfigInfo,
    5473     /* hPlugin */
    5474     NIL_RTLDRMOD,
    54755474    /* pfnCheckIfValid */
    54765475    iscsiCheckIfValid,
    … …  
    55545553    NULL,
    55555554    /* pfnRepair */
     5555    NULL,
     5556    /* pfnTraverseMetadata */
    55565557    NULL
    55575558};

  • trunk/src/VBox/Storage/Parallels.cpp

    r49039 r50988  
    2828#include <iprt/string.h>
    2929#include <iprt/asm.h>
     30
     31#include "VDBackends.h"
    3032
    3133#define PARALLELS_HEADER_MAGIC "WithoutFreeSpace"
    … …  
    12031205
    12041206
    1205 VBOXHDDBACKEND g_ParallelsBackend =
     1207const VBOXHDDBACKEND g_ParallelsBackend =
    12061208{
    12071209    /* pszBackendName */
    … …  
    12151217    /* paConfigInfo */
    12161218    NULL,
    1217     /* hPlugin */
    1218     NIL_RTLDRMOD,
    12191219    /* pfnCheckIfValid */
    12201220    parallelsCheckIfValid,
    … …  
    12981298    NULL,
    12991299    /* pfnRepair */
     1300    NULL,
     1301    /* pfnTraverseMetadata */
    13001302    NULL
    13011303};

  • trunk/src/VBox/Storage/QCOW.cpp

    r48851 r50988  
    3030#include <iprt/path.h>
    3131#include <iprt/list.h>
     32
     33#include "VDBackends.h"
    3234
    3335/**
    … …  
    24602462
    24612463
    2462 VBOXHDDBACKEND g_QCowBackend =
     2464const VBOXHDDBACKEND g_QCowBackend =
    24632465{
    24642466    /* pszBackendName */
    … …  
    24722474    /* paConfigInfo */
    24732475    NULL,
    2474     /* hPlugin */
    2475     NIL_RTLDRMOD,
    24762476    /* pfnCheckIfValid */
    24772477    qcowCheckIfValid,
    … …  
    25552555    NULL,
    25562556    /* pfnRepair */
     2557    NULL,
     2558    /* pfnTraverseMetadata */
    25572559    NULL
    25582560};

  • trunk/src/VBox/Storage/QED.cpp

    r48851 r50988  
    3030#include <iprt/path.h>
    3131#include <iprt/list.h>
     32
     33#include "VDBackends.h"
    3234
    3335/**
    … …  
    25982600
    25992601
    2600 VBOXHDDBACKEND g_QedBackend =
     2602const VBOXHDDBACKEND g_QedBackend =
    26012603{
    26022604    /* pszBackendName */
    … …  
    26102612    /* paConfigInfo */
    26112613    NULL,
    2612     /* hPlugin */
    2613     NIL_RTLDRMOD,
    26142614    /* pfnCheckIfValid */
    26152615    qedCheckIfValid,
    … …  
    26932693    qedResize,
    26942694    /* pfnRepair */
     2695    NULL,
     2696    /* pfnTraverseMetadata */
    26952697    NULL
    26962698};

  • trunk/src/VBox/Storage/RAW.cpp

    r49039 r50988  
    2727#include <iprt/alloc.h>
    2828#include <iprt/path.h>
     29
     30#include "VDBackends.h"
    2931
    3032/*******************************************************************************
    … …  
    11271129
    11281130
    1129 VBOXHDDBACKEND g_RawBackend =
     1131const VBOXHDDBACKEND g_RawBackend =
    11301132{
    11311133    /* pszBackendName */
    … …  
    11391141    /* paConfigInfo */
    11401142    NULL,
    1141     /* hPlugin */
    1142     NIL_RTLDRMOD,
    11431143    /* pfnCheckIfValid */
    11441144    rawCheckIfValid,
    … …  
    12221222    NULL,
    12231223    /* pfnRepair */
     1224    NULL,
     1225    /* pfnTraverseMetadata */
    12241226    NULL
    12251227};

  • trunk/src/VBox/Storage/VCICache.cpp

    r45486 r50988  
    2020*******************************************************************************/
    2121#define LOG_GROUP LOG_GROUP_VD_RAW /** @todo logging group */
    22 #include <VBox/vd-cache-plugin.h>
     22#include <VBox/vd-cache-backend.h>
    2323#include <VBox/err.h>
    2424
    … …  
    2828#include <iprt/file.h>
    2929#include <iprt/asm.h>
     30
     31#include "VDBackends.h"
    3032
    3133/*******************************************************************************
    … …  
    19571959
    19581960
    1959 VDCACHEBACKEND g_VciCacheBackend =
     1961const VDCACHEBACKEND g_VciCacheBackend =
    19601962{
    19611963    /* pszBackendName */
    … …  
    19691971    /* paConfigInfo */
    19701972    NULL,
    1971     /* hPlugin */
    1972     NIL_RTLDRMOD,
    19731973    /* pfnProbe */
    19741974    vciProbe,

  • trunk/src/VBox/Storage/VD.cpp

    r50852 r50988  
    4242
    4343#include <VBox/vd-plugin.h>
    44 #include <VBox/vd-cache-plugin.h>
     44
     45#include "VDBackends.h"
    4546
    4647/** Disable dynamic backends on non x86 architectures. This feature
    … …  
    552553#define VDMETAXFER_TXDIR_SET(flags, dir) ((flags) = (flags & ~VDMETAXFER_TXDIR_MASK) | (dir))
    553554
    554 extern VBOXHDDBACKEND g_RawBackend;
    555 extern VBOXHDDBACKEND g_VmdkBackend;
    556 extern VBOXHDDBACKEND g_VDIBackend;
    557 extern VBOXHDDBACKEND g_VhdBackend;
    558 extern VBOXHDDBACKEND g_ParallelsBackend;
    559 extern VBOXHDDBACKEND g_DmgBackend;
    560 extern VBOXHDDBACKEND g_ISCSIBackend;
    561 extern VBOXHDDBACKEND g_QedBackend;
    562 extern VBOXHDDBACKEND g_QCowBackend;
    563 extern VBOXHDDBACKEND g_VhdxBackend;
    564 
     555/**
     556 * Plugin structure.
     557 */
     558typedef struct VDPLUGIN
     559{
     560    /** Pointer to the next plugin structure. */
     561    RTLISTNODE NodePlugin;
     562    /** Handle of loaded plugin library. */
     563    RTLDRMOD   hPlugin;
     564} VDPLUGIN;
     565/** Pointer to a plugin structure. */
     566typedef VDPLUGIN *PVDPLUGIN;
     567
     568/** Head of loaded plugin list. */
     569static RTLISTANCHOR g_ListPluginsLoaded;
     570
     571/** Number of image backends supported. */
    565572static unsigned g_cBackends = 0;
    566 static PVBOXHDDBACKEND *g_apBackends = NULL;
    567 static PVBOXHDDBACKEND aStaticBackends[] =
     573/** Array of pointers to the image backends. */
     574static PCVBOXHDDBACKEND *g_apBackends = NULL;
     575/** Builtin image backends. */
     576static PCVBOXHDDBACKEND aStaticBackends[] =
    568577{
    569578    &g_VmdkBackend,
    … …  
    579588};
    580589
    581 /**
    582  * Supported backends for the disk cache.
    583  */
    584 extern VDCACHEBACKEND g_VciCacheBackend;
    585 
     590/** Number of supported cache backends. */
    586591static unsigned g_cCacheBackends = 0;
    587 static PVDCACHEBACKEND *g_apCacheBackends = NULL;
    588 static PVDCACHEBACKEND aStaticCacheBackends[] =
     592/** Array of pointers to the cache backends. */
     593static PCVDCACHEBACKEND *g_apCacheBackends = NULL;
     594/** Builtin cache backends. */
     595static PCVDCACHEBACKEND aStaticCacheBackends[] =
    589596{
    590597    &g_VciCacheBackend
    … …  
    601608 * internal: add several backends.
    602609 */
    603 static int vdAddBackends(PVBOXHDDBACKEND *ppBackends, unsigned cBackends)
    604 {
    605     PVBOXHDDBACKEND *pTmp = (PVBOXHDDBACKEND*)RTMemRealloc(g_apBackends,
    606            (g_cBackends + cBackends) * sizeof(PVBOXHDDBACKEND));
     610static int vdAddBackends(PCVBOXHDDBACKEND *ppBackends, unsigned cBackends)
     611{
     612    PCVBOXHDDBACKEND *pTmp = (PCVBOXHDDBACKEND*)RTMemRealloc(g_apBackends,
     613           (g_cBackends + cBackends) * sizeof(PCVBOXHDDBACKEND));
    607614    if (RT_UNLIKELY(!pTmp))
    608615        return VERR_NO_MEMORY;
    609616    g_apBackends = pTmp;
    610     memcpy(&g_apBackends[g_cBackends], ppBackends, cBackends * sizeof(PVBOXHDDBACKEND));
     617    memcpy(&g_apBackends[g_cBackends], ppBackends, cBackends * sizeof(PCVBOXHDDBACKEND));
    611618    g_cBackends += cBackends;
    612619    return VINF_SUCCESS;
    … …  
    616623 * internal: add single backend.
    617624 */
    618 DECLINLINE(int) vdAddBackend(PVBOXHDDBACKEND pBackend)
     625DECLINLINE(int) vdAddBackend(PCVBOXHDDBACKEND pBackend)
    619626{
    620627    return vdAddBackends(&pBackend, 1);
    … …  
    624631 * internal: add several cache backends.
    625632 */
    626 static int vdAddCacheBackends(PVDCACHEBACKEND *ppBackends, unsigned cBackends)
    627 {
    628     PVDCACHEBACKEND *pTmp = (PVDCACHEBACKEND*)RTMemRealloc(g_apCacheBackends,
    629            (g_cCacheBackends + cBackends) * sizeof(PVDCACHEBACKEND));
     633static int vdAddCacheBackends(PCVDCACHEBACKEND *ppBackends, unsigned cBackends)
     634{
     635    PCVDCACHEBACKEND *pTmp = (PCVDCACHEBACKEND*)RTMemRealloc(g_apCacheBackends,
     636           (g_cCacheBackends + cBackends) * sizeof(PCVDCACHEBACKEND));
    630637    if (RT_UNLIKELY(!pTmp))
    631638        return VERR_NO_MEMORY;
    632639    g_apCacheBackends = pTmp;
    633     memcpy(&g_apCacheBackends[g_cCacheBackends], ppBackends, cBackends * sizeof(PVDCACHEBACKEND));
     640    memcpy(&g_apCacheBackends[g_cCacheBackends], ppBackends, cBackends * sizeof(PCVDCACHEBACKEND));
    634641    g_cCacheBackends += cBackends;
    635642    return VINF_SUCCESS;
    … …  
    639646 * internal: add single cache backend.
    640647 */
    641 DECLINLINE(int) vdAddCacheBackend(PVDCACHEBACKEND pBackend)
     648DECLINLINE(int) vdAddCacheBackend(PCVDCACHEBACKEND pBackend)
    642649{
    643650    return vdAddCacheBackends(&pBackend, 1);
    … …  
    31853192}
    31863193
    3187 /**
    3188  * internal: scans plugin directory and loads the backends have been found.
     3194#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
     3195/**
     3196 * @copydoc VDPLUGIN::pfnRegisterImage
     3197 */
     3198static DECLCALLBACK(int) vdPluginRegisterImage(void *pvUser, PCVBOXHDDBACKEND pBackend)
     3199{
     3200    int rc = VINF_SUCCESS;
     3201
     3202    if (pBackend->cbSize == sizeof(VBOXHDDBACKEND))
     3203        vdAddBackend(pBackend);
     3204    else
     3205    {
     3206        LogFunc(("ignored plugin: pBackend->cbSize=%d rc=%Rrc\n", pBackend->cbSize));
     3207        rc = VERR_IGNORED;
     3208    }
     3209
     3210    return rc;
     3211}
     3212
     3213/**
     3214 * @copydoc VDPLUGIN::pfnRegisterCache
     3215 */
     3216static DECLCALLBACK(int) vdPluginRegisterCache(void *pvUser, PCVDCACHEBACKEND pBackend)
     3217{
     3218    int rc = VINF_SUCCESS;
     3219
     3220    if (pBackend->cbSize == sizeof(VDCACHEBACKEND))
     3221        vdAddCacheBackend(pBackend);
     3222    else
     3223    {
     3224        LogFunc(("ignored plugin: pBackend->cbSize=%d rc=%Rrc\n", pBackend->cbSize));
     3225        rc = VERR_IGNORED;
     3226    }
     3227
     3228    return rc;
     3229}
     3230
     3231/**
     3232 * Adds a plugin to the list of loaded plugins.
     3233 *
     3234 * @returns VBox status code.
     3235 * @param   hPlugin    PLugin handle to add.
     3236 */
     3237static int vdAddPlugin(RTLDRMOD hPlugin)
     3238{
     3239    int rc = VINF_SUCCESS;
     3240    PVDPLUGIN pPlugin = (PVDPLUGIN)RTMemAllocZ(sizeof(VDPLUGIN));
     3241
     3242    if (pPlugin)
     3243    {
     3244        pPlugin->hPlugin = hPlugin;
     3245        RTListAppend(&g_ListPluginsLoaded, &pPlugin->NodePlugin);
     3246    }
     3247    else
     3248        rc = VERR_NO_MEMORY;
     3249
     3250    return rc;
     3251}
     3252#endif
     3253
     3254/**
     3255 * internal: scans plugin directory and loads found plugins.
    31893256 */
    31903257static int vdLoadDynamicBackends()
    … …  
    32013268
    32023269    /* To get all entries with VBoxHDD as prefix. */
    3203     char *pszPluginFilter = RTPathJoinA(szPath, VBOX_HDDFORMAT_PLUGIN_PREFIX "*");
     3270    char *pszPluginFilter = RTPathJoinA(szPath, VD_PLUGIN_PREFIX "*");
    32043271    if (!pszPluginFilter)
    32053272        return VERR_NO_STR_MEMORY;
    … …  
    32273294    {
    32283295        RTLDRMOD hPlugin = NIL_RTLDRMOD;
    3229         PFNVBOXHDDFORMATLOAD pfnHDDFormatLoad = NULL;
    3230         PVBOXHDDBACKEND pBackend = NULL;
    32313296        char *pszPluginPath = NULL;
    32323297
    … …  
    32643329        if (RT_SUCCESS(rc))
    32653330        {
    3266             rc = RTLdrGetSymbol(hPlugin, VBOX_HDDFORMAT_LOAD_NAME, (void**)&pfnHDDFormatLoad);
    3267             if (RT_FAILURE(rc) || !pfnHDDFormatLoad)
     3331            VDBACKENDREGISTER BackendRegister;
     3332            PFNVDPLUGINLOAD pfnVDPluginLoad = NULL;
     3333
     3334            BackendRegister.pfnRegisterImage = vdPluginRegisterImage;
     3335            BackendRegister.pfnRegisterCache = vdPluginRegisterCache;
     3336            /** @todo: Filter plugins. */
     3337
     3338            rc = RTLdrGetSymbol(hPlugin, VD_PLUGIN_LOAD_NAME, (void**)&pfnVDPluginLoad);
     3339            if (RT_FAILURE(rc) || !pfnVDPluginLoad)
    32683340            {
    3269                 LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnHDDFormat=%#p\n", VBOX_HDDFORMAT_LOAD_NAME, pPluginDirEntry->szName, rc, pfnHDDFormatLoad));
     3341                LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnVDPluginLoad=%#p\n",
     3342                         VD_PLUGIN_LOAD_NAME, pPluginDirEntry->szName, rc, pfnVDPluginLoad));
    32703343                if (RT_SUCCESS(rc))
    32713344                    rc = VERR_SYMBOL_NOT_FOUND;
    … …  
    32753348            {
    32763349                /* Get the function table. */
    3277                 rc = pfnHDDFormatLoad(&pBackend);
    3278                 if (RT_SUCCESS(rc) && pBackend->cbSize == sizeof(VBOXHDDBACKEND))
    3279                 {
    3280                     pBackend->hPlugin = hPlugin;
    3281                     vdAddBackend(pBackend);
    3282                 }
    3283                 else
    3284                     LogFunc(("ignored plugin '%s': pBackend->cbSize=%d rc=%Rrc\n", pszPluginPath, pBackend->cbSize, rc));
     3350                rc = pfnVDPluginLoad(NULL, &BackendRegister);
    32853351            }
    32863352            else
    32873353                LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszPluginPath, rc));
    32883354
    3289             if (RT_FAILURE(rc))
    3290                 RTLdrClose(hPlugin);
    3291         }
    3292         RTStrFree(pszPluginPath);
    3293     }
    3294 out:
    3295     if (rc == VERR_NO_MORE_FILES)
    3296         rc = VINF_SUCCESS;
    3297     RTStrFree(pszPluginFilter);
    3298     if (pPluginDirEntry)
    3299         RTMemFree(pPluginDirEntry);
    3300     if (pPluginDir)
    3301         RTDirClose(pPluginDir);
    3302     return rc;
    3303 #else
    3304     return VINF_SUCCESS;
    3305 #endif
    3306 }
    3307 
    3308 /**
    3309  * internal: scans plugin directory and loads the cache backends have been found.
    3310  */
    3311 static int vdLoadDynamicCacheBackends()
    3312 {
    3313 #ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
    3314     int rc = VINF_SUCCESS;
    3315     PRTDIR pPluginDir = NULL;
    3316 
    3317     /* Enumerate plugin backends. */
    3318     char szPath[RTPATH_MAX];
    3319     rc = RTPathAppPrivateArch(szPath, sizeof(szPath));
    3320     if (RT_FAILURE(rc))
    3321         return rc;
    3322 
    3323     /* To get all entries with VBoxHDD as prefix. */
    3324     char *pszPluginFilter = RTPathJoinA(szPath, VD_CACHEFORMAT_PLUGIN_PREFIX "*");
    3325     if (!pszPluginFilter)
    3326     {
    3327         rc = VERR_NO_STR_MEMORY;
    3328         return rc;
    3329     }
    3330 
    3331     PRTDIRENTRYEX pPluginDirEntry = NULL;
    3332     size_t cbPluginDirEntry = sizeof(RTDIRENTRYEX);
    3333     /* The plugins are in the same directory as the other shared libs. */
    3334     rc = RTDirOpenFiltered(&pPluginDir, pszPluginFilter, RTDIRFILTER_WINNT, 0);
    3335     if (RT_FAILURE(rc))
    3336     {
    3337         /* On Windows the above immediately signals that there are no
    3338          * files matching, while on other platforms enumerating the
    3339          * files below fails. Either way: no plugins. */
    3340         goto out;
    3341     }
    3342 
    3343     pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
    3344     if (!pPluginDirEntry)
    3345     {
    3346         rc = VERR_NO_MEMORY;
    3347         goto out;
    3348     }
    3349 
    3350     while ((rc = RTDirReadEx(pPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK)) != VERR_NO_MORE_FILES)
    3351     {
    3352         RTLDRMOD hPlugin = NIL_RTLDRMOD;
    3353         PFNVDCACHEFORMATLOAD pfnVDCacheLoad = NULL;
    3354         PVDCACHEBACKEND pBackend = NULL;
    3355         char *pszPluginPath = NULL;
    3356 
    3357         if (rc == VERR_BUFFER_OVERFLOW)
    3358         {
    3359             /* allocate new buffer. */
    3360             RTMemFree(pPluginDirEntry);
    3361             pPluginDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(cbPluginDirEntry);
    3362             if (!pPluginDirEntry)
    3363             {
    3364                 rc = VERR_NO_MEMORY;
    3365                 break;
    3366             }
    3367             /* Retry. */
    3368             rc = RTDirReadEx(pPluginDir, pPluginDirEntry, &cbPluginDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
    3369             if (RT_FAILURE(rc))
    3370                 break;
    3371         }
    3372         else if (RT_FAILURE(rc))
    3373             break;
    3374 
    3375         /* We got the new entry. */
    3376         if (!RTFS_IS_FILE(pPluginDirEntry->Info.Attr.fMode))
    3377             continue;
    3378 
    3379         /* Prepend the path to the libraries. */
    3380         pszPluginPath = RTPathJoinA(szPath, pPluginDirEntry->szName);
    3381         if (!pszPluginPath)
    3382         {
    3383             rc = VERR_NO_STR_MEMORY;
    3384             break;
    3385         }
    3386 
    3387         rc = SUPR3HardenedLdrLoadPlugIn(pszPluginPath, &hPlugin, NULL);
    3388         if (RT_SUCCESS(rc))
    3389         {
    3390             rc = RTLdrGetSymbol(hPlugin, VD_CACHEFORMAT_LOAD_NAME, (void**)&pfnVDCacheLoad);
    3391             if (RT_FAILURE(rc) || !pfnVDCacheLoad)
    3392             {
    3393                 LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnVDCacheLoad=%#p\n",
    3394                          VD_CACHEFORMAT_LOAD_NAME, pPluginDirEntry->szName, rc, pfnVDCacheLoad));
    3395                 if (RT_SUCCESS(rc))
    3396                     rc = VERR_SYMBOL_NOT_FOUND;
    3397             }
    3398 
     3355            /* Create a plugin entry on success. */
    33993356            if (RT_SUCCESS(rc))
    3400             {
    3401                 /* Get the function table. */
    3402                 rc = pfnVDCacheLoad(&pBackend);
    3403                 if (RT_SUCCESS(rc) && pBackend->cbSize == sizeof(VDCACHEBACKEND))
    3404                 {
    3405                     pBackend->hPlugin = hPlugin;
    3406                     vdAddCacheBackend(pBackend);
    3407                 }
    3408                 else
    3409                     LogFunc(("ignored plugin '%s': pBackend->cbSize=%d rc=%Rrc\n", pszPluginPath, pBackend->cbSize, rc));
    3410             }
     3357                vdAddPlugin(hPlugin);
    34113358            else
    3412                 LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszPluginPath, rc));
    3413 
    3414             if (RT_FAILURE(rc))
    34153359                RTLdrClose(hPlugin);
    34163360        }
    … …  
    50565000        if (RT_SUCCESS(rc))
    50575001        {
     5002            RTListInit(&g_ListPluginsLoaded);
    50585003            rc = vdLoadDynamicBackends();
    5059             if (RT_SUCCESS(rc))
    5060                 rc = vdLoadDynamicCacheBackends();
    50615004        }
    50625005    }
    … …  
    50725015VBOXDDU_DECL(int) VDShutdown(void)
    50735016{
    5074     PVBOXHDDBACKEND *pBackends = g_apBackends;
    5075     PVDCACHEBACKEND *pCacheBackends = g_apCacheBackends;
     5017    PCVBOXHDDBACKEND *pBackends = g_apBackends;
     5018    PCVDCACHEBACKEND *pCacheBackends = g_apCacheBackends;
    50765019    unsigned cBackends = g_cBackends;
    50775020
    5078     if (!pBackends)
     5021    if (!g_apBackends)
    50795022        return VERR_INTERNAL_ERROR;
     5023
     5024    if (g_apCacheBackends)
     5025        RTMemFree(g_apCacheBackends);
     5026    RTMemFree(g_apBackends);
    50805027
    50815028    g_cBackends = 0;
    50825029    g_apBackends = NULL;
    50835030
    5084 #ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
    5085     for (unsigned i = 0; i < cBackends; i++)
    5086         if (pBackends[i]->hPlugin != NIL_RTLDRMOD)
    5087             RTLdrClose(pBackends[i]->hPlugin);
    5088 #endif
    5089 
    50905031    /* Clear the supported cache backends. */
    5091     cBackends = g_cCacheBackends;
    50925032    g_cCacheBackends = 0;
    50935033    g_apCacheBackends = NULL;
    50945034
    50955035#ifndef VBOX_HDD_NO_DYNAMIC_BACKENDS
    5096     for (unsigned i = 0; i < cBackends; i++)
    5097         if (pCacheBackends[i]->hPlugin != NIL_RTLDRMOD)
    5098             RTLdrClose(pCacheBackends[i]->hPlugin);
     5036    PVDPLUGIN pPlugin, pPluginNext;
     5037
     5038    RTListForEachSafe(&g_ListPluginsLoaded, pPlugin, pPluginNext, VDPLUGIN, NodePlugin)
     5039    {
     5040        RTLdrClose(pPlugin->hPlugin);
     5041        RTListNodeRemove(&pPlugin->NodePlugin);
     5042        RTMemFree(pPlugin);
     5043    }
    50995044#endif
    51005045
    5101     if (pCacheBackends)
    5102         RTMemFree(pCacheBackends);
    5103     RTMemFree(pBackends);
    51045046    return VINF_SUCCESS;
    51055047}

  • trunk/src/VBox/Storage/VDI.cpp

    r48851 r50988  
    3030#include <iprt/string.h>
    3131#include <iprt/asm.h>
     32
     33#include "VDBackends.h"
    3234
    3335#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
    … …  
    31943196}
    31953197
    3196 VBOXHDDBACKEND g_VDIBackend =
     3198const VBOXHDDBACKEND g_VDIBackend =
    31973199{
    31983200    /* pszBackendName */
    … …  
    32073209    /* paConfigInfo */
    32083210    NULL,
    3209     /* hPlugin */
    3210     NIL_RTLDRMOD,
    32113211    /* pfnCheckIfValid */
    32123212    vdiCheckIfValid,
    … …  
    32903290    vdiResize,
    32913291    /* pfnRepair */
    3292     vdiRepair
     3292    vdiRepair,
     3293    /* pfnTraverseMetadata */
     3294    NULL
    32933295};

  • trunk/src/VBox/Storage/VHD.cpp

    r50851 r50988  
    3131#include <iprt/path.h>
    3232#include <iprt/string.h>
     33
     34#include "VDBackends.h"
    3335
    3436#define VHD_RELATIVE_MAX_PATH 512
    … …  
    31883190
    31893191
    3190 VBOXHDDBACKEND g_VhdBackend =
     3192const VBOXHDDBACKEND g_VhdBackend =
    31913193{
    31923194    /* pszBackendName */
    … …  
    32023204    /* paConfigInfo */
    32033205    NULL,
    3204     /* hPlugin */
    3205     NIL_RTLDRMOD,
    32063206    /* pfnCheckIfValid */
    32073207    vhdCheckIfValid,
    … …  
    32853285    vhdResize,
    32863286    /* pfnRepair */
    3287     vhdRepair
     3287    vhdRepair,
     3288    /* pfnTraverseMetadata */
     3289    NULL
    32883290};

  • trunk/src/VBox/Storage/VHDX.cpp

    r50531 r50988  
    3030#include <iprt/uuid.h>
    3131#include <iprt/crc.h>
     32
     33#include "VDBackends.h"
    3234
    3335/*******************************************************************************
    … …  
    24292431
    24302432
    2431 VBOXHDDBACKEND g_VhdxBackend =
     2433const VBOXHDDBACKEND g_VhdxBackend =
    24322434{
    24332435    /* pszBackendName */
    … …  
    24412443    /* paConfigInfo */
    24422444    NULL,
    2443     /* hPlugin */
    2444     NIL_RTLDRMOD,
    24452445    /* pfnCheckIfValid */
    24462446    vhdxCheckIfValid,
    … …  
    25242524    NULL,
    25252525    /* pfnRepair */
     2526    NULL,
     2527    /* pfnTraverseMetadata */
    25262528    NULL
    25272529};

  • trunk/src/VBox/Storage/VMDK.cpp

    r49231 r50988  
    3232#include <iprt/zip.h>
    3333#include <iprt/asm.h>
     34
     35#include "VDBackends.h"
    3436
    3537/*******************************************************************************
    … …  
    65616563
    65626564
    6563 VBOXHDDBACKEND g_VmdkBackend =
     6565const VBOXHDDBACKEND g_VmdkBackend =
    65646566{
    65656567    /* pszBackendName */
    … …  
    65756577    /* paConfigInfo */
    65766578    NULL,
    6577     /* hPlugin */
    6578     NIL_RTLDRMOD,
    65796579    /* pfnCheckIfValid */
    65806580    vmdkCheckIfValid,
    … …  
    66586658    NULL,
    66596659    /* pfnRepair */
     6660    NULL,
     6661    /* pfnTraverseMetadata */
    66606662    NULL
    66616663};
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette