开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
mmapmgr.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：28k
源码类别：

Symbian

开发平台：

C/C++

mmapmgr.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. // no memory map support on VXWORKS or Symbian
  37. #if !defined(_VXWORKS) && !defined(_SYMBIAN)
  39. /*
  40.  * MMapMgr needs atomic ref increments.
  41.  */
  42. #define _WIN32_USE_INTERLOCKED_INCREMENT
  43. #include "hxcom.h"
  44. #include "hxtypes.h"
  45. #ifndef _MACINTOSH
  47. #include <stdio.h>
  48. #include <stdlib.h>
  50. #ifdef _UNIX
  51. #include <unistd.h>
  52. #include <fcntl.h>
  53. #endif
  55. #include "hlxclib/sys/types.h"
  56. #include "hlxclib/sys/stat.h"
  57. #include "hlxclib/io.h"
  59. #if defined(_UNIX) && !defined(_BEOS)
  60. #include <sys/mman.h>
  61. #endif
  63. #include "hxbuffer.h"
  64. #include "hxstrutl.h"
  65. #include "hxmap.h"
  66. #include "hxengin.h"
  67. #include "mmapmgr.h"
  68. #include "hxspriv.h"
  69. #include "debug.h"
  70. #include "mmapdatf.h"
  71. #include "hxassert.h"
  72. #include "hxmon.h"
  74. #ifdef _MMM_NEED_MUTEX
  75. #include "hxcomm.h"
  76. #endif
  78. //#define  MMAPDEBUG
  79. //#define  MMAPMOREDEBUG
  81. #ifdef MMAPDEBUG
  82. #define MMAPDPRINTF(x) printf x
  83. #else
  84. #define MMAPDPRINTF(x)
  85. #endif
  87. /* Must be a multiple of the page size */
  88. #define MMAP_INITIAL_CHUNK_SIZE
  89. (256 * 1024)
  91. #define MMAP_EXTRA_SLOP_SIZE
  92. 65536
  94. #define MAX_ADDRESS_SPACE_USED
  95. 1 * 1024 * 1000 * 1000 // 1 Gig
  97. #define MS_BETWEEN_HANDLE_REAP_BUCKETS
  98. 3000
  100. #define NUMBER_OF_REAP_BUCKETS_TO_EMPTY_ON_ADDRESS_SPACE_EXHUSTED
  101. 2
  104. #ifndef MAP_FAIL
  105. #define MAP_FAIL ((void *)-1)
  106. #endif
  108. /*
  109.  * On Linux/NT we have 1 address space for all procs.  On other unicies we
  110.  * have 'n' processes and 'n' address spaces.  This variables tracks address
  111.  * usage correctly on all 3 types of OSes.
  112.  */
  113. UINT32     g_ulAddressSpaceUsed = 0;
  116. /*
  117.  *  On the server we wish to reap the memory after a little bit of time
  118.  *  because it is very likely that we will want to use it again in a 
  119.  *  short amount of time. On the client we do not wish to do this, becuase we
  120.  *  can not do good things like delete the file if it is mem-mapped.
  121.  */
  123. static BOOL z_bDeterminedIfWeAreWithinServer    = FALSE;
  124. static BOOL z_bWithinServer                     = FALSE;
  126. /*
  127.  * On NT we only have one MemoryMapManager per server.
  128.  * On other unix platforms, we have on MemoryMapManager
  129.  * per process.
  130.  *
  131.  * XXXSMP The Linux code is Sub-Optimal!!  Since we have 1 address space,
  132.  * we should take advantage of the fact that pages that we are trying to
  133.  * map in one thread may already be mapped by another thread.  With 'n'
  134.  * MMM's, we can't take advantage of this optimization.
  135.  */
  136. MemoryMapManager::MemoryMapManager(IUnknown* pContext,
  137. BOOL bDisableMemoryMappedIO, UINT32 ulChunkSize)
  138.     : m_pMMMCallback(NULL)
  139. {
  140.     m_pDevINodeToFileInfoMap = new CHXMapStringToOb;
  141.     m_pDevINodeToFileInfoMap->InitHashTable(517);
  142.     m_ulActiveReapList = 0;
  144.     HX_VERIFY (HXR_OK ==
  145. pContext->QueryInterface(IID_IHXScheduler, (void **)&m_pScheduler));
  147.     if (!z_bDeterminedIfWeAreWithinServer)
  148.     {
  149.         z_bDeterminedIfWeAreWithinServer = TRUE;
  151.         IHXRegistry* pHXReg = NULL;
  153.         pContext->QueryInterface(IID_IHXRegistry, (void **)&pHXReg);
  154.         if (pHXReg)
  155.         {
  156.             HXPropType type = pHXReg->GetTypeByName("server.version");
  157.             if (type!= PT_UNKNOWN)
  158.             {
  159.                 z_bWithinServer = TRUE;
  160.             }
  161.             HX_RELEASE(pHXReg);
  162.         }
  163.     }
  165.     if (ulChunkSize)
  166.     {
  167. m_ulChunkSize = ulChunkSize;
  168.     }
  169.     else
  170.     {
  171. m_ulChunkSize = MMAP_INITIAL_CHUNK_SIZE;
  172.     }
  173.     m_lRefCount = 0;
  175.     if (z_bWithinServer)
  176.     {
  177. m_pMMMCallback = new MMMCallback(this);
  179. if (m_pMMMCallback)
  180. {
  181.     m_pMMMCallback->AddRef();
  182.     m_pMMMCallback->m_hPendingHandle = m_pScheduler->RelativeEnter(m_pMMMCallback, MS_BETWEEN_HANDLE_REAP_BUCKETS);
  183. }
  184.     }
  186. #ifdef _MMM_NEED_MUTEX
  187.     m_pMutex = NULL;
  188. #ifdef _DEBUG
  189.     m_bHaveMutex = FALSE;
  190. #endif
  191.     IHXCommonClassFactory* pCCF;
  192.     if (HXR_OK == pContext->QueryInterface(IID_IHXCommonClassFactory,
  193. (void**)&pCCF))
  194.     {
  195. pCCF->CreateInstance(CLSID_IHXMutex, (void**)&m_pMutex);
  196. pCCF->Release();
  197.     }
  198. #endif
  199.     m_pFastAlloc = NULL;
  200.     pContext->QueryInterface(IID_IHXFastAlloc, (void **)&m_pFastAlloc);
  201.     m_bDisableMemoryMappedIO = bDisableMemoryMappedIO;
  202. }
  205. MemoryMapManager::~MemoryMapManager()
  206. {
  207.     /* This had better be empty by now!! */
  208.     HX_DELETE(m_pDevINodeToFileInfoMap);
  210.     if (m_pMMMCallback && m_pMMMCallback->m_hPendingHandle)
  211.     {
  212. m_pScheduler->Remove(m_pMMMCallback->m_hPendingHandle);
  213.     }
  214.     HX_RELEASE(m_pMMMCallback);
  216.     HX_RELEASE(m_pScheduler);
  217.     HX_RELEASE(m_pFastAlloc);
  219. #ifdef _MMM_NEED_MUTEX
  220.     HX_RELEASE(m_pMutex);
  221. #endif
  222. }
  225. STDMETHODIMP
  226. MemoryMapManager::QueryInterface(REFIID riid, void** ppvObj)
  227. {
  228.     if (IsEqualIID(riid, IID_IUnknown))
  229.     {
  230.         AddRef();
  231.         *ppvObj = (IUnknown*)(IUnknown*)this;
  232.         return HXR_OK;
  233.     }
  235.     *ppvObj = NULL;
  236.     return HXR_NOINTERFACE;
  237. }
  240. /*
  241.  * These are the only AddRef/Release pairs
  242.  * that need to be thread safe.  All the
  243.  * other don't need to be.  Since _WIN32_USE_INTERLOCKED_INCREMENT
  244.  * is defined at the top of this file, every instance will be actual
  245.  * so for the ones that we don't want to use it we just do ++/--
  246.  */
  247. STDMETHODIMP_(ULONG32) 
  248. MemoryMapManager::AddRef()
  249. {
  250.     return InterlockedIncrement(&m_lRefCount);
  251. }
  254. STDMETHODIMP_(ULONG32) 
  255. MemoryMapManager::Release()
  256. {
  257.     if (InterlockedDecrement(&m_lRefCount) > 0)
  258.     {
  259.         return m_lRefCount;
  260.     }
  262.     delete this;
  264. #ifdef _WIN32
  265.     MemoryMapDataFile::m_zpMMM = NULL;
  266. #endif
  268.     return 0;
  269. }
  272. void
  273. MemoryMapManager::ProcessIdle()
  274. {
  275.     LockMutex();
  276.     m_ulActiveReapList = (m_ulActiveReapList + 1) % NUMBER_OF_REAP_BUCKETS;
  278.     EmptyReapBuckets();
  280.     /*
  281.      * Note: This callback is always called on Streamer #1 on NT, so the first
  282.      * streamer to be spawned will reap dead pages for all other processes.
  283.      */
  284.     m_pMMMCallback->m_hPendingHandle =m_pScheduler->RelativeEnter(
  285. m_pMMMCallback, MS_BETWEEN_HANDLE_REAP_BUCKETS);
  287.     UnlockMutex();
  288.     return;
  289. }
  292. /*
  293.  * This context is from the correct process to charge the descriptor usage
  294.  * against.
  295.  */
  296.  
  297. void*
  298. MemoryMapManager::GetMMHandle(FILE_IDENTIFIER Descriptor)
  299. {
  300.     char pLookup[128]; /* Flawfinder: ignore */
  301.     UINT32 ulSize = 0;
  303. #ifdef _UNIX
  304.     struct stat s;
  306.     if (fstat(Descriptor, &s) == 0)
  307.     {
  308. if (!s.st_dev || !s.st_ino)
  309. {
  310.     return 0;
  311. }
  313. #ifdef _RED_HAT_5_X_
  314.     /* Why make devices 64 bit??? */
  315. sprintf (pLookup, "%lld,%ld", s.st_dev, s.st_ino); /* Flawfinder: ignore */
  316. #else
  317. sprintf (pLookup, "%d,%ld", s.st_dev, s.st_ino); /* Flawfinder: ignore */
  318. #endif
  319. ASSERT(s.st_dev);
  320. ASSERT(s.st_ino);
  321. ulSize = (UINT32)s.st_size;
  323. MMAPDPRINTF(("%p: GetHandle %d %d %ld  ", this,
  324.     Descriptor, s.st_dev, s.st_ino));
  325.     }
  326. #elif defined(_WINDOWS)
  327.     BY_HANDLE_FILE_INFORMATION FileInformation;
  329.     if (GetFileInformationByHandle(Descriptor, &FileInformation))
  330.     {
  331. sprintf (pLookup, "%x,%x,%x", FileInformation.nFileIndexLow, /* Flawfinder: ignore */
  332.     FileInformation.nFileIndexHigh, FileInformation.dwVolumeSerialNumber);
  334. ulSize = FileInformation.nFileSizeLow;
  336. MMAPDPRINTF(("%p: '%s'n", Descriptor, pLookup));
  337.     }
  338. #endif
  340.     if (ulSize == 0)
  341.     {
  342. return 0;
  343.     }
  345.     void* pVoid = NULL;
  346.     LockMutex();
  347.     m_pDevINodeToFileInfoMap->Lookup(pLookup, pVoid);
  348.     UnlockMutex();
  349.     return pVoid;
  350. }
  352. void*
  353. MemoryMapManager::OpenMap(FILE_IDENTIFIER Descriptor, IUnknown* pContext)
  354. {
  355.     char pLookup[128]; /* Flawfinder: ignore */
  356.     UINT32 ulSize = 0;
  358.     if (m_bDisableMemoryMappedIO)
  359.     {
  360. return NULL;
  361.     }
  363. #ifdef _UNIX
  364.     struct stat s;
  366.     if (fstat(Descriptor, &s) == 0)
  367.     {
  368. if (!s.st_dev || !s.st_ino)
  369. {
  370.     return 0;
  371. }
  373. #ifdef _RED_HAT_5_X_
  374. /* Why make devices 64 bit??? */
  375. sprintf (pLookup, "%lld,%ld", s.st_dev, s.st_ino); /* Flawfinder: ignore */
  376. #else
  377. sprintf (pLookup, "%d,%ld", s.st_dev, s.st_ino); /* Flawfinder: ignore */
  378. #endif
  379. ASSERT(s.st_dev);
  380. ASSERT(s.st_ino);
  381. ulSize = (UINT32)s.st_size;
  383. MMAPDPRINTF(("%p: OpenMap %d %d %ld  ", this,
  384.     Descriptor, s.st_dev, s.st_ino));
  385.     }
  386. #elif defined(_WINDOWS)
  387.     BY_HANDLE_FILE_INFORMATION FileInformation;
  389.     if (GetFileInformationByHandle(Descriptor, &FileInformation))
  390.     {
  391. sprintf (pLookup, "%x,%x,%x", FileInformation.nFileIndexLow, /* Flawfinder: ignore */
  392.     FileInformation.nFileIndexHigh, FileInformation.dwVolumeSerialNumber);
  394. ulSize = FileInformation.nFileSizeLow;
  396. MMAPDPRINTF(("%p: '%s'n", Descriptor, pLookup));
  397.     }
  398. #endif
  400.     if (ulSize == 0)
  401.     {
  402. return 0;
  403.     }
  405.     void* pVoid = NULL;
  406.     struct _FileInfo* pInfo = NULL;
  408.     LockMutex();
  409.     m_pDevINodeToFileInfoMap->Lookup(pLookup, pVoid);
  410.     if (pVoid)
  411.     {
  412. MMAPDPRINTF(("(OpenMap Found Already)n"));
  413. pInfo = (struct _FileInfo*) pVoid;
  414. HX_ASSERT (pInfo->Descriptor != 0);
  415. pInfo->ulRefCount++;
  416. pInfo->ulUseCount++;
  417. /* In case the file size has changed */
  418. pInfo->ulSize = ulSize;
  420. UnlockMutex();
  421. return pVoid;
  422.     }
  423.     else
  424.     {
  425. MMAPDPRINTF(("(OpenMap New)n"));
  426. #ifdef _UNIX
  427. m_pDevINodeToFileInfoMap->SetAt(pLookup, pInfo = new struct _FileInfo);
  428. pInfo->Descriptor = dup(Descriptor);
  429. #else
  431. HANDLE hTest = CreateFileMapping(Descriptor, NULL, PAGE_READWRITE, 0, 0, NULL);
  432. if (!hTest)
  433. {
  434.     /*
  435.      * Try to open the mapping for read only.  This is supposed to handle
  436.      * readonly files.  If the file was opened for write then this
  437.      * will fail anyway, so we can't really do the wrong thing here.
  438.      */
  439.     hTest = CreateFileMapping(Descriptor, NULL, PAGE_READONLY, 0, 0, NULL);
  440.     if (!hTest)
  441.     {
  442. UnlockMutex();
  443. return NULL;
  444.     }
  445. }
  446. m_pDevINodeToFileInfoMap->SetAt(pLookup, pInfo = new struct _FileInfo);
  447. pInfo->Descriptor = hTest;
  448. #endif
  449. SafeStrCpy(pInfo->pKey, pLookup, FILEINFO_KEY_SIZE);
  450. pInfo->ulSize = ulSize;
  451. pInfo->pMgr = this;
  452. pInfo->pMgr->AddRef();
  453. pInfo->ulRefCount = 1;
  454. pInfo->ulUseCount = 1;
  455. #ifdef _WIN32
  456. pInfo->m_pPTEList = NULL;
  457. #endif
  458. memset(pInfo->pPageTable, 0, sizeof (pInfo->pPageTable));
  459. if (HXR_OK == pContext->QueryInterface(IID_IHXDescriptorRegistration,
  460.     (void **)&pInfo->pDescReg))
  461. {
  462.     pInfo->pDescReg->RegisterDescriptors(1);
  463. }
  464. else
  465. {
  466.     pInfo->pDescReg = NULL;
  467. }
  469. UnlockMutex();
  470. return (void *)pInfo;
  471.     }
  472. }
  475. #ifdef _WIN32
  476. void
  477. MemoryMapManager::AttemptCloseMapNow(void* pHandle)
  478. {
  479.     LockMutex();
  480.     struct _FileInfo* pInfo = (struct _FileInfo*)pHandle;
  481.     _PageTableEntry* pPTE;
  482.     _PageTableEntry* pNextPTE;
  483.     pNextPTE = pInfo->m_pPTEList;
  484.     while (pNextPTE)
  485.     {
  486. pPTE = pNextPTE;
  487. pNextPTE = pPTE->m_pNextPTE;
  488. pPTE->bReapMe = TRUE;
  489. CheckAndReapPageTableEntry(pPTE);
  490.     }
  491.     UnlockMutex();
  492. }
  493. #endif
  495. void
  496. MemoryMapManager::CloseMap(void* pHandle)
  497. {
  498.     LockMutex();
  499.     MMAPDPRINTF(("CloseMapn"));
  500.     struct _FileInfo* pInfo = (struct _FileInfo*)pHandle;
  501.     pInfo->ulRefCount--;
  502.     pInfo->ulUseCount--;
  504.     if (pInfo->ulRefCount == 0)
  505.     {
  506.         DestroyFileInfo(pHandle);
  507.     }
  509. #if 0
  510.     /*
  511.      * This code is really slow and not needed.  These pages will be
  512.      * reaped shortly by the timed reaper.
  513.      */
  514.     if (pInfo->ulUseCount == 0)
  515.     {
  516. for (int i = 0; i < NUM_PTES; i++)
  517. {
  518.     if (pInfo->pPageTable[i] == NULL)
  519.     {
  520. continue;
  521.     }
  523.     struct _PageTableEntry* pIE = 0;
  525.     for (int j = 0; j < NUM_PTES; j++)
  526.     {
  527. pIE = (struct _PageTableEntry*)
  528.     &(pInfo->pPageTable[i]->pEntry[j]);
  529. if (pIE->bActive == FALSE)
  530. {
  531.     continue;
  532. }
  533. pIE->bReapMe = TRUE;
  534. CheckAndReapPageTableEntry(pIE);
  535. if (pInfo->pPageTable[i] == NULL)
  536. {
  537.     break;
  538. }
  539.     }
  540. }
  541.     }
  542. #endif
  543.     MMAPDPRINTF(("Done CloseMapn"));
  545.     UnlockMutex();
  546. }
  549. /*
  550.  * On _WIN32 whoever calls this MUST have the mUTex!!!
  551.  */
  552. void MemoryMapManager::EmptyReapBuckets()
  553. {
  554. #if defined  _MMM_NEED_MUTEX && defined _DEBUG
  555.     HX_ASSERT(m_bHaveMutex);
  556. #endif
  558.     UINT32 ulListToReap = (m_ulActiveReapList + 1) % NUMBER_OF_REAP_BUCKETS;
  560.     if (!ReapBuckets[ulListToReap].IsEmpty())
  561.     {
  562. CHXSimpleList* pList = &ReapBuckets[ulListToReap];
  563. struct _PageTableEntry* pIE = 0;
  564. LISTPOSITION l = pList->GetHeadPosition();
  565. LISTPOSITION temp;
  567. while (l)
  568. {
  569.     pIE = (struct _PageTableEntry*)pList->GetAt(l);
  570.     pIE->bReapMe = TRUE;
  571.     temp = l;
  572.     pList->GetNext(l);
  573.     if (CheckAndReapPageTableEntry(pIE) == FALSE)
  574.     {
  575. pIE->bDeadPage = TRUE;
  576. pList->RemoveAt(temp);
  577.     }
  578.     else
  579.     {
  580.     }
  581. }
  582.     }
  583. }
  586. UINT32
  587. MemoryMapManager::GetBlock(REF(IHXBuffer*) pBuffer, void* pHandle,
  588.     UINT32 ulOffset, UINT32 ulSize)
  589. {
  590.     LockMutex();
  591.     struct _FileInfo* pInfo = (struct _FileInfo*)pHandle;
  592.     UINT32 ulNeededPageNumber = (ulOffset / m_ulChunkSize);
  593.     UINT32 ulNeededL1Entry = ulNeededPageNumber / NUM_PTES;
  594.     UINT32 ulNeededL2Entry = ulNeededPageNumber % NUM_PTES;
  595.     struct _PageTableEntry* pEntry = 0;
  597. #ifdef MMAPMOREDEBUG
  598.     MMAPDPRINTF(("%p GetBlock %d %d, Page %d/%dn", pHandle, ulOffset, ulSize,
  599.     ulNeededL1Entry, ulNeededL2Entry));
  600.     fflush(0);
  601. #endif
  603.     if (ulOffset >= pInfo->ulSize)
  604.     {
  605. /* Maybe the file has grown */
  606. #ifdef _UNIX
  607. struct stat s;
  608. if (fstat(pInfo->Descriptor, &s) == 0)
  609. {
  610.     pInfo->ulSize = (UINT32)s.st_size;
  611. }
  612. #elif defined(_WINDOWS)
  613.         BY_HANDLE_FILE_INFORMATION FileInformation;
  614.         if (GetFileInformationByHandle(pInfo->Descriptor, &FileInformation))
  615. {
  616.     pInfo->ulSize = FileInformation.nFileSizeLow;
  617. }
  618. #endif
  620. if (ulOffset >= pInfo->ulSize)
  621. {
  622.     pBuffer = NULL;
  623.     UnlockMutex();
  624.     return (ULONG32) MMAP_EOF_EXCEPTION;
  625. }
  626.     }
  628.     if (pInfo->pPageTable[ulNeededL1Entry])
  629.     {
  630. if (pInfo->pPageTable[ulNeededL1Entry]->pEntry[ulNeededL2Entry].bActive)
  631. {
  632.     pEntry = &pInfo->pPageTable[ulNeededL1Entry]->
  633. pEntry[ulNeededL2Entry];
  634. }
  635.     }
  637.     UCHAR* ulDataPointer = 0;
  639.     if (!pEntry)
  640.     {
  641. UINT32 ulEmptyAttempts = 0;
  643. while (g_ulAddressSpaceUsed > MAX_ADDRESS_SPACE_USED &&
  644.     ulEmptyAttempts++ <
  645.     NUMBER_OF_REAP_BUCKETS_TO_EMPTY_ON_ADDRESS_SPACE_EXHUSTED)
  646. {
  647.     /*
  648.      * Attempt to unmap some old pages and hopefully free up
  649.      * some address space.
  650.      */
  651.     m_ulActiveReapList = (m_ulActiveReapList + 1)
  652. % NUMBER_OF_REAP_BUCKETS;
  654.     EmptyReapBuckets();
  655. }
  657. if (g_ulAddressSpaceUsed > MAX_ADDRESS_SPACE_USED)
  658. {
  659.     MMAPDPRINTF((" Address Space Exceeded, Exceptionn"));
  660.     UnlockMutex();
  661.     return MMAP_EXCEPTION;
  662. }
  664. if (pInfo->pPageTable[ulNeededL1Entry] == NULL)
  665. {
  666.     pInfo->pPageTable[ulNeededL1Entry] = 
  667. new struct MemoryMapManager::_PageTableLevel1;
  668.     memset(pInfo->pPageTable[ulNeededL1Entry], 0, sizeof(
  669. struct MemoryMapManager::_PageTableLevel1));
  670.     pInfo->pPageTable[ulNeededL1Entry]->
  671. ulNumberOfPageTableEntriesInUse = 0;
  672.     pInfo->pPageTable[ulNeededL1Entry]->
  673. pMyEntryInParentsPageTable =
  674. &pInfo->pPageTable[ulNeededL1Entry];
  675. #ifdef _WIN32
  676.     pInfo->m_pPTEList = NULL;
  677. #endif
  678. }
  679. pInfo->pPageTable[ulNeededL1Entry]->
  680.     ulNumberOfPageTableEntriesInUse++;
  681. pEntry = &pInfo->pPageTable[ulNeededL1Entry]->pEntry[ulNeededL2Entry];
  682. pEntry->bActive = TRUE;
  683. pEntry->bReapMe = FALSE;
  684. pEntry->bDeadPage = FALSE;
  685. pEntry->ulPageRefCount = 0;
  686. pEntry->pParent = pInfo->pPageTable[ulNeededL1Entry];
  687. pEntry->pInfo = pInfo;
  690. UINT32 ulChunkSize = m_ulChunkSize + MMAP_EXTRA_SLOP_SIZE;
  691. if (ulChunkSize + ulNeededPageNumber * m_ulChunkSize > pInfo->ulSize)
  692. {
  693.     ulChunkSize = pInfo->ulSize - ulNeededPageNumber * m_ulChunkSize;
  694. }
  696. pEntry->ulSize = ulChunkSize;
  697. pInfo->ulRefCount++;
  699. #ifdef _BEOS // no mmap for BeOS yet...
  700. pEntry->pPage = MAP_FAIL;
  701. #else
  702. #ifdef _UNIX
  703. pEntry->pPage =
  704.     mmap(0, ulChunkSize, PROT_READ, MAP_PRIVATE, 
  705.     pInfo->Descriptor, ulNeededPageNumber * m_ulChunkSize);
  706. #else
  707. pEntry->pPage = MapViewOfFile(pInfo->Descriptor, FILE_MAP_READ, 0,
  708.     ulNeededPageNumber * m_ulChunkSize, ulChunkSize);
  709. if (pEntry->pPage == 0)
  710. {
  711.     pEntry->pPage = MAP_FAIL;
  712. }
  713. else
  714. {
  715. #if !defined(HELIX_FEATURE_SERVER) && defined(_WINDOWS)
  716.             // When MapViewOfFile is called it returns a handle to a page of memory that
  717.             // the system no longer knows about so an exception occurs.  It is usally a 
  718.             // EXCEPTION_IN_PAGE_ERROR. Reading the documentation it appears that all access
  719.             // to handles returned from memory mapped I/O should be wrapped in try/catch blocks 
  720.             // since the handles may be invalid.  I added try/catch logic to test this out and
  721.             // it fixes the bug.  The main problem I'm not sure about is that this code is also 
  722.             // used by the server and IsBadReadPtr may iterate over the memory block which can 
  723.             // be slow.  Because this is the layer of code that "knows" it is using memory mapped 
  724.             // I/O this is probably where the try/catch code belongs so that if an exception
  725.             // occurs then it can return an error and no buffer since the buffer wouldn't be
  726.             // accessible anyway.
  727.             BOOL bInvalid = TRUE;
  729.             try
  730.             {
  731.                bInvalid = ::IsBadReadPtr(pEntry->pPage, ulChunkSize);
  732.             }
  733.             catch (...)
  734.             {
  735.             }
  737.             if (bInvalid)
  738.             {
  739.                pEntry->pPage = MAP_FAIL;
  740.             }
  741.             else
  742.             {
  743.                 if (pInfo->m_pPTEList)
  744.                 {
  745.                     pInfo->m_pPTEList->m_pPrevPTE = pEntry;
  746.                 }
  747.                 pEntry->m_pNextPTE = pInfo->m_pPTEList;
  748.                 pEntry->m_pPrevPTE = NULL;
  749.                 pInfo->m_pPTEList = pEntry;
  750.             }
  751. #else
  752.     if (pInfo->m_pPTEList)
  753.     {
  754. pInfo->m_pPTEList->m_pPrevPTE = pEntry;
  755.     }
  756.     pEntry->m_pNextPTE = pInfo->m_pPTEList;
  757.     pEntry->m_pPrevPTE = NULL;
  758.     pInfo->m_pPTEList = pEntry;
  759. #endif /* !HELIX_FEATURE_SERVER && _WINDOWS */
  760. }
  761. #endif
  762. #endif /* _BEOS */
  764. MMAPDPRINTF(("MMAP from %d Size %ld Pos %ld = %p (entry %p)n",
  765.     pInfo->Descriptor, ulChunkSize,
  766.     ulNeededPageNumber * m_ulChunkSize,
  767.     pEntry->pPage, pEntry));
  769. g_ulAddressSpaceUsed += ulChunkSize;
  771. pEntry->usReapListNumber = m_ulActiveReapList;
  772. pEntry->ReapListPosition = ReapBuckets[m_ulActiveReapList].
  773.     AddHead(pEntry);
  775. if (pEntry->pPage == MAP_FAIL)
  776. {
  777.     pBuffer = NULL;
  778.     pEntry->bReapMe = TRUE;
  779.     CheckAndReapPageTableEntry(pEntry);
  780.     UnlockMutex();
  781.     return (UINT32) MMAP_EXCEPTION;
  782. }
  783.     }
  784.     else
  785.     {
  786. if (pEntry->bDeadPage ||
  787.     (m_ulActiveReapList != pEntry->usReapListNumber))
  788. {
  789.     if (pEntry->bDeadPage)
  790.     {
  791. MMAPDPRINTF(("UnDeadPage to %p!n", pEntry));
  792.      pEntry->bDeadPage = FALSE;
  793.     }
  794.     else
  795.     {
  796. ReapBuckets[pEntry->usReapListNumber].
  797.     RemoveAt(pEntry->ReapListPosition);
  798.     }
  799.     pEntry->usReapListNumber = m_ulActiveReapList;
  800.     pEntry->ReapListPosition = ReapBuckets[m_ulActiveReapList].
  801. AddHead(pEntry);
  802. }
  804. pEntry->bReapMe = FALSE;
  805.     }
  807.     ulDataPointer = ((UCHAR *) pEntry->pPage) + ulOffset % m_ulChunkSize;
  809.     /*
  810.      * Go back to normal read() if we are asking for something past
  811.      * the mapped region.
  812.      */
  813.     if ((ulOffset + ulSize > pInfo->ulSize) ||
  814.         (ulOffset % m_ulChunkSize + ulSize > pEntry->ulSize))
  815.     {
  816. /*
  817.  * If the file has grown, then the region we mapped may not be
  818.  * large enough, but we can remap it.  This is a rare optimization
  819.  * that we can do without.
  820.  */
  821. BOOL bEOF = (ulOffset + ulSize > pInfo->ulSize);
  823. MMAPDPRINTF((" Memory Map Page Overrun, Exceptionn"));
  825. pBuffer = NULL;
  827. if (!z_bWithinServer)
  828. {
  829.     // Do not defer clean-up of unused pages when in client
  830.     pEntry->bReapMe = TRUE;
  831.     CheckAndReapPageTableEntry(pEntry);
  832. }
  834. UnlockMutex();
  836. if (bEOF)
  837. {
  838.     return MMAP_EOF_EXCEPTION;
  839. }
  840. else
  841. {
  842.     return MMAP_EXCEPTION;
  843. }
  844.     }
  846.     pBuffer = new(m_pFastAlloc) Buffer(pEntry, ulDataPointer, ulSize);
  847.     if(pBuffer)
  848.     {
  849.         pBuffer->AddRef();
  850.     }
  851.     else
  852.     {
  853.         ulSize = 0;
  854.     }
  856.     UnlockMutex();
  857.     return ulSize;
  858. }
  861. /*
  862.  * On _WIN32 you MUST have the mutex to call this!
  863.  */
  864. BOOL
  865. MemoryMapManager::CheckAndReapPageTableEntry(struct _PageTableEntry* pPTE)
  866. {
  867. #if defined  _MMM_NEED_MUTEX && defined _DEBUG
  868.     HX_ASSERT(pPTE->pInfo->pMgr->m_bHaveMutex);
  869. #endif
  871.     struct _FileInfo* pInfo = pPTE->pInfo;
  873.     if (pPTE->ulPageRefCount == 0 && pPTE->bReapMe)
  874.     {
  875. MMAPDPRINTF(("Unmap Chunk %p %ld  ", pPTE->pPage, pPTE->ulSize));
  877. if (pPTE->pPage != MAP_FAIL)
  878. {
  879. #ifdef _BEOS
  880.     // no memory mapped IO for BeOS yet!
  881. #else
  882. #ifdef _UNIX
  883. #ifdef _SOLARIS
  884.     munmap((char*)(pPTE->pPage), pPTE->ulSize);
  885. #else
  886.     munmap(pPTE->pPage, pPTE->ulSize);
  887. #endif
  888. #else
  889.     UnmapViewOfFile(pPTE->pPage);
  890.     if (pPTE->m_pPrevPTE)
  891.     {
  892. pPTE->m_pPrevPTE->m_pNextPTE = pPTE->m_pNextPTE;
  893.     }
  894.     else
  895.     {
  896. pInfo->m_pPTEList = pPTE->m_pNextPTE;
  897.     }
  898.     if (pPTE->m_pNextPTE)
  899.     {
  900. pPTE->m_pNextPTE->m_pPrevPTE = pPTE->m_pPrevPTE;
  901.     }
  902. #endif
  903. #endif /* _BEOS */
  904. }
  906. pInfo->ulRefCount--;
  907. g_ulAddressSpaceUsed -= pPTE->ulSize;
  908. MMAPDPRINTF((" (Down to %0.2f), Reap %un",
  909.     g_ulAddressSpaceUsed
  910.     / (1.0 * pInfo->pMgr->m_ulChunkSize + MMAP_EXTRA_SLOP_SIZE),
  911.     pPTE->bReapMe));
  912. pPTE->bActive = FALSE;
  914. if (pPTE->bDeadPage == FALSE)
  915. {
  916.     pInfo->pMgr->ReapBuckets[pPTE->usReapListNumber].
  917. RemoveAt(pPTE->ReapListPosition);
  918. }
  920. if (--pPTE->pParent->ulNumberOfPageTableEntriesInUse == 0)
  921. {
  922.     struct _PageTableLevel1** pPTL1 =
  923. pPTE->pParent->pMyEntryInParentsPageTable;
  924.     *pPTL1 = 0;
  925.     delete pPTE->pParent;
  926. }
  928.         if (pInfo->ulRefCount == 0)
  929.             DestroyFileInfo((void*)pInfo);
  931. return TRUE;
  932.     }
  934.     return FALSE;
  935. }
  937. /*
  938.  * On _WIN32 you MUST have the mutex to call this!
  939.  */
  940. void
  941. MemoryMapManager::DestroyFileInfo(void* pHandle)
  942. {
  943. #if defined  _MMM_NEED_MUTEX && defined _DEBUG
  944.     HX_ASSERT(((struct _FileInfo*)pHandle)->pMgr->m_bHaveMutex);
  945. #endif
  947.     struct _FileInfo* pInfo = (struct _FileInfo*)pHandle;
  949.     MMAPDPRINTF(("Remove %s from %pn", pInfo->pKey,
  950. pInfo->pMgr->m_pDevINodeToFileInfoMap));
  951.     pInfo->pMgr->m_pDevINodeToFileInfoMap->RemoveKey
  952. ((const char *)pInfo->pKey);
  954.     /*
  955.      * Don't use MemoryMapManager's context!  You will credit the wrong
  956.      * process.
  957.      */
  958.     if (pInfo->pDescReg)
  959.     {
  960. pInfo->pDescReg->UnRegisterDescriptors(1);
  961. HX_RELEASE(pInfo->pDescReg);
  962.     }
  964. #ifdef _UNIX
  965.     close(pInfo->Descriptor);
  966. #else
  967.     CloseHandle(pInfo->Descriptor);
  968. #endif
  970.     HX_RELEASE(pInfo->pMgr);
  971.     delete pInfo;
  972. }
  975. MemoryMapManager::Buffer::Buffer(struct _PageTableEntry* pEntry, UCHAR* pData,
  976.     ULONG32 ulLength)
  977.     : m_lRefCount(0)
  978.     , m_ulLength(ulLength)
  979.     , m_pData(pData)
  980.     , m_pPTE(pEntry)
  981. {
  982.     ASSERT(m_pPTE);
  983.     m_pPTE->ulPageRefCount++;
  984. }
  987. MemoryMapManager::Buffer::~Buffer()
  988. {
  989.     MemoryMapManager* pMgr = m_pPTE->pInfo->pMgr;
  990.     pMgr->LockMutex();
  992.     m_pPTE->ulPageRefCount--;
  993.     if (!z_bWithinServer && !m_pPTE->ulPageRefCount)
  994.         m_pPTE->bReapMe = TRUE;
  995.     MemoryMapManager::CheckAndReapPageTableEntry(m_pPTE);
  997.     pMgr->UnlockMutex();
  998. }
  1001. STDMETHODIMP
  1002. MemoryMapManager::Buffer::QueryInterface(REFIID riid, void** ppvObj)
  1003. {
  1004. QInterfaceList qiList[] =
  1005. {
  1006. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IUnknown*)this },
  1007. { GET_IIDHANDLE(IID_IHXBuffer), (IUnknown*)(IHXBuffer*)this },
  1008. };
  1009.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);   
  1010. }
  1013. STDMETHODIMP_(ULONG32) 
  1014. MemoryMapManager::Buffer::AddRef()
  1015. {
  1016.     m_lRefCount++;
  1017.     return m_lRefCount;
  1018. }
  1021. STDMETHODIMP_(ULONG32) 
  1022. MemoryMapManager::Buffer::Release()
  1023. {
  1024.     m_lRefCount--;
  1025.     if (m_lRefCount > 0)
  1026.     {
  1027.         return m_lRefCount;
  1028.     }
  1030.     delete this;
  1031.     return 0;
  1032. }
  1035. STDMETHODIMP
  1036. MemoryMapManager::Buffer::Get(REF(UCHAR*) pData, REF(ULONG32) ulLength)
  1037. {
  1038.     pData = m_pData;
  1039.     ulLength = m_ulLength;
  1041.     return HXR_OK;
  1042. }
  1045. STDMETHODIMP
  1046. MemoryMapManager::Buffer::Set(const UCHAR* pData, ULONG32 ulLength)
  1047. {
  1048.     /* XXXSMP We should support this. */
  1049.     PANIC(("Internal Error mmgr/620"));
  1050.     return HXR_UNEXPECTED;
  1051. }
  1054. STDMETHODIMP
  1055. MemoryMapManager::Buffer::SetSize(ULONG32 ulLength)
  1056. {
  1057.     /* XXXSMP We should support this. */
  1058.     if (ulLength < m_ulLength)
  1059.     {
  1060. m_ulLength = ulLength;
  1061. return HXR_OK;
  1062.     }
  1063.     else
  1064.     {
  1065.     PANIC(("Internal Error mmgr/635"));
  1066. return HXR_UNEXPECTED;
  1067.     }
  1068. }
  1071. STDMETHODIMP_(ULONG32)
  1072. MemoryMapManager::Buffer::GetSize()
  1073. {
  1074.     return m_ulLength;
  1075. }
  1078. STDMETHODIMP_(UCHAR*)
  1079. MemoryMapManager::Buffer::GetBuffer()
  1080. {
  1081.     return m_pData;
  1082. }
  1084. // MemoryMapManager callback
  1086. MMMCallback::MMMCallback(MemoryMapManager* pMMM)
  1087.    :m_lRefCount(0)
  1088.    ,m_pMMM(pMMM)
  1089.    ,m_hPendingHandle(0)
  1090. {
  1091. }
  1093. MMMCallback::~MMMCallback()
  1094. {
  1095. }
  1097. STDMETHODIMP
  1098. MMMCallback::QueryInterface(REFIID riid, void**ppvObj)
  1099. {
  1100. QInterfaceList qiList[] =
  1101. {
  1102. { GET_IIDHANDLE(IID_IUnknown), this },
  1103. { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*) this },
  1104. };
  1105.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  1106. }
  1108. /////////////////////////////////////////////////////////////////////////
  1109. //  Method:
  1110. // IUnknown::AddRef
  1111. //  Purpose:
  1112. // Everyone usually implements this the same... feel free to use
  1113. // this implementation.
  1114. //
  1115. STDMETHODIMP_(ULONG32) 
  1116. MMMCallback::AddRef()
  1117. {
  1118.     m_lRefCount++;
  1119.     return m_lRefCount;
  1120. }
  1122. /////////////////////////////////////////////////////////////////////////
  1123. //  Method:
  1124. // IUnknown::Release
  1125. //  Purpose:
  1126. // Everyone usually implements this the same... feel free to use
  1127. // this implementation.
  1128. //
  1129. STDMETHODIMP_(ULONG32) 
  1130. MMMCallback::Release()
  1131. {
  1132.     m_lRefCount--;
  1133.     if (m_lRefCount > 0)
  1134.     {
  1135.         return m_lRefCount;
  1136.     }
  1138.     delete this;
  1139.     return 0;
  1140. }
  1142. STDMETHODIMP
  1143. MMMCallback::Func(void)
  1144. {
  1145.     m_hPendingHandle = 0;
  1147.     if (m_pMMM)
  1148.     {
  1149. m_pMMM->AddRef();
  1150. m_pMMM->ProcessIdle();
  1151. m_pMMM->Release();
  1152.     }
  1154.     return HXR_OK;
  1155. }
  1157. #endif
  1158. #endif /* _VXWORKS */