fsdserv.cpp

WinCE5.0部分核心源码

                    iAFS = RegisterAFSName(wsAFS);
                    if (iAFS != INVALID_AFS && GetLastError() == 0) {
                        DEBUGMSGW(ZONE_EVENTS,(DBGTEXTW("FSDMGR_RegisterVolume: registering volume as %s\n"), wsAFS));
                        if (RegisterAFSEx(iAFS, hAFSAPI, (DWORD)pVol, AFS_VERSION, AFS_FROM_MOUNT_FLAGS(pDsk->dwFlags))) {
                            pVol->iAFS = iAFS;
                            // GetAFSName will fail if this is a hidden volume
                            GetAFSName(pVol->iAFS, wsAFS, ARRAY_SIZE(wsAFS));
                            wcsncpy( pVol->wsVol, wsAFS, 63); // Size of wsVol = 64;
                            pVol->wsVol[63] = 0;
                            LockFSDMgr();
                            pVol->hNotifyHandle = NotifyCreateVolume(wsAFS);
                            if (g_hRootNotifyHandle) {
                                NotifyPathChange(g_hRootNotifyHandle, pVol->wsVol, TRUE, FILE_ACTION_ADDED);
                            } else {
                                if (AFS_FROM_MOUNT_FLAGS(pDsk->dwFlags) & AFS_FLAG_ROOTFS) {
                                    g_hRootNotifyHandle = pVol->hNotifyHandle;
                                }
                            }    
                            UnlockFSDMgr();
                            break;
                        }
                        DEBUGMSGW(ZONE_EVENTS,(DBGTEXTW("FSDMGR_RegisterVolume: registering volume failed (%d)\n"), GetLastError()));
                        VERIFYTRUE(DeregisterAFSName(iAFS));
                    }
                } while (iSuffix++ < 9);
            }
        }

        // End of "if pVol->iAFS == INVALID_AFS".  Note, however, that pVol->iAFS may
        // *still* be INVALID_AFS if all our attempts to register a volume name were rebuffed.

        LockFSDMgr();
        
        if (pVol->iAFS == INVALID_AFS) {
            if (pVol->hNotifyHandle) {
                NotifyDeleteVolume(pVol->hNotifyHandle);
            }    
            DeallocVolume(pVol);
            pVol = NULL;
        } 

        if (pVol) {
            // add the pVol to the global list of allocated volumes        
            AddListItem((PDLINK)&dlVOLList, (PDLINK)&pVol->dlVol);
        }

        UnlockFSDMgr();
    }
   

    return pVol;
}

/*  FSDMGR_GetVolumeName - Called by an FSD to query a volume's registered name
 *
 *  ENTRY
 *      pVol -> VOL structure returned from FSDMGR_RegisterVolume
 *      pwsName -> buffer, or NULL to query size of name
 *      cchMax == max chars allowed in buffer (including terminating NULL), ignored if pwsName is NULL
 *
 *  EXIT
 *      Number of characters returned, NOT including terminating NULL, or 0 if error
 */

int FSDMGR_GetVolumeName(PVOL pVol, PWSTR pwsName, int cchMax)
{
    PREFAST_ASSERT(VALIDSIG(pVol, VOL_SIG));

    if (pVol->iAFS != INVALID_AFS) {
        return GetAFSName(pVol->iAFS, pwsName, cchMax);
    } else {
        return 0;
    }
}

/*  FSDMGR_DeregisterVolume - Called by an FSD to deregister a volume
 *
 *  ENTRY
 *      pVol -> VOL structure returned from FSDMGR_RegisterVolume
 *
 *  EXIT
 *      None
 */

void FSDMGR_DeregisterVolume(PVOL pVol)
{
    // all cleanup is done in DeinitEx
}
#endif

/*  FSDMGR_CreateFileHandle - Called by an FSD to create 'file' handles
 *
 *  ENTRY
 *      pVol -> VOL structure returned from FSDMGR_RegisterVolume
 *      hProc == originating process handle
 *      pFile == FSD-defined file-specific data for the new handle
 *
 *  EXIT
 *      A 'file' handle associated with the originating process, or INVALID_HANDLE_VALUE
 */

HANDLE FSDMGR_CreateFileHandle(PVOL pVol, HANDLE hProc, PFILE pFile)
{
    PREFAST_ASSERT(VALIDSIG(pVol, VOL_SIG));
    return pFile;
}


/*  FSDMGR_CreateSearchHandle - Called by an FSD to create 'search' (aka 'find') handles
 *
 *  ENTRY
 *      pVol -> VOL structure returned from FSDMGR_RegisterVolume
 *      hProc == originating process handle
 *      pSearch == FSD-defined search-specific data for the new handle
 *
 *  EXIT
 *      A 'search' handle associated with the originating process, or INVALID_HANDLE_VALUE
 */

HANDLE FSDMGR_CreateSearchHandle(PVOL pVol, HANDLE hProc, PSEARCH pSearch)
{
    PREFAST_ASSERT(VALIDSIG(pVol, VOL_SIG));
    return pSearch;
}

/*  FSDMGR_DiskIoControl - Called by an FSD to access DeviceIoControl functions exported by the Block Driver*/

BOOL FSDMGR_DiskIoControl(PDSK pDsk, DWORD dwIoControlCode, LPVOID lpInBuf, DWORD nInBufSize, LPVOID lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
{
    PREFAST_ASSERT(VALIDSIG(pDsk, DSK_SIG));
    BOOL f;  
    DWORD dwErr;
    extern DWORD g_dwWaitIODelay;
    
    if (pDsk->pDeviceIoControl) {
        __try {
            SetLastError(0);
            f = pDsk->pDeviceIoControl((DWORD)pDsk->hDsk, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned, lpOverlapped);
            if (!f && !(DSK_STOREHANDLE & pDsk->dwFlags)) {
                dwErr = GetLastError();
                if ((ERROR_DEVICE_REMOVED == dwErr) || 
                    (ERROR_INVALID_HANDLE_STATE == dwErr) ||
                    (ERROR_DEVICE_NOT_AVAILABLE == dwErr)) {
                    
                    // A lower level call has indicated that the device is not currently 
                    // available for i/o. If there is an unload delay specified and the 
                    // volume has not been deinitialized, sleep for the delay and then retry 
                    // the call a second time.
                    DWORD dwDelay;

                    LockFSDMgr();
                    if (g_dwWaitIODelay && pDsk->pVol && !(VOL_DEINIT & pDsk->pVol->dwFlags)) {
                        dwDelay = g_dwWaitIODelay;
                    } else {
                        dwDelay = 0;
                    }
                    UnlockFSDMgr();
                    
                    if (dwDelay) {
                        DEBUGMSG(ZONE_POWER, (TEXT("FSDMGR!FSDMGR_DiskIoControl: blocking i/o for %u ms on unavailable disk %s\r\n"), g_dwWaitIODelay, pDsk->wsDsk));
                        Sleep(dwDelay);
                        SetLastError(0);
                        if (pDsk->pDeviceIoControl) {
                            f = pDsk->pDeviceIoControl((DWORD)pDsk->hDsk, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned, lpOverlapped); 
                        } else {
                            SetLastError(ERROR_DEVICE_NOT_AVAILABLE);
                            f = FALSE;
                        }
                    }
                }
            }    
        } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
            SetLastError(ERROR_ACCESS_DENIED);
            f = FALSE;
        }
    } else {
        SetLastError(ERROR_DEVICE_NOT_AVAILABLE);
        f = FALSE;
    }
    return f;
} 


BOOL FSDMGR_GetRegistryValue(PDSK pDsk, PCTSTR szValueName, PDWORD pdwValue)
{
    extern const TCHAR *g_szSTORAGE_PATH;
    TCHAR szRegKey[MAX_PATH];
    HKEY hKey;
    BOOL bSuccess = FALSE;
    TCHAR *pszRootKey, *pszSubKey;
    PREFAST_ASSERT(VALIDSIG(pDsk, DSK_SIG));
    if ((DSK_STOREHANDLE & pDsk->dwFlags) && pDsk->pStore){
        pszSubKey = pDsk->pStore->m_szPartDriverName;
        pszRootKey = pDsk->pStore->m_szRootRegKey;
    } else { 
        PREFAST_ASSERT(pDsk->pFSD);
        pszSubKey = pDsk->pFSD->szFileSysName;
        pszRootKey = pDsk->pFSD->szRegKey;
    }
    VERIFY(SUCCEEDED(StringCchPrintf(szRegKey, MAX_PATH, L"%s\\%s", pszRootKey, pszSubKey)));
    DEBUGMSG( ZONE_HELPER, (L"FSDMGR_GetRegistryValue pDsk=%08X Trying key %s\r\n", pDsk, szRegKey));
    if (bSuccess = (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey))) {
        DUMPREGKEY(ZONE_HELPER, szRegKey, hKey);
        bSuccess = FsdGetRegistryValue(hKey, szValueName, pdwValue);
        FsdRegCloseKey( hKey);
    }    
    if (!bSuccess) {
        VERIFY(SUCCEEDED(StringCchPrintf(szRegKey, MAX_PATH, L"%s\\%s", g_szSTORAGE_PATH, pszSubKey)));
        DEBUGMSG( ZONE_HELPER, (L"FSDMGR_GetRegistryValue pDsk=%08X Trying key %s\r\n", pDsk, szRegKey));
        if (bSuccess = (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey))) {
            DUMPREGKEY(ZONE_HELPER, szRegKey, hKey);
            bSuccess = FsdGetRegistryValue(hKey, szValueName, pdwValue);
            FsdRegCloseKey( hKey);
        }    
    }
    if (!bSuccess)
        *pdwValue = 0;
    return bSuccess;
}

BOOL FSDMGR_GetRegistryString(PDSK pDsk, PCTSTR szValueName, PTSTR szValue, DWORD dwSize)
{
    extern const TCHAR *g_szSTORAGE_PATH;
    TCHAR szRegKey[MAX_PATH];
    HKEY hKey;
    BOOL bSuccess = FALSE;    
    TCHAR *pszRootKey, *pszSubKey;
    PREFAST_ASSERT(VALIDSIG(pDsk, DSK_SIG));
    if (DSK_STOREHANDLE & pDsk->dwFlags) {
        pszSubKey = pDsk->pStore->m_szPartDriverName;
        pszRootKey = pDsk->pStore->m_szRootRegKey;
    } else {
        PREFAST_ASSERT(pDsk->pFSD);
        pszSubKey = pDsk->pFSD->szFileSysName;
        pszRootKey = pDsk->pFSD->szRegKey;
    }
    VERIFY(SUCCEEDED(StringCchPrintf(szRegKey, MAX_PATH, L"%s\\%s", pszRootKey, pszSubKey)));
    DEBUGMSG( ZONE_HELPER, (L"FSDMGR_GetRegistryString pDsk=%08X Trying key %s\r\n", pDsk, szRegKey));
    if (bSuccess = (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey))) {
        DUMPREGKEY(ZONE_HELPER, szRegKey, hKey);
        bSuccess = FsdGetRegistryString(hKey, szValueName, szValue, dwSize);
        FsdRegCloseKey( hKey);
    }    
    if (!bSuccess) {
        VERIFY(SUCCEEDED(StringCchPrintf(szRegKey, MAX_PATH, L"%s\\%s", g_szSTORAGE_PATH, pszSubKey)));
        DEBUGMSG( ZONE_HELPER, (L"FSDMGR_GetRegistryString pDsk=%08X Trying key %s\r\n", pDsk, szRegKey));
        if (bSuccess = (ERROR_SUCCESS == FsdRegOpenKey( szRegKey, &hKey))) {
            DUMPREGKEY(ZONE_HELPER, szRegKey, hKey);
            bSuccess = FsdGetRegistryString(hKey, szValueName, szValue, dwSize);
            FsdRegCloseKey( hKey);
        }
    }
    if (!bSuccess) 
        VERIFY(SUCCEEDED(StringCbCopy(szValue, dwSize, L"")));
    return bSuccess;
}

BOOL FSDMGR_GetRegistryFlag(PDSK pDsk,const TCHAR *szValueName, PDWORD pdwFlag, DWORD dwSet)
{
    DWORD dwValue;
    if (FSDMGR_GetRegistryValue(pDsk, szValueName, &dwValue)){
        if (dwValue == 1) 
            *pdwFlag |= dwSet;
        else
            *pdwFlag &= ~dwSet;
        return TRUE;            
    }
    return FALSE;
}

BOOL FSDMGR_GetDiskName(PDSK pDsk, TCHAR *szDiskName)
{
    PREFAST_ASSERT(VALIDSIG(pDsk, DSK_SIG));
    VERIFY(SUCCEEDED(StringCchCopy(szDiskName, MAX_PATH, pDsk->wsDsk)));
    return (wcslen(szDiskName) != 0);
}

typedef BOOL (* PADVERTISEINTERFACE)(const GUID *devclass, LPCWSTR name, BOOL fAdd);

#ifdef UNDER_CE
BOOL    FSDMGR_AdvertiseInterface( const GUID *pGuid, LPCWSTR lpszName, BOOL fAdd)
{
    PADVERTISEINTERFACE pAdvertiseInterface = NULL;
    HMODULE hCoreDll;
    BOOL bRet = FALSE;
    
    if (IsAPIReady(SH_DEVMGR_APIS)) {
        hCoreDll = (HMODULE)LoadLibrary(L"coredll.dll");
        if (hCoreDll) { 
            pAdvertiseInterface = (PADVERTISEINTERFACE)FsdGetProcAddress( hCoreDll, L"AdvertiseInterface");
            if (pAdvertiseInterface) {
                bRet = pAdvertiseInterface( pGuid, lpszName, fAdd);
            }
            FreeLibrary( hCoreDll);
        }    
    }    
    return bRet;
}
#else
// NT stub
BOOL FSDMGR_AdvertiseInterface( const GUID *pGuid, LPCWSTR lpszName, BOOL fAdd)
{
    return TRUE;
}
#endif


DWORD FSDMGR_FormatVolume(PDSK pDsk, LPVOID pParams)
{
    HINSTANCE hUtilDll;
    TCHAR szUtilDll[MAX_PATH];
    PFN_FORMATVOLUME pfnFormatVolume = NULL;

    if (!FSDMGR_GetRegistryString(pDsk, L"Util", szUtilDll, MAX_PATH)) {
        DEBUGMSG(ZONE_ERRORS,  (L"FSDMGR_FormatVolume: No utility DLL specified in registry\r\n"));
        return ERROR_FILE_NOT_FOUND;
    }

    hUtilDll = LoadLibrary (szUtilDll);
    if (hUtilDll != NULL)
    {
        pfnFormatVolume = (PFN_FORMATVOLUME)FsdGetProcAddress(hUtilDll, TEXT("FormatVolumeEx"));
        if (!pfnFormatVolume) {
            DEBUGMSG(ZONE_ERRORS,  (L"GetProcAddress failed on FormatVolumeEx\r\n"));
            FreeLibrary(hUtilDll);       
            return ERROR_NOT_SUPPORTED;
        }
        else {
            DWORD dwError = ERROR_GEN_FAILURE;
            __try {
                dwError = pfnFormatVolume(pDsk->hPartition, pParams);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                ASSERT(0);
            }    
            FreeLibrary(hUtilDll); 
            return dwError;
        }
    }
    else {
        DEBUGMSG(ZONE_ERRORS,  (L"LoadLibrary failed on %s \r\n", szUtilDll));
        return ERROR_FILE_NOT_FOUND;
    }
    return ERROR_NOT_SUPPORTED;
}

DWORD FSDMGR_ScanVolume(PDSK pDsk, LPVOID pParams)
{
    HINSTANCE hUtilDll;
    TCHAR szUtilDll[MAX_PATH];
    PFN_SCANVOLUME pfnScanVolume = NULL;

    if (!FSDMGR_GetRegistryString(pDsk, L"Util", szUtilDll, MAX_PATH)) {
        DEBUGMSG(ZONE_ERRORS,  (L"FSDMGR_ScanVolume: No utility DLL specified in registry\r\n"));
        return ERROR_FILE_NOT_FOUND;
    }

    hUtilDll = LoadLibrary (szUtilDll);
    if (hUtilDll != NULL)
    {
        pfnScanVolume = (PFN_SCANVOLUME)FsdGetProcAddress(hUtilDll, TEXT("ScanVolumeEx"));
        if (!pfnScanVolume) {
            DEBUGMSG(ZONE_ERRORS,  (L"GetProcAddress failed on ScanVolumeEx\r\n"));
            FreeLibrary(hUtilDll);       
            return ERROR_NOT_SUPPORTED;
        }
        else {
            DWORD dwError = ERROR_GEN_FAILURE;
            __try {
                dwError = pfnScanVolume(pDsk->hPartition, pParams);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                ASSERT(0);
            }    
            FreeLibrary(hUtilDll);       
            return dwError;
        }
    }
    else {
        DEBUGMSG(ZONE_ERRORS,  (L"LoadLibrary failed on %s \r\n", szUtilDll));
        return ERROR_FILE_NOT_FOUND;
    }
    return ERROR_NOT_SUPPORTED;
}

/*  translate a disk handle to an HDSK for the partition driver.
 */

PDSK FSDMGR_DeviceHandleToHDSK(HANDLE hDevice)
{
    PDSK pDsk = NULL;
    CStore *pTempStore = g_pStoreRoot;
    if (NULL == g_pStoreRoot) {
        return NULL;
    }
    
    LockStoreMgr();

    // locate the store matching the specified handle
    while(pTempStore) {
        if (hDevice == pTempStore->m_hDisk) {
            break;
        }
        pTempStore = pTempStore->m_pNextStore;
    }
    
    if (pTempStore && NULL == pTempStore->m_pDskStore) {
        // alloc a new pseudo-store DSK for the store
        pTempStore->m_pDskStore = new DSK;
        if (pTempStore->m_pDskStore) {
            INITSIG(pTempStore->m_pDskStore, DSK_SIG);
            pTempStore->m_pDskStore->dwFlags = DSK_STOREHANDLE;
            pTempStore->m_pDskStore->pStore = pTempStore;
            pTempStore->m_pDskStore->pDeviceIoControl = (PDEVICEIOCONTROL)CStore::InternalStoreIoControl;
            pTempStore->m_pDskStore->pVol = NULL;
            pTempStore->m_pDskStore->dwFilterVol = 0;
            pTempStore->m_pDskStore->hPartition = NULL;
            pTempStore->m_pDskStore->hDsk = (HANDLE)pTempStore;
            VERIFY(SUCCEEDED(StringCchCopy(pTempStore->m_pDskStore->wsDsk, MAX_PATH, L"")));
        }
    }

    UnlockStoreMgr();

    return pTempStore ? pTempStore->m_pDskStore : NULL;
}