storemain.cpp

WinCE5.0部分核心源码

    if (memcmp( &pStore1->m_di, &pStore2->m_di, sizeof(DISK_INFO)) != 0) 
        goto exit;
    if (memcmp( &pStore1->m_sdi, &pStore2->m_sdi, sizeof(STORAGEDEVICEINFO)) != 0) 
        goto exit;
    if (pStore1->m_dwPartCount != pStore2->m_dwPartCount)
        goto exit;
    bRet = TRUE;            
exit:
    return bRet;
}

BOOL   WINAPI MountStore(TCHAR *szDeviceName, GUID DeviceGuid)
{
    DWORD dwError = ERROR_SUCCESS;
    LockStoreMgr();
    CStore *pStore = FindStore( szDeviceName);
    if (!pStore || (pStore->m_dwFlags & STORE_FLAG_DETACHED)) {
        CStore *pStoreTemp = g_pStoreRoot;
        while( pStoreTemp) {
            if (pStoreTemp->m_dwFlags & STORE_FLAG_DETACHED) {
                break;
            }   
            pStoreTemp = pStoreTemp->m_pNextStore;
        }   
        pStore = new CStore(szDeviceName, DeviceGuid);
        if (!pStore) {
            UnlockStoreMgr();
            return FALSE;
        }
        // needs to be added to the list before any partition driver exports are called
        // because the partition driver may call FSDMGR_DeviceToStore to replace the
        // disk handle with a store handle
        AddStore(pStore);
        if (ERROR_SUCCESS != (dwError = pStore->MountStore(pStoreTemp ? FALSE : TRUE))) {
            DEBUGMSG( ZONE_INIT | ZONE_ERRORS, (L"STOREMGR: Store %s failed to mount initially\r\n", szDeviceName));
            DeleteStore(pStore);
            pStore = NULL;
        } else {
            if (pStoreTemp) {
                pStoreTemp = g_pStoreRoot;
                while(pStoreTemp) {
                    pStoreTemp->Lock();
                    // find an existing store object that looks like the new store object,
                    // but is not the one we just added
                    if ((pStore != pStoreTemp) && CompareStore( pStore, pStoreTemp)) {
                        CPartition *pPartition1 = pStoreTemp->m_pPartitionList;
                        CPartition *pPartition2 = pStore->m_pPartitionList;
                        while(pPartition1 && pPartition2) {
                            if (memcmp( &pPartition1->m_pi, &pPartition2->m_pi, sizeof(PD_PARTINFO)) != 0) {
                                break;
                            }
                            pPartition1 = pPartition1->m_pNextPartition;
                            pPartition2 = pPartition2->m_pNextPartition;
                        }
                        if (!pPartition1 && !pPartition2) {
                            pStoreTemp->Unlock();
                            break;
                        }   
                    }   
                    pStoreTemp->Unlock();
                    pStoreTemp = pStoreTemp->m_pNextStore;
                }
                if (pStoreTemp) {
                    // a detached storage device has been re-inserted, so we will 
                    // update the existing CStore object with handles, device name, 
                    // and partition info from the new CStore object and free the 
                    // new CStore object
                    pStoreTemp->Lock();
                    pStoreTemp->m_pPartDriver->CloseStore(pStoreTemp->m_dwStoreId);
                    CloseHandle(pStoreTemp->m_hDisk);
                    pStoreTemp->m_hDisk = pStore->m_hDisk;
                    pStoreTemp->m_dwStoreId = pStore->m_dwStoreId;

                    if (pStoreTemp->m_pDskStore) {
                        // copy the PDSK used by the partition driver from the
                        // new CStore object to the existing CStore object
                        PREFAST_DEBUGCHK(NULL != pStore->m_pDskStore);
                        delete pStoreTemp->m_pDskStore;
                        pStoreTemp->m_pDskStore = pStore->m_pDskStore;
                        pStoreTemp->m_pDskStore->hDsk = (HANDLE)pStoreTemp;
                        // NULL the PDSK in the new CStore object so it does not
                        // get cleaned up when the object is deleted
                        pStore->m_pDskStore = NULL;
                    }

                    // remove the detached flag
                    pStoreTemp->m_dwFlags &= ~STORE_FLAG_DETACHED;
                    // device name could have changed (e.g. DSK1: is now DSK2: though the
                    // physical device is the same)
                    wcscpy( pStoreTemp->m_szDeviceName, szDeviceName);
                    wcscpy( pStoreTemp->m_szOldDeviceName, L"");
                    CPartition *pPartition1 = pStoreTemp->m_pPartitionList;
                    CPartition *pPartition2 = pStore->m_pPartitionList;
                    while(pPartition1) {
                        // copy partition information
                        if (pPartition1->m_pDsk && pPartition1->m_pDsk->pVol) {
                            pPartition1->m_pDsk->pVol->dwFlags &= ~VOL_DETACHED;
                        }
                        pPartition1->m_dwPartitionId = pPartition2->m_dwPartitionId;
                        pPartition1->m_dwStoreId = pPartition2->m_dwStoreId;
                        pPartition2->m_dwPartitionId = 0;
                        pPartition1 = pPartition1->m_pNextPartition;
                        pPartition2 = pPartition2->m_pNextPartition;
                    }
                    // cleanup/free the new store object
                    pStore->m_dwStoreId = 0;
                    pStore->m_hDisk = NULL;
                    pStoreTemp->Unlock();
                    pStore->UnmountStore(TRUE);
                    DeleteStore(pStore);
                    pStore = NULL;
                } else {
                    DetachStores(STORE_FLAG_DETACHED);
                    CPartition *pPartition = pStore->m_pPartitionList;
                    while(pPartition) {
                        pStore->MountPartition(pPartition);
                        pPartition = pPartition->m_pNextPartition;
                    }
                }
            }
        }
    } else {
        DEBUGMSG( ZONE_ERRORS, (L"STOREMGR: Store %s already exists ...skipping\r\n", szDeviceName));
    }   
    UnlockStoreMgr();
    if (pStore && (dwError == ERROR_SUCCESS)) {
        FSDMGR_AdvertiseInterface( &STORE_MOUNT_GUID, pStore->m_szDeviceName, TRUE);
    }
    return TRUE;
}

void WINAPI DetachStores(DWORD dwFlags)
{
    LockStoreMgr();
    CStore *pDetachedStore;
    CStore *pStore = g_pStoreRoot;
    while( pStore) {
        if (pStore->m_dwFlags & dwFlags) {
            pDetachedStore = pStore;
            pStore = pStore->m_pNextStore;
            pDetachedStore->Lock();
            DEBUGMSG( ZONE_INIT, (L"Delayed detach of store %s is happenning !!!\r\n", pDetachedStore->m_szOldDeviceName));
            pDetachedStore->UnmountStore();
            UpdateHandleFromList(pDetachedStore->m_pRootHandle, pDetachedStore, NULL);
            pDetachedStore->Unlock();
            UpdateHandleFromList(g_pRootHandle, pDetachedStore, NULL);
            if (dwFlags & STORE_FLAG_DETACHED) 
                FSDMGR_AdvertiseInterface( &STORE_MOUNT_GUID, pDetachedStore->m_szOldDeviceName, FALSE);
            else    
                FSDMGR_AdvertiseInterface( &STORE_MOUNT_GUID, pDetachedStore->m_szDeviceName, FALSE);
            DeleteStore( pDetachedStore);
        } else {
            pStore = pStore->m_pNextStore;
        }
    }   
    UnlockStoreMgr();
}

BOOL WINAPI UnmountStore(TCHAR *szDeviceName)
{
    LockStoreMgr();
    CStore *pStore = FindStore( szDeviceName);
    UnlockStoreMgr();
    if (pStore) {
        pStore->Lock();
        pStore->m_dwFlags |= STORE_FLAG_DETACHED;
        wcscpy( pStore->m_szOldDeviceName , pStore->m_szDeviceName);
        wcscpy( pStore->m_szDeviceName, L"");
        CPartition *pPartition = pStore->m_pPartitionList;
        while(pPartition) {
            if (pPartition->m_pDsk && pPartition->m_pDsk->pVol) {
                pPartition->m_pDsk->pVol->dwFlags |= VOL_DETACHED;
            }
            pPartition = pPartition->m_pNextPartition;
        }
        pStore->Unlock();
        LockStoreMgr();
        g_dwUpdateState |= STOREMGR_EVENT_UPDATETIMEOUT;
        SetEvent( g_hPNPUpdateEvent);
        UnlockStoreMgr();
        return TRUE;
    } 
    return FALSE;
}

BOOL AddHandleToList(PSTOREHANDLE *ppRoot, PSTOREHANDLE pHandle)
{
    DEBUGMSG(ZONE_INIT, (L"AddHandleToList root=%08X pHandle=%08X\r\n", *ppRoot, pHandle));
    pHandle->pNext = *ppRoot;
    *ppRoot = pHandle;
    return TRUE;
}

BOOL DeleteHandleFromList(PSTOREHANDLE *ppRoot, PSTOREHANDLE pHandle)
{
    PSTOREHANDLE pTemp = *ppRoot;
    if (*ppRoot && pHandle) {
        if (*ppRoot == pHandle) {
            DEBUGMSG(ZONE_INIT, (L"DeleteHandleFromList deleting with root=%08X pHandle=%08X\r\n", *ppRoot, pHandle));
            *ppRoot = pHandle->pNext;
            return TRUE;
        } 
        while( pTemp) {
            if (pTemp->pNext == pHandle) {
                pTemp->pNext = pHandle->pNext;
                DEBUGMSG(ZONE_INIT, (L"DeleteHandleFromList Root=%08X pHandle=%08X <---Deleted\r\n", *ppRoot, pHandle));
                return TRUE;
            }
            DEBUGMSG(1, (L"DeleteHandleFromList pHandle=%08X\r\n", pTemp));
            pTemp = pTemp->pNext;
        }
    } 
    DEBUGMSG( ZONE_INIT, (L"DeleteHandleFromList handle not found Root=%08X pHandle=%08X\r\n", *ppRoot, pHandle));
    return FALSE;
}

BOOL UpdateHandleFromList( PSTOREHANDLE pHandle, CStore *pStore, CPartition *pPartition)
{
    while(pHandle) {
        DEBUGMSG(ZONE_INIT, (L"UpdateHandleFromList pHandle=%08X\r\n", pHandle));
        if (pHandle->pPartition == pPartition && pPartition) {
            if (pHandle->dwFlags & STOREHANDLE_TYPE_SEARCH) {
                pHandle->pPartition = pPartition->m_pNextPartition;
                pHandle->dwFlags |= STOREHANDLE_TYPE_CURRENT;
            } else {
                pHandle->pPartition = INVALID_PARTITION;
            }
        }   
        if (pHandle->pStore == pStore && pStore) {
            if (pHandle->dwFlags & STOREHANDLE_TYPE_SEARCH) {
                pHandle->pStore = pStore->m_pNextStore;
                pHandle->dwFlags |= STOREHANDLE_TYPE_CURRENT;
            } else {
                pHandle->pStore =  INVALID_STORE;
            }   
        }   
        pHandle = pHandle->pNext;
    }
    return TRUE;
}

// Device Io Control for filesystems that do not have a block driver associated with it.
BOOL DeviceIoControlStub(HANDLE hDsk, DWORD dwIoControlCode, LPVOID lpInBuf, DWORD nInBufSize, LPVOID lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
{
    SetLastError( ERROR_NOT_SUPPORTED);
    return FALSE;
}

#ifdef UNDER_CE

void AutoLoadFileSystems(DWORD dwCurPhase, DWORD dwFlags)
{
    HKEY  hKeyAutoLoad;
    DWORD dwBootPhase;
    PFSDLOADLIST pFSDLoadList = NULL, pTemp=NULL;
    TCHAR szActivityName[MAX_PATH];
    if (ERROR_SUCCESS == FsdRegOpenKey( g_szAUTOLOAD_PATH, &hKeyAutoLoad)) {
        pFSDLoadList = LoadFSDList( hKeyAutoLoad, dwFlags);
        while(pFSDLoadList) {
            HKEY hKeyFS;
            if (ERROR_SUCCESS == FsdRegOpenSubKey( hKeyAutoLoad, pFSDLoadList->szName, &hKeyFS)) {
                if (!FsdGetRegistryValue( hKeyFS, g_szFSD_BOOTPHASE_STRING, &dwBootPhase)) {
                    if (dwCurPhase != 0) {
                        dwBootPhase = dwCurPhase;
                    } else {
                        dwBootPhase = 1;
                    }   
                    RegSetValueExW( hKeyFS, g_szFSD_BOOTPHASE_STRING, 0, REG_DWORD, (LPBYTE)&dwBootPhase, sizeof(DWORD));
                }
                TCHAR szFSName[MAX_PATH];
                if (dwBootPhase == dwCurPhase) {
                    if (FsdGetRegistryString(hKeyFS, g_szFILE_SYSTEM_MODULE_STRING, szFSName, sizeof(szFSName)/sizeof(WCHAR))) {
                        HMODULE hFSD = LoadDriver( szFSName);
                        if (hFSD) {
                            FSDINITDATA fid;
                            fid.pIoControl = (PDEVICEIOCONTROL)DeviceIoControlStub;
                            fid.hDsk = NULL;
                            fid.hPartition = NULL;
                            fid.pPartition = NULL;
                            fid.pStore = NULL;
                            fid.dwFlags = 0;