VirtualBox

忽略:
時間撮記:
2010-10-29 上午08:55:09 (14 年 以前)
作者:
vboxsync
svn:sync-xref-src-repo-rev:
67200
訊息:

VRDE: removed VBOX_WITH_VRDP from source code, also some obsolete code removed.

檔案:
修改 1 筆資料

圖例:

未更動
新增
刪除
  • trunk/src/VBox/Main/win/dllmain.cpp

    r32056 r33590  
    2626#include <iprt/initterm.h>
    2727
    28 /* Memory leak detection. */
    29 #ifdef VBOX_WITH_VRDP_MEMLEAK_DETECTOR
    30 typedef struct _MLDMemBlock
    31 {
    32     unsigned uSignature;
    33     struct _MLDMemBlock *next;
    34     struct _MLDMemBlock *prev;
    35     const char *pszCaller;
    36     int iLine;
    37     bool fTmp;
    38     size_t size;
    39     void *pv;
    40 } MLDMemBlock;
    41 
    42 static MLDMemBlock *gMemBlockListHead;
    43 static RTCRITSECT g_critsect;
    44 static const char *gszMDLPrefix = "MLDMEM";
    45 static int gAllocated = 0;
    46 static int gFreed = 0;
    47 static bool gfMLD = false;
    48 
    49 
    50 #define MLD_BLOCK_TO_PTR(__p) ((__p)? (void *) ( (uint8_t *)(__p) + sizeof (MLDMemBlock) ) : NULL)
    51 #define MLD_PTR_TO_BLOCK(__p) ((__p)? (MLDMemBlock *)((uint8_t *)(__p) - sizeof (MLDMemBlock)): NULL)
    52 
    53 #define MLD_BLOCK_SIGNATURE 0xFEDCBA98
    54 
    55 static void vrdpMemLock (void)
    56 {
    57     int rc = RTCritSectEnter (&g_critsect);
    58     AssertRC(rc);
    59 }
    60 
    61 static void vrdpMemUnlock (void)
    62 {
    63     RTCritSectLeave (&g_critsect);
    64 }
    65 
    66 static void vrdpMemAppendBlock (MLDMemBlock *pBlock)
    67 {
    68     pBlock->next = gMemBlockListHead;
    69     pBlock->prev = NULL;
    70 
    71     if (gMemBlockListHead)
    72     {
    73         gMemBlockListHead->prev = pBlock;
    74     }
    75     gMemBlockListHead = pBlock;
    76 }
    77 
    78 static void vrdpMemExcludeBlock (MLDMemBlock *pBlock)
    79 {
    80     /* Assert that the block is in the list. */
    81     MLDMemBlock *pIter = gMemBlockListHead;
    82 
    83     while (pIter && pIter != pBlock)
    84     {
    85         pIter = pIter->next;
    86     }
    87 
    88     Assert (pIter == pBlock);
    89 
    90     /* Exclude the block from list. */
    91     if (pBlock->next)
    92     {
    93         pBlock->next->prev = pBlock->prev;
    94     }
    95     else
    96     {
    97         /* do nothing */
    98     }
    99 
    100     if (pBlock->prev)
    101     {
    102         pBlock->prev->next = pBlock->next;
    103     }
    104     else
    105     {
    106         gMemBlockListHead = pBlock->next;
    107     }
    108 
    109     pBlock->next = NULL;
    110     pBlock->prev = NULL;
    111 }
    112 
    113 void *MLDMemAllocDbg (size_t cb, bool fTmp, bool fZero, const char *pszCaller, int iLine)
    114 {
    115     size_t cbAlloc;
    116     MLDMemBlock *pBlock;
    117 
    118     // LogFlowFunc(("cb = %d, fTmp = %d, fZero = %d, pszCaller = %s, iLine = %d\n",
    119     //              cb, fTmp, fZero, pszCaller, iLine));
    120 
    121     vrdpMemLock ();
    122 
    123     cbAlloc = cb + sizeof (MLDMemBlock);
    124 
    125     pBlock = (MLDMemBlock *)RTMemAlloc (cbAlloc);
    126 
    127     if (pBlock)
    128     {
    129         if (fZero)
    130         {
    131             memset (pBlock, 0, cbAlloc);
    132         }
    133 
    134         pBlock->pszCaller  = pszCaller;
    135         pBlock->iLine      = iLine;
    136         pBlock->size       = cb;
    137         pBlock->fTmp       = fTmp;
    138         pBlock->uSignature = MLD_BLOCK_SIGNATURE;
    139         pBlock->pv         = MLD_BLOCK_TO_PTR(pBlock);
    140 
    141         vrdpMemAppendBlock (pBlock);
    142 
    143         gAllocated++;
    144     }
    145 
    146     vrdpMemUnlock ();
    147 
    148     return MLD_BLOCK_TO_PTR(pBlock);
    149 }
    150 
    151 void *MLDMemReallocDbg (void *pv, size_t cb, const char *pszCaller, int iLine)
    152 {
    153     MLDMemBlock *pBlock;
    154 
    155     // LogFlowFunc(("pv = %p, cb = %d, pszCaller = %s, iLine = %d\n",
    156     //              pv, cb, pszCaller, iLine));
    157 
    158     vrdpMemLock ();
    159 
    160     pBlock = MLD_PTR_TO_BLOCK(pv);
    161 
    162     if (pBlock)
    163     {
    164         size_t cbAlloc = cb + sizeof (MLDMemBlock);
    165 
    166         Assert(pBlock->uSignature == MLD_BLOCK_SIGNATURE);
    167         Assert(!pBlock->fTmp); /* Tmp blocks are not to be reallocated. */
    168         Assert(pBlock->pv == pv);
    169 
    170         vrdpMemExcludeBlock (pBlock);
    171 
    172         pBlock = (MLDMemBlock *)RTMemRealloc (pBlock, cbAlloc);
    173 
    174         pBlock->pszCaller = pszCaller;
    175         pBlock->iLine     = iLine;
    176         pBlock->size      = cb;
    177 
    178         vrdpMemAppendBlock (pBlock);
    179 
    180         pv = MLD_BLOCK_TO_PTR(pBlock);
    181 
    182         pBlock->pv = pv;
    183     }
    184     else
    185     {
    186         pv = MLDMemAllocDbg (cb, false /* fTmp */, false /* fZero */, pszCaller, iLine);
    187     }
    188 
    189     vrdpMemUnlock ();
    190 
    191     return pv;
    192 }
    193 
    194 void MLDMemFreeDbg (void *pv, bool fTmp)
    195 {
    196     MLDMemBlock *pBlock;
    197 
    198     // LogFlowFunc(("pv = %d, fTmp = %d\n",
    199     //              pv, fTmp));
    200 
    201     vrdpMemLock ();
    202 
    203     pBlock = MLD_PTR_TO_BLOCK(pv);
    204 
    205     if (pBlock)
    206     {
    207         Assert(pBlock->uSignature == MLD_BLOCK_SIGNATURE);
    208         Assert(pBlock->fTmp == fTmp);
    209         Assert(pBlock->pv == pv);
    210 
    211         vrdpMemExcludeBlock (pBlock);
    212 
    213         RTMemFree (pBlock);
    214         gFreed++;
    215     }
    216 
    217     vrdpMemUnlock ();
    218 }
    219 
    220 
    221 void MLDMemDump (void)
    222 {
    223     MLDMemBlock *pBlock = gMemBlockListHead;
    224 
    225     int c = 0;
    226     size_t size = 0;
    227     while (pBlock)
    228     {
    229         LogRel(("%s-MLDMEM: %p 0x%8X bytes %d %s@%d\n", gszMDLPrefix, pBlock, pBlock->size, pBlock->fTmp, pBlock->pszCaller, pBlock->iLine));
    230         c++;
    231         size += pBlock->size;
    232         pBlock = pBlock->next;
    233     }
    234 
    235     LogRel(("%s-MLDMEM: %d/%d/%d blocks allocated/freed/left, total %dKb in use.\n", gszMDLPrefix, gAllocated, gFreed, c, size / 1024));
    236 }
    237 
    238 static int gcRefsMem = 0;
    239 
    240 void MLDMemInit (const char *pszPrefix)
    241 {
    242     if (++gcRefsMem == 1)
    243     {
    244         int rc = RTCritSectInit (&g_critsect);
    245         AssertRC(rc);
    246         gMemBlockListHead = NULL;
    247         gszMDLPrefix = pszPrefix;
    248         gAllocated = 0;
    249         gFreed = 0;
    250         gfMLD = true;
    251     }
    252 }
    253 
    254 void MLDMemUninit (void)
    255 {
    256     MLDMemDump();
    257 
    258     if (--gcRefsMem == 0)
    259     {
    260         gfMLD = false;
    261         gMemBlockListHead = NULL;
    262 
    263         if (RTCritSectIsInitialized (&g_critsect))
    264         {
    265             RTCritSectDelete (&g_critsect);
    266         }
    267     }
    268 }
    269 
    270 void* operator new (std::size_t size) throw (std::bad_alloc)
    271 {
    272     if (gfMLD)
    273         return MLDMemAllocDbg (size, false /* bool fTmp */, true /* bool fZero */, __FILE__, __LINE__);
    274     else
    275         return malloc(size);
    276 }
    277 
    278 void operator delete (void* ptr) throw ()
    279 {
    280     if (gfMLD)
    281         MLDMemFreeDbg (ptr, false /* bool fTmp */);
    282     else
    283         free(ptr);
    284 }
    285 
    286 #endif /* !VBOX_WITH_VRDP_MEMLEAK_DETECTOR */
    287 
    28828CComModule _Module;
    28929
     
    30545        // idempotent, so doesn't harm, and needed for COM embedding scenario
    30646        RTR3Init();
    307 
    308 #ifdef VBOX_WITH_VRDP_MEMLEAK_DETECTOR
    309         MLDMemInit("VBOXC");
    310 #endif /* !VBOX_WITH_VRDP_MEMLEAK_DETECTOR */
    31147    }
    31248    else if (dwReason == DLL_PROCESS_DETACH)
    31349    {
    31450        _Module.Term();
    315 
    316 #ifdef VBOX_WITH_VRDP_MEMLEAK_DETECTOR
    317         MLDMemUninit();
    318 #endif /* !VBOX_WITH_VRDP_MEMLEAK_DETECTOR */
    31951    }
    32052    return TRUE;
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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