store.cpp

WinCE5.0部分核心源码

        if (hProc == GetCurrentProcess()) {
            pStoreHandle->dwFlags |= STOREHANDLE_TYPE_INTERNAL;
        }
        pStoreHandle->hProc = hProc;
        AddHandleToList(&m_pRootHandle, pStoreHandle);
    } else {
        delete pStoreHandle;
        pStoreHandle = NULL;
    }    
    Unlock();
    if (pStoreHandle) {
        *pbHandle = CreateAPIHandle( g_hStoreApi, pStoreHandle);
        if (*pbHandle != INVALID_HANDLE_VALUE) {
            SetHandleOwner( *pbHandle, hProc);
        }
    } else {
        dwError = ERROR_FILE_NOT_FOUND;
    }    
    return dwError;    
}

DWORD CStore::MountPartition(CPartition * pPartition)
{
    HANDLE hPartition;
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (pPartition->IsPartitionMounted()){
            dwError = ERROR_ALREADY_EXISTS;
        } else {
            OpenPartition( pPartition->m_szPartitionName, &hPartition, GetCurrentProcess());
            if (pPartition->MountPartition(hPartition, m_szRootRegKey, m_szDefaultFileSystem, m_dwMountFlags, m_hActivityEvent, FALSE)) {
                m_dwMountCount++;
            } else {
                dwError = ERROR_GEN_FAILURE; 
            }
        }    
    }
    Unlock();
    return dwError;
}

DWORD CStore::UnmountPartition(CPartition * pPartition)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (!pPartition->IsPartitionMounted()){
            dwError = ERROR_FILE_NOT_FOUND;
        } else {
            if (pPartition->UnmountPartition()) {
                m_dwMountCount--;
            } else {
                dwError = ERROR_GEN_FAILURE; 
            }
        }    
    }
    Unlock();
    return dwError;
}   

DWORD CStore::RenameParttion(CPartition * pPartition, LPCTSTR szNewName)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (!pPartition->RenamePartition(szNewName)) {
            GetDriverError(&dwError);
        }    
    }
    Unlock();
    return dwError;
}   

    

DWORD CStore::SetPartitionAttributes(CPartition * pPartition, DWORD dwAttrs)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (!pPartition->SetPartitionAttributes(dwAttrs)) {
            GetDriverError(&dwError);
        }    
    }
    Unlock();
    return dwError;
}   

DWORD CStore::SetPartitionSize(CPartition *pPartition, SECTORNUM snNumSectors)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)) {
        if (!pPartition->SetPartitionSize(snNumSectors)) {
            GetDriverError(&dwError);
        } else {
            m_pPartDriver->GetStoreInfo(m_dwStoreId, &m_si);
        }
    }
    Unlock();
    return dwError;
}

DWORD CStore::GetPartitionInfo(CPartition * pPartition, PPARTINFO pInfo)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (!pPartition->GetPartitionInfo(pInfo)) {
            dwError = ERROR_BAD_ARGUMENTS;
        }    
    }
    Unlock();
    return dwError;
}   

    
DWORD CStore::FormatPartition(CPartition *pPartition, BYTE bPartType, BOOL bAuto)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (IsValidPartition(pPartition)){
        if (!pPartition->FormatPartition(bPartType, bAuto)) {
            GetDriverError( &dwError);
        }    
    }
    Unlock();
    return dwError;
}

DWORD CStore::FindFirstPartition(PPARTINFO pInfo, HANDLE * pHandle, HANDLE hProc)
{
    DWORD dwError = ERROR_SUCCESS;
    *pHandle = INVALID_HANDLE_VALUE;
    SEARCHPARTITION*pSearch = new SEARCHPARTITION;
    if (!pSearch) {
        return ERROR_OUTOFMEMORY;
    }
    Lock();
    if (m_pPartitionList) {
        pSearch->pStore = this;
        pSearch->pPartition = m_pPartitionList;
        pSearch->pPartition->GetPartitionInfo( pInfo);
        pSearch->pNext = NULL;
        pSearch->dwFlags = STOREHANDLE_TYPE_SEARCH;
        pSearch->hProc = hProc;
        pSearch->dwSig = PART_HANDLE_SIG;
        AddHandleToList(&m_pRootHandle, pSearch);
        *pHandle = CreateAPIHandle(g_hFindPartApi, pSearch);
    } else {
        delete pSearch;
        dwError = ERROR_NO_MORE_ITEMS;
    }    
    Unlock();
    return dwError;
}

DWORD CStore::FindNextPartition(PSEARCHPARTITION pSearch, PARTINFO *pInfo)
{
    DWORD dwError = ERROR_NO_MORE_ITEMS;
    Lock();
    if (IsValidPartition(pSearch->pPartition)) {
        if (pSearch->dwFlags & STOREHANDLE_TYPE_CURRENT) {
            pSearch->dwFlags &= ~STOREHANDLE_TYPE_CURRENT;
        } else {
            pSearch->pPartition= pSearch->pPartition->m_pNextPartition;
        }    
        if (pSearch->pPartition && (pSearch->pPartition != INVALID_PARTITION)) {
            pSearch->pPartition->GetPartitionInfo( pInfo);
            dwError = ERROR_SUCCESS;
        }    
    }
    Unlock();
    return dwError;
}

DWORD CStore::FindClosePartition(PSEARCHPARTITION pSearch)
{
    DWORD dwError = ERROR_SUCCESS;
    Lock();
    if (DeleteHandleFromList(&m_pRootHandle, pSearch)) {
        delete pSearch;
    } else {
        dwError = ERROR_INVALID_OPERATION;
    }   
    Unlock();
    return dwError;
}

 DWORD CStore::DeviceIoControl(CPartition *pPartition, DWORD dwIoControlCode, PVOID pInBuf, DWORD nInBufSize, PVOID pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned)
 {
    DWORD dwError = ERROR_SUCCESS;
    
    if (IsValidPartition(pPartition)) {

        dwError = pPartition->DeviceIoControl(dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned);

    } else {

        switch(dwIoControlCode) {
        case IOCTL_DISK_WRITE:
        case IOCTL_DISK_READ:
        case DISK_IOCTL_READ:
        case DISK_IOCTL_WRITE:
            if (!MapSgBuffers ((PSG_REQ)pInBuf, nInBufSize))
                return FALSE;
            break;
        case IOCTL_CDROM_READ_SG:
            if (!MapSgBuffers ((PCDROM_READ)pInBuf, nInBufSize))
                return FALSE;
            break;           
        default:
            break;
        }

        if (!InternalStoreIoControl( this, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned, NULL)) {
            GetDriverError(&dwError);
        }
    }
    return dwError;
 }

/*  direct access to i/o control for a store. intended for use by the partition driver to 
    directly access the store.
 */
 
#ifdef UNDER_CE
BOOL CStore::InternalStoreIoControl(PSTORE pStore, DWORD dwIoControlCode, LPVOID lpInBuf, DWORD nInBufSize, LPVOID lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
{   
    BOOL fRet = FALSE;
    // TODO: if pStore->m_pBlockDevice is valid, directly call function ptr
    return ::DeviceIoControl(pStore->m_hDisk, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned, lpOverlapped);
}
#endif

//
// Helper functions for CStore::DeviceIoControl
//
#ifdef UNDER_CE
BOOL CStore::MapSgBuffers(PSG_REQ pSgReq ,DWORD InBufLen)
{
    if  (pSgReq && InBufLen >= (sizeof(SG_REQ) + sizeof(SG_BUF) * (pSgReq->sr_num_sg - 1))) {
        DWORD dwIndex;
        for (dwIndex=0; dwIndex < pSgReq -> sr_num_sg; dwIndex++) {
            pSgReq->sr_sglist[dwIndex].sb_buf = 
                (PUCHAR)MapCallerPtr((LPVOID)pSgReq->sr_sglist[dwIndex].sb_buf,pSgReq->sr_sglist[dwIndex].sb_len);
        }
    }
    else // Parameter Wrong.
        return FALSE;
    
    return TRUE;
}
BOOL CStore::MapSgBuffers(PCDROM_READ pCdrom ,DWORD InBufLen)
{
    if  (pCdrom && InBufLen >= (sizeof(CDROM_READ) + sizeof(SGX_BUF) * (pCdrom->sgcount - 1))) {
        DWORD dwIndex;
        for (dwIndex=0; dwIndex < pCdrom-> sgcount; dwIndex++) {
            pCdrom->sglist[dwIndex].sb_buf = 
                (PUCHAR)MapCallerPtr((LPVOID)pCdrom->sglist[dwIndex].sb_buf,pCdrom->sglist[dwIndex].sb_len);
        }
    }
    else // Parameter Wrong.
        return FALSE;
    return TRUE;
}
#else
// NT stub
BOOL CStore::MapSgBuffers(PSG_REQ pSgReq ,DWORD InBufLen)
{
    return TRUE;
}

// NT stub
BOOL CStore::MapSgBuffers(PCDROM_READ pCdrom ,DWORD InBufLen)
{
    return TRUE;
}
#endif // UNDER_CE