main.cpp

WinCE5.0部分核心源码

                FILESentry* pfe = (FILESentry*) pBuffer;
                DWORD i, j;
                
                for (i=0;i < dwNumFiles; i++) {
                    fRet = ReadAtOffset(pVolume, (PBYTE) szAscii,  MAX_PATH, &dwRead, AdjustOffset( pVolume, dwCurRegion , (DWORD) pfe[i].lpszFileName));
                    j = 0;
                    memset( szFileName, 0, MAX_PATH);
                    while( (j < MAX_PATH) && szAscii[j]) {
                        szFileName[j] = szAscii[j];
                        j++;
                    }   
                    pTemp = new BinDirList;
                    if (pTemp) {
                        pTemp->dwRegion = dwCurRegion;
                        pTemp->dwAddress = AdjustOffset( pVolume, dwCurRegion, pfe[i].ulLoadOffset);
                        pTemp->dwCompFileSize = pfe[i].nCompFileSize;
                        pTemp->dwRealFileSize = pfe[i].nRealFileSize;
                        pTemp->dwAttributes = pfe[i].dwFileAttributes | FILE_ATTRIBUTE_INROM;
                        pTemp->pe32 = NULL;
                        pTemp->po32 = NULL;
                        memcpy( &pTemp->ft, &(pfe[i].ftTime), sizeof(FILETIME)); 
                        pTemp->szFileName = new WCHAR[wcslen(szFileName)+1];
                        if (pTemp->szFileName) {
                            wcscpy( pTemp->szFileName, szFileName);
                        }
                        pTemp->pNext = NULL;
                        if (pDirectory) {
                            pDirectory->pNext = pTemp;
                        } else {
                            pVolume->pChain[dwCurRegion].pDirectory = pTemp;
                        }
                        pDirectory = pTemp;
                    }
                }
            } else {
                DEBUGMSG( ZONE_INIT, (L"BINFS: InitVolume - Couldn't locate Files data\n"));
            }
            delete [] pBuffer;
        }    
    }    
    PRINTFILELISTING( pVolume->pChain[dwCurRegion].pDirectory);
    pVolume->pChain[dwCurRegion].pDirectoryLast = pDirectory;
    return TRUE;
}

BOOL FindRegion(BinVolume *pVolume, DWORD dwHdrStart, LPDWORD pdwRegion) 
{
    DWORD dwRegion = 0;
    for (dwRegion = 0; dwRegion < pVolume->dwNumRegions; dwRegion++) {
        if ((dwHdrStart >= pVolume->pChain[dwRegion].dwAddress) && (dwHdrStart <= (pVolume->pChain[dwRegion].dwAddress + pVolume->pChain[dwRegion].dwLength))) {
            *pdwRegion = dwRegion;
            return TRUE;
        }
    }
    return FALSE;
}

BOOL InitVolume(BinVolume *pVolume)
{
    DWORD dwOffset = 0;
    DWORD dwSignature, dwHdrStart, dwRead;
    DWORD dwRomHdrOffset;
    BinDirList *pDirectory = NULL;
    DWORD dwRegion, dwCurRegion;
    ROMINFO *pInfo;
    DWORD  cbSize = sizeof(ROMINFO)+(sizeof(LARGE_INTEGER)*pVolume->dwNumRegions);
    pInfo = (ROMINFO *)new BYTE[cbSize];
    pInfo->dwSlot_0_DllBase = 0x02000000;
    pInfo->dwSlot_1_DllBase = 0x04000000;
    pInfo->nROMs = pVolume->dwNumRegions;
    LARGE_INTEGER *pHiLowPair = (LARGE_INTEGER *)(((BYTE *)pInfo)+sizeof(ROMINFO));
    if (pInfo) {
        for (dwRegion = 0; dwRegion < pVolume->dwNumRegions; dwRegion++) {
skipchain:        
            if (!ReadAtOffset(pVolume, &dwSignature, sizeof(DWORD), &dwRead, ROM_SIGNATURE_OFFSET+dwOffset)) {
                break;
            }    
            if (dwSignature != ROM_SIGNATURE) {
                DEBUGMSG( ZONE_INIT, (TEXT("BINFS: InitVolume - Signature of ROM Header does not Match- Assuming Chain Region")));
                dwOffset += g_dwChainRegionLength;
                goto skipchain;
            } 
            ReadAtOffset(pVolume, &dwHdrStart, sizeof(DWORD), &dwRead, ROM_SIGNATURE_OFFSET+sizeof(DWORD)+dwOffset);
            if (!FindRegion( pVolume, dwHdrStart, &dwCurRegion)) {
                DEBUGCHK(0);
                return FALSE;
            }
            pVolume->pChain[dwCurRegion].dwBinOffset = dwOffset;
            dwRomHdrOffset = AdjustOffset( pVolume, dwCurRegion, dwHdrStart);
            DEBUGMSG( ZONE_INIT, (TEXT("BINFS: InitVolume - RomHdr starts at %08X(%08X)\r\n"), dwHdrStart, dwRomHdrOffset));
            if (pVolume->pChain[dwCurRegion].dwType == CHAIN_TYPE_BIN) {
                if (!ReadDirEntries(pVolume, dwCurRegion, dwRomHdrOffset)) {
                    // TODO: Do we continue or do we stop ???
                    DEBUGMSG( ZONE_INIT, (L"Failed reading directory entries for phys region %ld , logical region %ld\r\n", dwRegion, dwCurRegion));
                    return FALSE;
                }    
            }
            dwOffset += pVolume->pChain[dwCurRegion].dwLength;
        }
    } else {
        return FALSE;
    }    
    DEBUGMSG( ZONE_INIT, (TEXT("BINFS: Num Regions = %ld  Slot0Base=0x%08x Slot1Base=0x%08x\r\n"), pInfo->nROMs, pInfo->dwSlot_0_DllBase, pInfo->dwSlot_1_DllBase));
    for (dwRegion = 0; dwRegion < pVolume->dwNumRegions; dwRegion++) {
        if (pVolume->pChain[dwRegion].dwSlot1DllBase < pInfo->dwSlot_1_DllBase)
            pInfo->dwSlot_1_DllBase = pVolume->pChain[dwRegion].dwSlot1DllBase;
        if (( pVolume->pChain[dwRegion].Toc.dllfirst & 0xffff0000)  <  pInfo->dwSlot_0_DllBase){
            pInfo->dwSlot_0_DllBase = pVolume->pChain[dwRegion].Toc.dllfirst & 0xffff0000;
        }
#ifdef DEBUG        
        if (dwRegion && 
            (pVolume->pChain[dwRegion].dwType == CHAIN_TYPE_BIN) && 
            (pVolume->pChain[dwRegion-1].dwType == CHAIN_TYPE_BIN)) 
        {
            if ((pVolume->pChain[dwRegion].Toc.dllfirst > pVolume->pChain[dwRegion-1].Toc.dllfirst) && 
                 (pVolume->pChain[dwRegion].Toc.dlllast < pVolume->pChain[dwRegion-1].Toc.dlllast)) {
                    // We have overlapping bin regions;
                    DEBUGMSG( 1, (L"BINFS:We have overlapping regions between region %ld and %ld...aborting\r\n",dwRegion-1, dwRegion));
                    return FALSE;
            }
            if ((pVolume->pChain[dwRegion].Toc.dlllast > pVolume->pChain[dwRegion-1].Toc.dlllast) && 
                 (pVolume->pChain[dwRegion].Toc.dllfirst < pVolume->pChain[dwRegion-1].Toc.dllfirst)) {
                    // We have overlapping bin regions;
                    DEBUGMSG( 1, (L"BINFS:We have overlapping regions between region %ld and %ld...aborting\r\n", dwRegion-1, dwRegion));
                    return FALSE;
            }
        }
#endif        
        pHiLowPair->LowPart = ((pVolume->pChain[dwRegion].Toc.dllfirst & 0xffff) << 16);
        pHiLowPair->HighPart = pVolume->pChain[dwRegion].Toc.dlllast;
        DEBUGMSG( ZONE_INIT, (TEXT("BINFS:     Region %ld: High=0x%08x  Low=0x%08x\r\n"), dwRegion, pHiLowPair->HighPart, pHiLowPair->LowPart));
        if (pVolume->pChain[dwRegion].dwType == CHAIN_TYPE_BIN) {
            if (pDirectory = (BinDirList *)pVolume->pChain[dwRegion].pDirectoryLast) {
                pDirectory->pNext = pVolume->pDirectory;
            }    
            if (pDirectory = (BinDirList *)pVolume->pChain[dwRegion].pDirectory) {
                pVolume->pDirectory = pDirectory;
            }
        }
        pHiLowPair++;
    }
    if (!KernelLibIoControl( (HANDLE)KMOD_CORE, IOCTL_KLIB_SETROMDLLBASE, pInfo, cbSize, NULL, 0, NULL)) {
        NKDbgPrintfW( L"IOCTL_KLIB_SETROMDLLBASE failed !!!");
        DEBUGCHK(0);
        return FALSE;
    }
    
    PRINTFILELISTING( pVolume->pDirectory);
    return TRUE;
}

BOOL RegisterVolume(BinVolume *pVolume)
{
    TCHAR szFolderName[MAX_PATH];    
    DWORD cbRet;
    STORAGEDEVICEINFO sdi;
    if (!FSDMGR_GetRegistryString(pVolume->hDsk, L"Folder", szFolderName, MAX_PATH)) {
        wcscpy( szFolderName, DEFAULT_VOLUME_NAME);
    }    
    if ((UserKInfo[KINX_PAGESIZE] == pVolume->diskInfo.di_bytes_per_sect)
        && FSDMGR_DiskIoControl(pVolume->hDsk, IOCTL_DISK_DEVICE_INFO, &sdi, sizeof(sdi), NULL, 0, &cbRet, NULL)) {
        // if the sector size == the page size and the block device supports XIP, support XIP modules
        if (STORAGE_DEVICE_FLAG_XIP & sdi.dwDeviceFlags) {
            pVolume->dwVolFlags |= VOL_FLAG_XIP;
        }
    }
    pVolume->hVolume = ::FSDMGR_RegisterVolume(pVolume->hDsk, szFolderName, (PVOLUME)pVolume);
    if (pVolume->hVolume)
    {
        RETAILMSG(1, (L"BINFS: RegisterVolume - Mounted volume '\\%s'\n", szFolderName));
        return TRUE;
    }
    return FALSE;
}

extern "C" BOOL FSD_MountDisk(HDSK hDsk)
{
    BinVolume *pVolume = NULL;
    DWORD dwError = ERROR_SUCCESS;
    BOOL fSuccess = FALSE;
    
    DEBUGMSG(ZONE_API, (L"BINFS: FSD_UnmountDisk\n"));

    pVolume = CreateVolume(hDsk);
    if (pVolume) {
        if (InitBinDescriptors(pVolume) && InitVolume( pVolume)) {
            fSuccess = RegisterVolume( pVolume);
        }    
    } else {
        dwError = ERROR_OUTOFMEMORY;
    }
    if (fSuccess) {
        if (pVolume)
            AddVolume( pVolume);
    } else {
        if (ERROR_SUCCESS != dwError)
            SetLastError(dwError);
        if (pVolume)
            delete pVolume;
    }    
    return fSuccess;
}


/*  FSD_UnmountDisk - Deinitialization service called by FSDMGR.DLL
 *
 *  ENTRY
 *      hdsk == FSDMGR disk handle, or NULL to deinit all
 *      frozen volumes on *any* disk that no longer has any open
 *      files or dirty buffers.
 *
 *  EXIT
 *      0 if failure, or the number of devices that were successfully
 *      unmounted.
 */

extern "C" BOOL FSD_UnmountDisk(HDSK hDsk)
{
    DWORD dwError = ERROR_SUCCESS;
    BOOL fSuccess = FALSE;
    BinVolume *pVolume = FindVolume( hDsk);
    DEBUGMSG(ZONE_API, (L"BINFS: FSD_UnmountDisk\n"));
    if (pVolume) {
        FSDMGR_DeregisterVolume(pVolume->hVolume);
        DeleteVolume( pVolume);
    }    
    if (dwError) {
        SetLastError(dwError);
    }
    return fSuccess;
}



BOOL WINAPI DllMain(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
{
    switch(dwReason) {
        case DLL_PROCESS_ATTACH: {
            DEBUGREGISTER((HINSTANCE)hInstance);
            InitializeCriticalSection(&csMain);
            break;
        }
        case DLL_PROCESS_DETACH: {
            DeleteCriticalSection(&csMain);
            break;
        }
        default:
            break;
    }
    return TRUE;
}