file.c

WinCE5.0部分核心源码

    }

    if (pstm->s_pvol->v_flags & VOLF_READONLY) {
        dwError = ERROR_WRITE_PROTECT;
        goto exit;
    }

    dwError = ERROR_SUCCESS;

    EnterCriticalSection(&pstm->s_cs);
    __try {
        if (lpCreation) {
            pstm->s_ftCreate = *lpCreation;
            pstm->s_flags |= STF_CREATE_TIME | STF_DIRTY_INFO;
        }
        if (lpLastAccess) {
            pstm->s_ftAccess = *lpLastAccess;
            pstm->s_flags |= STF_ACCESS_TIME | STF_DIRTY_INFO;
        }
        if (lpLastWrite) {
            pstm->s_ftWrite = *lpLastWrite;
            pstm->s_flags |= STF_WRITE_TIME | STF_DIRTY_INFO;
        }

#ifdef WASTE_OF_TIME

        // This is a waste of time, because when the recipient of this message
        // turns around and calls FAT_OidGetInfo, it's not going to see the new
        // time anyway.  New file times don't get written to disk until a commit
        // or close, and FAT_OidGetInfo only reports file information currently
        // stored on disk.  Since we always post DB_CEOID_CHANGED when a file's
        // directory entry is updated, this DB_CEOID_CHANGED is superfluous.
        //
        // You might think that FAT_OidGetInfo should look for and extract
        // information from an open stream (if one exists), but that would be
        // inconsistent with how all other APIs have historically worked.  For
        // example, FindFirstFile always returns what's recorded in a file's
        // directory entry, regardless of what another thread or process may be
        // doing to that file at the same time. -JTP

        FILESYSTEMNOTIFICATION(pvol, DB_CEOID_CHANGED, 0, SHCNE_UPDATEITEM, &pstm->s_sid, &pstm->s_sidParent, NULL, NULL, NULL, DBGTEXTW("FAT_SetFileTime"));

#endif  // WASTE_OF_TIME

    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_INVALID_PARAMETER;
    }
    LeaveCriticalSection(&pstm->s_cs);

  exit:
    if (dwError)
        SetLastError(dwError);

    FATExit(pstm->s_pvol, LOGID_NONE);

    DEBUGMSG(ZONE_APIS || ZONE_ERRORS && dwError,(DBGTEXT("FATFS!FAT_SetFileTime returned 0x%x (%d)\r\n"), dwError == ERROR_SUCCESS, dwError));

    return dwError == ERROR_SUCCESS;
}


BOOL FAT_SetEndOfFile(PFHANDLE pfh)
{
    PDSTREAM pstm = pfh->fh_pstm;
    DWORD dwError;

    ASSERT(pstm);
    DEBUGMSG(ZONE_APIS,(DBGTEXT("FATFS!FAT_SetEndOfFile(0x%x)\r\n"), pfh));

    if (!FATEnter(pstm->s_pvol, LOGID_SETENDOFFILE))
        return FALSE;

    if (!(pfh->fh_mode & FH_MODE_WRITE) || (pfh->fh_flags & (FHF_VOLUME | FHF_UNMOUNTED))) {
        dwError = ERROR_ACCESS_DENIED;
        goto exit;
    }

    EnterCriticalSection(&pstm->s_cs);
    dwError = ResizeStream(pstm, pfh->fh_pos, RESIZESTREAM_SHRINK|RESIZESTREAM_UPDATEFAT);
    LeaveCriticalSection(&pstm->s_cs);

  exit:
    if (dwError) {
        SetLastError(dwError);
    }

    FATExit(pstm->s_pvol, LOGID_SETENDOFFILE);

    DEBUGMSG(ZONE_APIS || ZONE_ERRORS && dwError,(DBGTEXT("FATFS!FAT_SetEndOfFile returned 0x%x (%d)\r\n"), dwError == ERROR_SUCCESS, dwError));

    return dwError == ERROR_SUCCESS;
}


BOOL FAT_DeviceIoControl(
PFHANDLE pfh,
DWORD dwIoControlCode,
LPVOID lpInBuf, DWORD nInBufSize,
LPVOID lpOutBuf, DWORD nOutBufSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped)
{
    DWORD dwError = ERROR_INVALID_PARAMETER;
    PVOLUME pvol = pfh->fh_pstm->s_pvol;

    DEBUGMSG(ZONE_APIS,(DBGTEXT("FATFS!FAT_DeviceIoControl(0x%x,0x%x)\r\n"), pfh, dwIoControlCode));

    



    // FATEnterQuick();

    if (dwIoControlCode == FSCTL_COPY_EXTERNAL_START) {

        if (pfh->fh_flags & (FHF_VOLUME | FHF_UNMOUNTED)) {
            dwError = ERROR_ACCESS_DENIED;
            goto exit;
        }
        
        if (!lpInBuf || nInBufSize < sizeof(FILE_COPY_EXTERNAL)) {
            dwError = ERROR_INVALID_PARAMETER;
            goto exit;
        }
        
        dwError = CopyFileExternal (pfh->fh_pstm, (PFILE_COPY_EXTERNAL)lpInBuf, lpOutBuf,nOutBufSize);
        goto exit;
    }

    if (dwIoControlCode == FSCTL_COPY_EXTERNAL_COMPLETE) {
        return FSDMGR_DiskIoControl((HDSK)pvol->v_pdsk->d_hdsk, IOCTL_DISK_COPY_EXTERNAL_COMPLETE, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned, lpOverlapped);
    }
    
    if ((pfh->fh_flags & FHF_VOLUME) && !(pfh->fh_flags & FHF_UNMOUNTED)) {

      __try {

        *lpBytesReturned = 0;

        if ((dwIoControlCode == IOCTL_DISK_GET_DEVICE_PARAMETERS ||
             dwIoControlCode == IOCTL_DISK_GET_VOLUME_PARAMETERS) &&
            nOutBufSize >= sizeof(DEVPB)) {

            QueryVolumeParameters(pvol, (PDEVPB)lpOutBuf, dwIoControlCode == IOCTL_DISK_GET_VOLUME_PARAMETERS);

            *lpBytesReturned = sizeof(DEVPB);
            dwError = ERROR_SUCCESS;
            goto exit;
        }

        if (dwIoControlCode == IOCTL_DISK_GET_FREE_SPACE && nOutBufSize >= sizeof(FREEREQ)) {

            PFREEREQ pfr = (PFREEREQ)lpOutBuf;

            if (FAT_GetDiskFreeSpaceW(pvol,
                                     NULL,
                                     &pfr->fr_SectorsPerCluster,
                                     &pfr->fr_BytesPerSector,
                                     &pfr->fr_FreeClusters,
                                     &pfr->fr_Clusters)) {
                *lpBytesReturned = sizeof(FREEREQ);
                dwError = ERROR_SUCCESS;
            }
            goto exit;
        }


        // NOTE: Callers of IOCTL_DISK_FORMAT_VOLUME and IOCTL_DISK_SCAN_VOLUME
        // need only pass the first (flags) DWORD of the corresponding FMTVOLREQ and
        // SCANVOLREQ packets;  the flags will indicate whether or not any of the
        // additional fields that we may or may not add over time are actually present.

        if (dwIoControlCode == IOCTL_DISK_FORMAT_VOLUME) {
            if (nInBufSize < sizeof(DWORD))
                lpInBuf = NULL;
            dwError = FormatVolume(pvol, (PFMTVOLREQ)lpInBuf);
            *lpBytesReturned = 0;
            goto exit;
        }

        if (dwIoControlCode == IOCTL_DISK_SCAN_VOLUME) {
            DWORD dwScanVol = SCANVOL_QUICK;
            if (nInBufSize >= sizeof(DWORD) && lpInBuf) {
                dwScanVol = ((PSCANVOLREQ)lpInBuf)->sv_dwScanVol;
            }
            dwError = ScanVolume(pvol, dwScanVol);
            *lpBytesReturned = 0;            
            goto exit;
        }

#ifdef DEBUG
        if (dwIoControlCode == IOCTL_DISK_SET_DEBUG_ZONES && nInBufSize >= sizeof(DWORD)) {
            dpCurSettings.ulZoneMask = *(PDWORD)lpInBuf;
            dwError = ERROR_SUCCESS;
            *lpBytesReturned = 0;
            goto exit;
        }
#endif

// Last ditch attempt... if all else fails and the dwIoControlCode is
// in the valid range, pass it on to the device driver and hope for the best

        if (((dwIoControlCode >> 16) & 0xffff) != IOCTL_DISK_BASE ||
            ((dwIoControlCode >> 2) & 0xfff) < 0x080 ||
            ((dwIoControlCode >> 2) & 0xfff) >= 0x700) {
            if (!FSDMGR_DiskIoControl((HDSK)pvol->v_pdsk->d_hdsk, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned, lpOverlapped)) {
                dwError = GetLastError();
            } else {
                dwError = ERROR_SUCCESS;
            }
            goto exit;
        }

      } __except (EXCEPTION_EXECUTE_HANDLER) {
        ;
      }
    }
    
  exit:
    if (dwError)
        SetLastError(dwError);

    

    DEBUGMSG(ZONE_APIS || ZONE_ERRORS && dwError,(DBGTEXT("FATFS!FAT_DeviceIoControl returned 0x%x (%d)\r\n"), dwError == ERROR_SUCCESS, dwError));

    return dwError == ERROR_SUCCESS;
}


BOOL FAT_LockFileEx(PFHANDLE pfh, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped)
{
    PREFAST_DEBUGCHK(pfh);

    return FSDMGR_InstallFileLock(AcquireFileLockState, ReleaseFileLockState, (DWORD)pfh, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped);
}


BOOL FAT_UnlockFileEx(PFHANDLE pfh, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped)
{
    PREFAST_DEBUGCHK(pfh);

    return FSDMGR_RemoveFileLock(AcquireFileLockState, ReleaseFileLockState, (DWORD)pfh, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped);
}


BOOL AcquireFileLockState(DWORD dwPfh, PFILELOCKSTATE *ppFileLockState)
{
    PFHANDLE pfh;
    PDSTREAM pstm;
    BOOL fRet;

    pfh = (PFHANDLE)dwPfh;

    PREFAST_DEBUGCHK(pfh);
    PREFAST_DEBUGCHK(ppFileLockState);

    FATEnterQuick();

    pstm = pfh->fh_pstm;
    PREFAST_DEBUGCHK(pstm);

    if (pfh->fh_flags & (FHF_VOLUME | FHF_UNMOUNTED)) {
        fRet = FALSE;
        goto exit;
    }

    if (NULL == pstm->s_filelockstate.lpcs) {
        fRet = FALSE;
        goto exit;
    }

    // TODO: what protects pfh?

    // acquire file lock state; exit in ReleaseFileLockState
    EnterCriticalSection(pstm->s_filelockstate.lpcs);

    // fetch file position
    pstm->s_filelockstate.dwPosLow = pfh->fh_pos;
    pstm->s_filelockstate.dwPosHigh = 0;

    // fetch create access
    pstm->s_filelockstate.dwAccess = 0;
    if (pfh->fh_mode & AccessToMode(GENERIC_WRITE)) {
        pstm->s_filelockstate.dwAccess |= GENERIC_WRITE;
    }
    if (pfh->fh_mode & AccessToMode(GENERIC_READ)){
        pstm->s_filelockstate.dwAccess |= GENERIC_READ;
    }

    // fetch file lock container
    *ppFileLockState = &pstm->s_filelockstate;

    fRet = TRUE;

exit:

    FATExitQuick();

    return fRet;
}


BOOL ReleaseFileLockState(DWORD dwPfh, PFILELOCKSTATE *ppFileLockState)
{
    PFHANDLE pfh;
    PDSTREAM pstm;
    BOOL fRet;

    pfh = (PFHANDLE)dwPfh;

    PREFAST_DEBUGCHK(pfh);
    PREFAST_DEBUGCHK(ppFileLockState);

    FATEnterQuick();

    pstm = pfh->fh_pstm;
    PREFAST_DEBUGCHK(pstm);

    // if volume is unmounted, then fail
    if (pfh->fh_flags & (FHF_VOLUME | FHF_UNMOUNTED)) {
        fRet = FALSE;
        goto exit;
    }

    if (NULL == pstm->s_filelockstate.lpcs) {
        fRet = FALSE;
        goto exit;
    }

    // release file lock state; enter s_filelockstate.cs in AcquireFileLockState
    LeaveCriticalSection(pstm->s_filelockstate.lpcs);

    fRet = TRUE;

exit:

    FATExitQuick();

    return fRet;
}


DWORD CopyFileExternal(PDSTREAM pstm, PFILE_COPY_EXTERNAL pInCopyReq, LPVOID lpOutBuf, DWORD nOutBufSize)
{
    DWORD dwRuns = 0;
    PDISK_COPY_EXTERNAL pOutCopyReq;
    PSECTOR_LIST_ENTRY pEntry, pSectorList;
    PVOLUME pvol = pstm->s_pvol;
    DWORD dwSize;
    DWORD dwError = ERROR_SUCCESS;

    // Validate input parameters
    if (!pInCopyReq->pUserData && pInCopyReq->cbUserDataSize) {
        return ERROR_INVALID_PARAMETER;
    }

    FATEnterQuick();
    EnterCriticalSection(&pstm->s_cs);    
       
    // Determine the number of sector runs
    RewindStream (pstm, INVALID_POS);
    while (UnpackRun (pstm) != ERROR_HANDLE_EOF) {
        dwRuns++;    
    }

    dwSize = sizeof(DISK_COPY_EXTERNAL) + dwRuns * sizeof(SECTOR_LIST_ENTRY);
    pOutCopyReq = HeapAlloc (hHeap, 0, dwSize);
    if (!pOutCopyReq) {
        DEBUGMSG(ZONE_ERRORS,(DBGTEXT("FATFS!CopyFileExternal: Out of memory\r\n")));
        dwError = ERROR_OUTOFMEMORY;
        goto exit;
    }

    // Initialize the output copy request structure by copying the input
    pOutCopyReq->cbSize = sizeof(DISK_COPY_EXTERNAL);
    pOutCopyReq->dwDirection = pInCopyReq->dwDirection;
    pOutCopyReq->pUserData = pInCopyReq->pUserData;
    pOutCopyReq->cbUserDataSize = pInCopyReq->cbUserDataSize;
    _tcsncpy (pOutCopyReq->szCancelEventName, pInCopyReq->szCancelEventName, MAX_PATH-1);
    pOutCopyReq->szCancelEventName[MAX_PATH-1] = 0;

    pOutCopyReq->hCallerProc = GetCallerProcess();
    pOutCopyReq->cbSectorListSize = dwRuns * sizeof(SECTOR_LIST_ENTRY);

    // Set the file size.
    pOutCopyReq->ulFileSize.LowPart = pstm->s_size;
    pOutCopyReq->ulFileSize.HighPart = 0;

    // The sector list starts at the end of the structure.
    pSectorList = (PSECTOR_LIST_ENTRY)(pOutCopyReq + 1);
    pEntry = pSectorList;

    // Loop through each of the cluster runs and add each one to the sector list.
    RewindStream (pstm, INVALID_POS);
    while (UnpackRun (pstm) != ERROR_HANDLE_EOF) {        
        pEntry->dwStartSector = CLUSTERTOSECTOR(pvol, pstm->s_run.r_clusThis);
        ASSERT (pstm->s_run.r_start <= pstm->s_run.r_end);
        pEntry->dwNumSectors = (pstm->s_run.r_end - pstm->s_run.r_start + pvol->v_pdsk->d_diActive.di_bytes_per_sect - 1) / 
            pvol->v_pdsk->d_diActive.di_bytes_per_sect;
        pEntry++;
    }    

    // For a write, invalidate the cache for these sectors, since copy external will not go 
    // through the cache.  For a read, flush any dirty sectors first, so that the correct
    // data is read from disk.
    
    if (pvol->v_DataCacheId != INVALID_CACHE_ID) {
        if (pInCopyReq->dwDirection == COPY_EXTERNAL_READ) {
            FSDMGR_FlushCache (pvol->v_DataCacheId, pSectorList, dwRuns, 0);
        } else {
            FSDMGR_InvalidateCache (pvol->v_DataCacheId, pSectorList, dwRuns, 0);
        }
    }

    if (!FSDMGR_DiskIoControl((HDSK)pvol->v_pdsk->d_hdsk, IOCTL_DISK_COPY_EXTERNAL_START, (LPBYTE)pOutCopyReq, dwSize, lpOutBuf, nOutBufSize, NULL, NULL)) {
        dwError = GetLastError();
    }

exit:

    if (pOutCopyReq)
        HeapFree (hHeap, 0, (HLOCAL)pOutCopyReq);

    LeaveCriticalSection(&pstm->s_cs);    
    FATExitQuick();

    return dwError;
    
}

BOOL FAT_GetVolumeInfo(PVOLUME pvol, FSD_VOLUME_INFO *pInfo)
{
    pInfo->dwBlockSize = pvol->v_cbClus;
    if (pvol->v_flags & VOLF_READONLY)
        pInfo->dwAttributes = FSD_ATTRIBUTE_READONLY;
    pInfo->dwFlags = FSD_FLAG_LOCKFILE_SUPPORTED | FSD_FLAG_WFSC_SUPPORTED;
#ifdef TFAT    
    if (pvol->v_fTfat)
        pInfo->dwFlags |= FSD_FLAG_TRANSACTION_SAFE;
    if (pvol->v_flFATFS  & FATFS_TRANS_DATA)
        pInfo->dwFlags |= FSD_FLAG_TRANSACT_WRITES;
#endif        
    return TRUE;
}