storemain.cpp

WinCE5.0部分核心源码

                            GetMountSettings(hKeyFS, &fid.dwFlags);
                            if (!FsdGetRegistryString(hKeyFS, g_szACTIVITY_TIMER_STRING, szActivityName, sizeof(szActivityName)/sizeof(WCHAR))) {
                                wcscpy( szActivityName, g_szDEFAULT_ACTIVITY_NAME);
                            } 
                            if (wcslen(szActivityName)) {
                                fid.hActivityEvent = CreateEvent( NULL, FALSE, FALSE, szActivityName);
                            } else {
                                fid.hActivityEvent = NULL;
                            }    
                            wcsncpy( fid.szFileSysName, pFSDLoadList->szName, FILESYSNAMESIZE-1);
                            wcscpy( fid.szRegKey, g_szAUTOLOAD_PATH);
                            wcscpy( fid.szDiskName, L"AutoLoad");
                            fid.hFSD = hFSD;
                            fid.pNextDisk = NULL;
                            fid.bFormat = FALSE;
                            InitEx( &fid);
                        }    
                    } else {
                        if (FsdGetRegistryString(hKeyFS, g_szFILE_SYSTEM_DRIVER_STRING, szFSName, sizeof(szFSName)/sizeof(WCHAR))) {
                            CStore *pStore = new CStore(pFSDLoadList->szName, BLOCK_DRIVER_GUID);
                            if (pStore) {
                                AddStore(pStore);
                                pStore->SetBlockDevice(szFSName);
                                if (ERROR_SUCCESS != pStore->MountStore(TRUE)) {
                                    DeleteStore(pStore);
                                }
                            }
                        }
                    }
                }    
                FsdRegCloseKey( hKeyFS);
            }
            pTemp = pFSDLoadList;
            pFSDLoadList = pFSDLoadList->pNext;
            delete pTemp;
        }
        FsdRegCloseKey( hKeyAutoLoad);
    }
    if ((dwCurPhase == 2) && (dwFlags & LOAD_FLAG_SYNC)) {
        SetEvent(g_hAutoLoadEvent);
    }   
}

BYTE g_pPNPBuf[sizeof(DEVDETAIL) + 200];

#define DEFAULT_TIMEOUT_RESET 5000
#define DEFAULT_WAITIO_MULTIPLIER 3

DWORD PNPThread(LPVOID lParam)
{
    DWORD dwFlags, dwSize;
//    HKEY hDevKey;
    HANDLE hReg;
    DEVDETAIL * pd = (DEVDETAIL *)g_pPNPBuf;
    GUID guid = {0};
    HANDLE pHandles[3];
    TCHAR szGuid[MAX_PATH];
    HMODULE hCoreDll;    
    DWORD dwTimeOut = INFINITE, dwTimeOutReset = DEFAULT_TIMEOUT_RESET;
    PSTOPDEVICENOT pStopDeviceNotification = NULL;
    PREQUESTDEVICENOT pRequestDeviceNotification = NULL;

    pHandles[0] = g_hPNPQueue;
    pHandles[1] = g_hPNPUpdateEvent;
    pHandles[2] = g_hAutoLoadEvent;

    HKEY hKey;
    if (ERROR_SUCCESS == FsdRegOpenKey( g_szSTORAGE_PATH, &hKey)) {
        DWORD dwPriority;
        if (!FsdGetRegistryValue(hKey, g_szReloadTimeOut, &dwTimeOutReset)) {
            dwTimeOutReset = DEFAULT_TIMEOUT_RESET;
        }
        if (!FsdGetRegistryValue( hKey, g_szWaitDelay, &g_dwWaitIODelay)) {
            g_dwWaitIODelay = dwTimeOutReset * DEFAULT_WAITIO_MULTIPLIER;
        }
        if (FsdGetRegistryValue( hKey, g_szPNPThreadPrio, &dwPriority)) {
            CeSetThreadPriority(GetCurrentThread(), dwPriority); 
        }
        FsdRegCloseKey( hKey);
    }
    DEBUGMSG( ZONE_INIT, (L"STOREMGR: Using PNP unload delay of %ld\r\n", dwTimeOutReset));

    hCoreDll = (HMODULE)LoadLibrary(L"coredll.dll");
    if (hCoreDll) {
        pRequestDeviceNotification = (PREQUESTDEVICENOT)FsdGetProcAddress( hCoreDll, L"RequestDeviceNotifications");
        pStopDeviceNotification = (PSTOPDEVICENOT)FsdGetProcAddress( hCoreDll, L"StopDeviceNotifications");
    }
    FreeLibrary( hCoreDll); // This is okay since we should already have a reference to coredll

    if (pRequestDeviceNotification) {
        DEBUGMSG( ZONE_INIT, (L"STOREMGR: PNPThread Created\r\n"));
        hReg = pRequestDeviceNotification(&BLOCK_DRIVER_GUID, g_hPNPQueue, TRUE);
    }
    
    while(TRUE) {
        DWORD dwWaitCode;
        dwWaitCode = WaitForMultipleObjects( 3, pHandles, FALSE, dwTimeOut);
        if (dwWaitCode == WAIT_TIMEOUT) {
            DEBUGMSG( ZONE_INIT, (L"STOREMGR: Scavenging stores\r\n"));
            LockStoreMgr();
            dwTimeOut = INFINITE;
            g_dwUpdateState &= ~STOREMGR_EVENT_UPDATETIMEOUT;
            UnlockStoreMgr();
            DetachStores(STORE_FLAG_DETACHED);                  
        } else {
            DWORD dwEvent = dwWaitCode - WAIT_OBJECT_0;
            switch(dwEvent) {
                case 0: {
                    if (ReadMsgQueue(g_hPNPQueue, pd, sizeof(g_pPNPBuf), &dwSize, INFINITE, &dwFlags)) {
                        FsdStringFromGuid(&pd->guidDevClass, szGuid);
                        DEBUGMSG( ZONE_INIT, (L"STOREMGR: Got a plug and play event %s Class(%s) Attached=%s!!!\r\n", pd->szName, szGuid, pd->fAttached ? L"TRUE":L"FALSE"));
                        if (memcmp( &pd->guidDevClass, &BLOCK_DRIVER_GUID, sizeof(GUID)) == 0) {
                            if (pd->fAttached) {
                                MountStore( pd->szName, pd->guidDevClass);
                            } else {
                                UnmountStore(pd->szName);
                            }    
                        }    
                    }             
                    break;
                }
                case 1: {
                    if (g_dwUpdateState & STOREMGR_EVENT_UPDATETIMEOUT) {
                        dwTimeOut = dwTimeOutReset;
                    }
                    if (g_dwUpdateState & STOREMGR_EVENT_REFRESHSTORE) {
                        LockStoreMgr();
                        BOOL fRet;
                        CStore *pStore = g_pStoreRoot;
                        TCHAR szName[MAX_PATH];
                        while(pStore) {
                            if (pStore->m_dwFlags & STORE_FLAG_REFRESHED) {
                                CStore *pStoreTemp = pStore;
                                wcscpy( szName, pStore->m_szDeviceName);
                                pStoreTemp->Lock();
                                DEBUGMSG( ZONE_INIT, (L"Refreshing store %s is happenning !!!\r\n", pStore->m_szOldDeviceName));
                                fRet = pStoreTemp->UnmountStore();
                                pStoreTemp->Unlock();
                                pStore = pStoreTemp->m_pNextStore;
                                if (fRet) {
                                    UpdateHandleFromList(g_pRootHandle, pStoreTemp, NULL);
                                    FSDMGR_AdvertiseInterface( &STORE_MOUNT_GUID, pStoreTemp->m_szDeviceName, FALSE);
                                    DeleteStore( pStoreTemp);
                                    MountStore( szName, BLOCK_DRIVER_GUID);
                                }
                            } else {
                                pStore = pStore->m_pNextStore;
                            }
                        }
                        UnlockStoreMgr();
                    }
                    break;
                }
                case 2:
                    ResetEvent( g_hAutoLoadEvent);
                    AutoLoadFileSystems( 2, LOAD_FLAG_ASYNC);
                    break;
                default:
                    break;
            }   
        }    
    }    
    // SHould never get here !!!
    if (pStopDeviceNotification)
        pStopDeviceNotification(hReg);
    return 0;
}
 
BOOL InitStorageManager(DWORD dwBootPhase)
{
    if (!g_hSTRMGRApi) {
        DWORD dwThreadId=0;
        int iAFS = INVALID_AFS;
        MSGQUEUEOPTIONS msgopts;
        DWORD dwOrder = -1;

        iAFS = RegisterAFSName(L"StoreMgr");
        if (iAFS != INVALID_AFS && GetLastError() == 0) {
            g_hSTRMGRApi = CreateAPISet("PFSD", ARRAY_SIZE(apfnSTGMGRAPIs), (const PFNVOID *)apfnSTGMGRAPIs, asigSTGMGRAPIs);
            if (!RegisterAFSEx(iAFS, g_hSTRMGRApi, (DWORD)1, AFS_VERSION, AFS_FLAG_HIDDEN)) {
                DEBUGMSGW(ZONE_INIT,(DBGTEXTW("STOREMGR: InitStoreMgr failed registering secondary volume\r\n")));
                DeregisterAFSName(iAFS);
                goto Fail;
            }
        } else {
            goto Fail;
        }
        
        g_hFindStoreApi = CreateAPISet("FSTG", ARRAY_SIZE(apfnFindStoreAPIs), (const PFNVOID * )apfnFindStoreAPIs, asigFindStoreAPIs);
        g_hFindPartApi = CreateAPISet("FPRT", ARRAY_SIZE(apfnFindPartAPIs), (const PFNVOID * )apfnFindPartAPIs, asigFindPartAPIs);
        g_hStoreApi  = CreateAPISet("STRG", ARRAY_SIZE(apfnSTGAPIs), (const PFNVOID *)apfnSTGAPIs, asigSTGAPIs);
        g_hBlockDevApi = CreateAPISet("BDEV", ARRAY_SIZE(DevFileApiMethods), (const PFNVOID *)DevFileApiMethods, DevFileApiSigs);
        g_hPNPUpdateEvent = CreateEvent( NULL, FALSE, FALSE, NULL);

        msgopts.dwSize = sizeof(MSGQUEUEOPTIONS);
        msgopts.dwFlags = 0;
        msgopts.dwMaxMessages = 0; //?
        msgopts.cbMaxMessage = sizeof(g_pPNPBuf);
        msgopts.bReadAccess = TRUE;
        
        g_hPNPQueue = CreateMsgQueue(NULL, &msgopts);
        
        if (!g_hFindPartApi || !g_hFindStoreApi || !g_hStoreApi || !g_hPNPUpdateEvent || !g_hBlockDevApi || !g_hPNPQueue)
            goto Fail;
        
        RegisterAPISet(g_hFindStoreApi, HT_FIND | REGISTER_APISET_TYPE);
        RegisterAPISet(g_hFindPartApi, HT_FIND | REGISTER_APISET_TYPE);
        RegisterAPISet(g_hStoreApi, HT_FILE | REGISTER_APISET_TYPE);
        RegisterAPISet(g_hBlockDevApi, HT_FILE | REGISTER_APISET_TYPE);

        g_hAutoLoadEvent = CreateEvent( NULL, TRUE, FALSE, NULL);
        if (!g_hAutoLoadEvent)
            goto Fail;

        InitializeCriticalSection(&g_csStoreMgr);

        if (g_hPNPThread = CreateThread( NULL, 0, PNPThread, NULL, 0, &dwThreadId)) {
        } else {
            goto Fail;
        }    
    }     

    AutoLoadFileSystems(dwBootPhase, LOAD_FLAG_SYNC);

    return TRUE;
Fail:
    return FALSE;
}

#endif

void GetMountSettings(HKEY hKey, LPDWORD pdwMountFlags)
{
    DWORD dwValue;
    if (FsdGetRegistryValue(hKey, g_szMOUNT_FLAGS_STRING, &dwValue)) {
        *pdwMountFlags = dwValue;
    }
#ifdef UNDER_CE
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTASBOOT_STRING, pdwMountFlags, AFS_FLAG_BOOTABLE);
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTASROM_STRING, pdwMountFlags, AFS_FLAG_MOUNTROM);
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTHIDDEN_STRING, pdwMountFlags, AFS_FLAG_HIDDEN);
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTASROOT_STRING, pdwMountFlags, AFS_FLAG_ROOTFS);
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTSYSTEM_STRING, pdwMountFlags, AFS_FLAG_SYSTEM);
    FsdLoadFlag(hKey, g_szMOUNT_FLAG_MOUNTPERMANENT_STRING, pdwMountFlags, AFS_FLAG_PERMANENT);
#endif    
}

// External API's
HANDLE STRMGR_CreateFileW(DWORD dwData, HANDLE hProc, PCWSTR pwsFileName, DWORD dwAccess, DWORD dwShareMode, PSECURITY_ATTRIBUTES pSecurityAttributes, DWORD dwCreate, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
    if (*pwsFileName == L'\\') 
        pwsFileName++;
    return STG_OpenStore( pwsFileName, hProc);
}

HANDLE STRMGR_FindFirstFileW(DWORD dwData, HANDLE hProc, PCWSTR pwsFileSpec, PWIN32_FIND_DATAW pfd)
{
    return STG_FindFirstStore((STOREINFO * )pfd, hProc);
}

BOOL   STRMGR_RefreshStore(DWORD dwData, PWSTR pwsFileName, PCWSTR szReserved)
{
    if (*pwsFileName == L'\\') 
        pwsFileName++;
    LockStoreMgr();
    CStore *pStore = FindStore( pwsFileName);
    if (pStore) {
        pStore->Lock();
        pStore->m_dwFlags |= STORE_FLAG_REFRESHED;
        pStore->Unlock();
        g_dwUpdateState |= STOREMGR_EVENT_REFRESHSTORE;
        SetEvent( g_hPNPUpdateEvent);
    } else {
        MountStore( pwsFileName, BLOCK_DRIVER_GUID);
    }
    UnlockStoreMgr();
    return TRUE;
}