fsdalloc.cpp

WinCE5.0部分核心源码

                fh.pFindNextFileW = (PFINDNEXTFILEW)pDsk->pFSD->apfnFind[FINDAPI_FINDNEXTFILEW];
                fh.pFindClose = (PFINDCLOSE)pDsk->pFSD->apfnFind[FINDAPI_FINDCLOSE];

                fh.pReadFile = (PREADFILE)pDsk->pFSD->apfnFile[FILEAPI_READFILE];
                fh.pReadFileWithSeek = (PREADFILEWITHSEEK)pDsk->pFSD->apfnFile[FILEAPI_READFILEWITHSEEK];
                fh.pWriteFile = (PWRITEFILE)pDsk->pFSD->apfnFile[FILEAPI_WRITEFILE];
                fh.pWriteFileWithSeek = (PWRITEFILEWITHSEEK)pDsk->pFSD->apfnFile[FILEAPI_WRITEFILEWITHSEEK];
                fh.pSetFilePointer = (PSETFILEPOINTER)pDsk->pFSD->apfnFile[FILEAPI_SETFILEPOINTER];
                fh.pGetFileSize = (PGETFILESIZE)pDsk->pFSD->apfnFile[FILEAPI_GETFILESIZE];
                fh.pGetFileInformationByHandle = (PGETFILEINFORMATIONBYHANDLE)pDsk->pFSD->apfnFile[FILEAPI_GETFILEINFORMATIONBYHANDLE];
                fh.pFlushFileBuffers = (PFLUSHFILEBUFFERS)pDsk->pFSD->apfnFile[FILEAPI_FLUSHFILEBUFFERS];
                fh.pGetFileTime = (PGETFILETIME)pDsk->pFSD->apfnFile[FILEAPI_GETFILETIME];
                fh.pSetFileTime = (PSETFILETIME)pDsk->pFSD->apfnFile[FILEAPI_SETFILETIME];
                fh.pSetEndOfFile = (PSETENDOFFILE)pDsk->pFSD->apfnFile[FILEAPI_SETENDOFFILE];
                fh.pDeviceIoControl = (PDEVICEIOCONTROL)pDsk->pFSD->apfnFile[FILEAPI_DEVICEIOCONTROL];
                fh.pCloseFile = (PCLOSEFILE)pDsk->pFSD->apfnFile[FILEAPI_CLOSEFILE];
                fh.pLockFileEx = (PLOCKFILEEX)pDsk->pFSD->apfnFile[FILEAPI_LOCKFILEEX];
                fh.pUnlockFileEx = (PUNLOCKFILEEX)pDsk->pFSD->apfnFile[FILEAPI_UNLOCKFILEEX];

                fh.pReadFileScatter = (PREADFILESCATTER)pDsk->pFSD->pReadFileScatter;
                fh.pWriteFileGather = (PWRITEFILEGATHER)pDsk->pFSD->pWriteFileGather;                
                fh.pRefreshVolume = pDsk->pFSD->pRefreshVolume;
                fh.pGetVolumeInfo = (PGETVOLUMEINFO)pDsk->pFSD->pGetVolumeInfo;

                if (pTemp->pFSD->pfnHookVolume) {
                    __try {
                        dwVolData = pTemp->pFSD->pfnHookVolume(pTemp, &fh);
                    } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                        ASSERT(0);
                        // Todo  - Probably too late to remove it from the list ...
                    }    
                    pTemp->dwFilterVol = dwVolData;
                }
                pVol->pDsk = pTemp;
                pTemp->pVol = pVol;
                pDsk = pTemp;
                pTemp = pTemp->pPrevDisk;
            }
        }
        pVol->dwVolData = dwVolData;
    } else {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FSDMGR!AllocVolume: out of memory!\n")));
    }

    return pVol;
}


/*  DeallocVolume - Deallocate VOL structure
 *
 *  ENTRY
 *      pVol -> VOL structure
 *
 *  EXIT
 *      TRUE is VOL was successfully deallocated, FALSE if not (eg, if the VOL
 *      structure still has some HDL structures attached to it).
 *
 *      Currently, we never fail this function.  If handles are still attached to
 *      the volume, we forcibly close them;  that decision may need to be revisited....
 */

void UnHookAllFilters(PVOL pVol)
{
    if (pVol->pDsk) {
        while(pVol->pDsk->pNextDisk) {
            if (pVol->pDsk->dwFilterVol)
                __try {
                    pVol->pDsk->pFSD->pfnUnhookVolume(pVol->pDsk->dwFilterVol);
                } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(0);
                }    
            pVol->pDsk = pVol->pDsk->pNextDisk;
        }
    }    
}

BOOL DeallocVolumeHandles(PVOL pVol)
{
    PREFAST_ASSERT(VALIDSIG(pVol, VOL_SIG) && OWNCRITICALSECTION(&csFSD));
        
    PHDL pHdl;
    pHdl = pVol->dlHdlList.pHdlNext;
    while (pHdl != (PHDL)&pVol->dlHdlList) {
        if (!(pHdl->dwFlags & HDL_INVALID)) {
            __try {
                pHdl->dwFlags |= HDL_INVALID;
                if (pHdl->dwFlags & HDL_FILE) {
                    ((PCLOSEFILE)pVol->pDsk->pFSD->apfnFile[FILEAPI_CLOSEFILE])(pHdl->dwHdlData);
                } else
                if (pHdl->dwFlags & HDL_SEARCH) {
                    ((PFINDCLOSE)pVol->pDsk->pFSD->apfnFind[FINDAPI_FINDCLOSE])(pHdl->dwHdlData);
                }   
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            pHdl->pVol = NULL;
        }    
        pHdl = pHdl->dlHdl.pHdlNext;
    }

    RemoveListItem((PDLINK)&pHdl->dlHdl);
    return TRUE;
}

BOOL DeallocVolume(PVOL pVol)
{
    PREFAST_ASSERT(VALIDSIG(pVol, VOL_SIG) && OWNCRITICALSECTION(&csFSD));

    if (pVol->iAFS != INVALID_AFS)
        return FALSE;

    if (pVol->pDsk) {
        while(pVol->pDsk->pNextDisk) {
            pVol->pDsk->pVol = NULL;
            pVol->pDsk = pVol->pDsk->pNextDisk;
        }
        pVol->pDsk->pVol = NULL; // Get the main FSD's Disk
    }    

    LocalFree((HLOCAL)pVol);

    return TRUE;
}


/*  AllocFSDHandle - Allocate HDL structure for a VOL
 *
 *  ENTRY
 *      pVol -> VOL structure
 *      hProc == originating process handle
 *      dwHldData == value from FSD's call to FSDMGR_CreateXXXXHandle
 *      dwFlags == initial flags for HDL (eg, HDL_FILE or HDL_FIND)
 *
 *  EXIT
 *      An application handle, or INVALID_HANDLE_VALUE if error
 */

HANDLE AllocFSDHandle(PVOL pVol, HANDLE hProc, HANDLE hNotify, DWORD dwHdlData, DWORD dwFlags)
{
    PHDL pHdl;
    HANDLE h = INVALID_HANDLE_VALUE;

    if (pVol == NULL)
        return NULL;

    pHdl = (PHDL)LocalAlloc(LPTR, sizeof(HDL));

    if (pHdl) {
        LockFSDMgr();

        INITSIG(pHdl, (dwFlags & (HDL_FILE | HDL_PSUEDO))? HFILE_SIG : HSEARCH_SIG);
        AddListItem((PDLINK)&pVol->dlHdlList, (PDLINK)&pHdl->dlHdl);
        pHdl->pVol = pVol;
        pHdl->dwFlags = dwFlags;
        pHdl->dwHdlData = dwHdlData;
        pHdl->hNotify = hNotify;
        pHdl->h = CreateAPIHandle((dwFlags & (HDL_FILE | HDL_PSUEDO))? hFileAPI : hFindAPI, pHdl);
        if (pHdl->h) {
            h = pHdl->h;
#ifdef UNDER_CE
            if (hProc == NULL) {
                if (hProc = GetCurrentProcess()) {
                    BOOL f = SetHandleOwner(h, hProc);
                    DEBUGMSG(ZONE_INIT,(DBGTEXT("FSDMGR!AllocFSDHandle: hProc switched to 0x%08x (%d)\n"), hProc, f));
                }
            }
#endif
            pHdl->hProc = hProc;
        }
        else
            DeallocFSDHandle(pHdl);

        UnlockFSDMgr();
    }
    else
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FSDMGR!AllocFSDHandle: out of memory!\n")));

    return h;
}


/*  DeallocFSDHandle - Deallocate HDL structure
 *
 *  ENTRY
 *      pHdl -> HDL structure
 *
 *  EXIT
 *      None
 */

void DeallocFSDHandle(PHDL pHdl)
{
    LockFSDMgr();

    PREFAST_ASSERT(VALIDSIG(pHdl, (pHdl->dwFlags & (HDL_FILE | HDL_PSUEDO))? HFILE_SIG : HSEARCH_SIG));

    RemoveListItem((PDLINK)&pHdl->dlHdl);
    UnlockFSDMgr();

    LocalFree((HLOCAL)pHdl);
}



PDSK HookFilters(PDSK pDsk, PFSD pFSD)
{
    extern const TCHAR *g_szSTORAGE_PATH;
    extern const TCHAR *g_szFILE_SYSTEM_MODULE_STRING;
    WCHAR szRegKey[MAX_PATH];
    FSDLOADLIST *pFSDLoadList=NULL;
    HKEY hKey = NULL;
    // Filter search path is the following
    // 1) System\Storage Manager\AutoLoad\FileSystem\Filters 
    //              or
    //    System\Storage Manager\Profiles\ProfileName\FileSystem\Filters
    // 2) System\Storage Manager\FileSystem\Filters
    // 3) System\Storage Manager\Filters
    wsprintf( szRegKey, L"%s\\%s\\Filters", pFSD->szRegKey, pFSD->szFileSysName);
    if (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey)) {
        pFSDLoadList = LoadFSDList( hKey, LOAD_FLAG_SYNC | LOAD_FLAG_ASYNC, szRegKey, pFSDLoadList, TRUE /* Reverse Order */);
        FsdRegCloseKey(hKey);
    }   
    wsprintf( szRegKey, L"%s\\%s\\Filters", g_szSTORAGE_PATH, pFSD->szFileSysName);
    if (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey)) {
        pFSDLoadList = LoadFSDList( hKey, LOAD_FLAG_SYNC | LOAD_FLAG_ASYNC, szRegKey, pFSDLoadList, TRUE /* Reverse Order */);
        FsdRegCloseKey(hKey);
    }
    wsprintf( szRegKey, L"%s\\Filters", g_szSTORAGE_PATH);
    if (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey)) {
        pFSDLoadList = LoadFSDList( hKey, LOAD_FLAG_SYNC | LOAD_FLAG_ASYNC, szRegKey, pFSDLoadList, TRUE /* Reverse Order */);
        FsdRegCloseKey(hKey);
    }
    if (pFSDLoadList) {
        PFSDLOADLIST pTemp = NULL;
        while(pFSDLoadList) {
            HKEY hKeyFilter;
            TCHAR szDllName[MAX_PATH];
            PDSK pDskNew;
            HANDLE hFilter;
            // TODO: If we fail the load what happens ?
            if (ERROR_SUCCESS == FsdRegOpenKey( pFSDLoadList->szPath, &hKeyFilter)) {
                if (FsdGetRegistryString(hKeyFilter, g_szFILE_SYSTEM_MODULE_STRING, szDllName, sizeof(szDllName)/sizeof(WCHAR))) {
                    hFilter = LoadLibrary( szDllName);
                    if (hFilter) {
                        // TODO: In the process of hooking if any of the API's point to a stub then we should bypass ?
                        FSDINITDATA fid;
                        fid.dwFlags = pDsk->dwFlags;
                        fid.hDsk = pDsk->hDsk;
                        fid.hActivityEvent = pDsk->hActivityEvent;
                        fid.hFSD = hFilter;
                        fid.pIoControl = pDsk->pDeviceIoControl;
                        fid.pNextDisk = NULL;
                        fid.pStore = pDsk->pStore;
                        fid.pPartition = pDsk->pPartition;
                        wcscpy( fid.szDiskName, L"Filter");
                        wcsncpy( fid.szFileSysName, pFSDLoadList->szName, 31); // FILESYSNAMESIZE = 32
                        fid.szFileSysName[31] = 0;
                        wcscpy( fid.szRegKey, szRegKey);
                        fid.pNextDisk = pDsk;
                        pDskNew = FSDLoad( &fid);
                        pDsk->pPrevDisk = pDskNew;
                        pDsk = pDskNew;
                    }
                }
                FsdRegCloseKey( hKeyFilter);
            }
            pTemp = pFSDLoadList;
            pFSDLoadList = pFSDLoadList->pNext;
            delete pTemp;
        }
    }
    return pDsk;
}


PFSDLOADLIST LoadFSDList( HKEY hKey, DWORD dwFlags, TCHAR *szPath, PFSDLOADLIST pExisting, BOOL bReverse)
{
    extern const TCHAR *g_szFSD_ORDER_STRING;
    extern const TCHAR *g_szFSD_LOADFLAG_STRING;
    TCHAR szRegKey[MAX_PATH];
    DWORD cbSize = MAX_PATH;
    DWORD dwIndex = 0;
    DWORD dwItemFlag = 0;
    PFSDLOADLIST pFSDLoadList = pExisting;
    while(ERROR_SUCCESS == FsdRegEnumKey( hKey, dwIndex, szRegKey, &cbSize)) {
        HKEY hKeyFS;
        if (ERROR_SUCCESS == FsdRegOpenSubKey( hKey, szRegKey, &hKeyFS)) {
            DWORD dwOrder;
            if (!FsdGetRegistryValue( hKeyFS, g_szFSD_ORDER_STRING, &dwOrder)) {
                dwOrder = 0xffffffff;
            }   
            FsdGetRegistryValue( hKeyFS, g_szFSD_LOADFLAG_STRING, &dwItemFlag);
            if (!(dwItemFlag & LOAD_FLAG_ASYNC) && !(dwItemFlag & LOAD_FLAG_SYNC)) {
                dwItemFlag |= LOAD_FLAG_ASYNC;
            }   
            if (dwItemFlag & dwFlags) {
                PFSDLOADLIST pTemp = pFSDLoadList;
                PFSDLOADLIST pPrev = NULL;
                while(pTemp) {
                    if (bReverse) {
                        if (pTemp->dwOrder < dwOrder) {
                            break;
                        }
                    } else {    
                        if (pTemp->dwOrder > dwOrder) {
                            break;
                        }   
                    }   
                    pPrev = pTemp;                  
                    pTemp = pTemp->pNext;
                }
                pTemp = new FSDLOADLIST;
                if (pTemp) {
                    if (szPath) {
                        wcscpy( pTemp->szPath, szPath);
                        wcscat( pTemp->szPath, L"\\");
                        wcscat( pTemp->szPath, szRegKey);
                    }
                    pTemp->dwOrder = dwOrder;
                    wcscpy( pTemp->szName, szRegKey);
                    if (pPrev) {
                        pTemp->pNext = pPrev->pNext;
                        pPrev->pNext = pTemp;
                    } else {
                        pTemp->pNext = pFSDLoadList;
                        pFSDLoadList = pTemp;
                    }
                }    
            }   
            FsdRegCloseKey( hKeyFS);
        }
        dwIndex++;
        cbSize = MAX_PATH;
    }
    return pFSDLoadList;
}