📄 stream.c
字号:
if ((pstm->s_pvol->v_flags & VOLF_UPDATE_ACCESS) && !(pstm->s_flags & STF_ACCESS_TIME)) {
SYSTEMTIME stTmp;
FILETIME ftTmp1, ftTmp2;
stTmp = stLocal;
stTmp.wDayOfWeek = stTmp.wHour = stTmp.wMinute = stTmp.wSecond = stTmp.wMilliseconds = 0;
// Now that I've truncated the local system time to midnight,
// I need to switch back to non-local time to perform the
// necessary comparison.
DEBUGMSG(ZONE_STREAMS && ZONE_LOGIO,(DBGTEXT("FATFS!CommitStream: current (truncated) local system time: y=%d,m=%d,d=%d,h=%d,m=%d,s=%d\n"), stTmp.wYear, stTmp.wMonth, stTmp.wDay, stTmp.wHour, stTmp.wMinute, stTmp.wSecond));
SystemTimeToFileTime(&stTmp, &ftTmp1);
DEBUGMSG(ZONE_STREAMS && ZONE_LOGIO,(DBGTEXT("FATFS!CommitStream: current (truncated) local file time: %08x,%08x\n"), ftTmp1.dwLowDateTime, ftTmp1.dwHighDateTime));
LocalFileTimeToFileTime(&ftTmp1, &ftTmp2);
DEBUGMSG(ZONE_STREAMS && ZONE_LOGIO,(DBGTEXT("FATFS!CommitStream: current (truncated) file time: %08x,%08x\n"), ftTmp2.dwLowDateTime, ftTmp2.dwHighDateTime));
if (pstm->s_ftAccess.dwLowDateTime != ftTmp2.dwLowDateTime ||
pstm->s_ftAccess.dwHighDateTime != ftTmp2.dwHighDateTime) {
pstm->s_ftAccess = ftTmp2;
pstm->s_flags |= STF_ACCESS_TIME | STF_DIRTY_INFO;
}
}
if (pstm->s_flags & STF_DIRTY) {
PBUF pbuf;
// We don't specify a stream for FindBuffer, because we're
// not trying to find a buffer for THIS stream, but rather its
// directory's stream.
// Also note this means we need to call CommitBuffer and UnholdBuffer
// when we're done (instead of the usual ModifyStreamBuffer).
if (pstm->s_blkDir == INVALID_BLOCK) {
DEBUGMSGBREAK(TRUE,(DBGTEXT("FATFS!CommitStream: invalid blkDir!\n")));
dwError = ERROR_INVALID_BLOCK;
}
else
dwError = FindBuffer(pstm->s_pvol, pstm->s_blkDir, NULL, FALSE, &pbuf);
if (dwError == ERROR_SUCCESS) {
PDIRENTRY pde;
DWORD clusFirst;
pde = (PDIRENTRY)(pbuf->b_pdata + pstm->s_offDir);
dwError = ModifyBuffer(pbuf, pde, sizeof(DIRENTRY));
if (!dwError) {
pstm->s_attr |= ATTR_ARCHIVE;
pde->de_attr = pstm->s_attr;
pde->de_size = pstm->s_size;
clusFirst = pstm->s_clusFirst;
if (clusFirst == UNKNOWN_CLUSTER)
clusFirst = NO_CLUSTER;
SETDIRENTRYCLUSTER(pstm->s_pvol, pde, clusFirst);
if (pstm->s_flags & STF_CREATE_TIME) {
FileTimeToDOSTime(&pstm->s_ftCreate,
&pde->de_createdDate,
&pde->de_createdTime,
&pde->de_createdTimeMsec);
pstm->s_flags &= ~STF_CREATE_TIME;
}
// A dirty data stream always gets a new write time, unless
// STF_WRITE_TIME is set, in which case someone has already set a
// specific write time.
if ((pstm->s_flags & (STF_DIRTY_DATA | STF_WRITE_TIME)) == STF_DIRTY_DATA) {
// We could simply call GetSystemTimeAsFileTime,
// with s_ftWrite as the destination, but if both
// last access and last write times are being updated,
// I prefer to insure that both times are identical.
FILETIME ftTmp;
SystemTimeToFileTime(&stLocal, &ftTmp);
LocalFileTimeToFileTime(&ftTmp, &pstm->s_ftWrite);
pstm->s_flags |= STF_WRITE_TIME;
}
if (pstm->s_flags & STF_WRITE_TIME) {
FileTimeToDOSTime(&pstm->s_ftWrite,
&pde->de_date,
&pde->de_time, NULL);
pstm->s_flags &= ~STF_WRITE_TIME;
}
if (pstm->s_flags & STF_ACCESS_TIME) {
FileTimeToDOSTime(&pstm->s_ftAccess,
&pde->de_lastAccessDate, NULL, NULL);
pstm->s_flags &= ~STF_ACCESS_TIME;
}
if (fAll)
dwError = CommitBuffer(pbuf, FALSE);
}
UnholdBuffer(pbuf);
#if 0
if (!dwError)
FILESYSTEMNOTIFICATION(pstm->s_pvol, DB_CEOID_CHANGED, 0, SHCNE_UPDATEITEM, &pstm->s_sid, &pstm->s_sidParent, NULL, NULL, NULL, DBGTEXTW("CommitStream"));
#endif
// Even if the buffer couldn't be written, the dirt has still
// moved from the stream's data structure to the buffer
pstm->s_flags &= ~(STF_DIRTY | STF_DIRTY_CLUS);
}
// If there was some error getting a buffer however, note that the
// stream remains dirty.
}
}
}
else {
// CommitAndReleaseStreamBuffers would have insured the release for us,
// but since we can't do a commit, we'll have to insure the release ourselves.
ReleaseStreamBuffer(pstm, FALSE);
dwError = !(pstm->s_flags & STF_DIRTY)? ERROR_SUCCESS : ERROR_ACCESS_DENIED;
}
DEBUGMSG(ZONE_STREAMS || ZONE_ERRORS && dwError,(DBGTEXT("FATFS!CommitStream returned %d for '%.11hs'\n"), dwError, pstm->s_achOEM));
return dwError;
}
/* RewindStream
*
* ENTRY
* pstm - pointer to DSTREAM
* pos - position within DSTREAM to rewind to, or INVALID_POS to reinitialize
*
* EXIT
* None
*/
void RewindStream(PDSTREAM pstm, DWORD pos)
{
if ((pos == INVALID_POS) || (pos < pstm->s_run.r_start) ||
((pstm->s_run.r_clusNext == UNKNOWN_CLUSTER) && (pstm->s_clusFirst != UNKNOWN_CLUSTER))) {
pstm->s_run.r_start = 0;
pstm->s_run.r_end = 0;
pstm->s_run.r_clusThis = UNKNOWN_CLUSTER;
pstm->s_run.r_clusNext = pstm->s_clusFirst;
pstm->s_run.r_clusPrev = NO_CLUSTER;
}
}
/* SeekStream
*
* ENTRY
* pstm - pointer to DSTREAM
* pos - position within DSTREAM to seek to
*
* EXIT
* 0 if successful, error code if not
* (eg, ERROR_HANDLE_EOF if end of cluster chain reached)
*/
DWORD SeekStream(PDSTREAM pstm, DWORD pos)
{
DWORD dwError;
ASSERT(OWNCRITICALSECTION(&pstm->s_cs));
if ((pos == INVALID_POS) || (pos < pstm->s_run.r_start) ||
((pstm->s_run.r_clusNext == UNKNOWN_CLUSTER) && (pstm->s_clusFirst != UNKNOWN_CLUSTER))) {
RewindStream(pstm, pos);
}
// Locate the data run which contains the position requested.
do {
if (pos < pstm->s_run.r_end)
return ERROR_SUCCESS;
DEBUGMSG(ZONE_LOGIO && (pstm->s_flags & STF_DEMANDPAGED),(DBGTEXT("FATFS!SeekStream(DP): begin unpack\n")));
dwError = UnpackRun(pstm);
DEBUGMSG(ZONE_LOGIO && (pstm->s_flags & STF_DEMANDPAGED),(DBGTEXT("FATFS!SeekStream(DP): end unpack\n")));
if (dwError)
break;
} while (TRUE);
return dwError;
}
/* PositionStream - Find cluster containing (or preceding) specified position
*
* ENTRY
* pstm - pointer to DSTREAM
* pos - offset within stream to seek to
*
* EXIT
* There are three general cases that callers are concerned about:
*
* UNKNOWN_CLUSTER: the specified position does not lie
* within a cluster (ie, is beyond EOF)
*
* NO_CLUSTER: the specified position does not require a
* cluster (in other words, pos is ZERO)
*
* Valid cluster: There are two cases here: if pos is on a
* cluster boundary, we will return the cluster
* PRECEDING the one containing pos, otherwise
* we will return the cluster CONTAINING pos.
*/
DWORD PositionStream(PDSTREAM pstm, DWORD pos)
{
ASSERT(OWNCRITICALSECTION(&pstm->s_cs));
if ((pos == INVALID_POS) || (pos < pstm->s_run.r_start) ||
((pstm->s_run.r_clusNext == UNKNOWN_CLUSTER) && (pstm->s_clusFirst != UNKNOWN_CLUSTER))) {
RewindStream(pstm, pos);
}
// Locate the data run which contains the position requested.
do {
if (pos == pstm->s_run.r_start)
return pstm->s_run.r_clusPrev;
if (pos <= pstm->s_run.r_end) {
return pstm->s_run.r_clusThis +
((pos - pstm->s_run.r_start - 1) >>
(pstm->s_pvol->v_log2cblkClus + BLOCK_LOG2));
}
} while (UnpackRun(pstm) == ERROR_SUCCESS);
return UNKNOWN_CLUSTER;
}
/* ReadStream
*
* Returns a pointer (to a buffer) containing data from the requested
* stream position, and the amount of data available in the buffer. ppvEnd
* is optional as long as the caller knows that the size and alignment of
* its data is such that all the data will be buffered; directory streams
* are an example of this: as long as the caller calls ReadStream before
* examining each DIRENTRY record, the caller can be assured that the entire
* DIRENTRY is in the buffer (that would not, however, be a particularly
* efficient way to scan a directory stream. -JTP)
*
* ENTRY
* pstm - pointer to DSTREAM
* pos - position within DSTREAM to read from
* ppvStart - pointer to pointer to receive starting address of data
* ppvEnd - pointer to pointer to receive ending address of data
*
* EXIT
* 0 if successful, error code if not (eg, error reading the disk, or
* ERROR_HANDLE_EOF if the end of the stream has been reached).
*/
DWORD ReadStream(PDSTREAM pstm, DWORD pos, PVOID *ppvStart, PVOID *ppvEnd)
{
DWORD dwError;
ASSERT(OWNCRITICALSECTION(&pstm->s_cs));
dwError = SeekStream(pstm, pos);
if (!dwError)
dwError = ReadStreamBuffer(pstm, pos, 0, ppvStart, ppvEnd);
return dwError;
}
/* ReadStreamData
*
* Whereas ReadStream returns a pointer (to a buffer) and a length,
* and then the caller reads whatever data it wants up to that length,
* this function takes a memory address and a length and simply reads
* that many bytes directly into that address, avoiding the use of
* disk buffers whenever possible.
*
* Thus, unlike ReadStream, where the caller can never get more than a
* buffer's worth of data back at a time and probably needs to put a loop
* around its ReadStream call, ReadStreamData can read any amount of data
* with one call (no external loop).
*
* ENTRY
* pstm - pointer to DSTREAM
* pos - position within DSTREAM to read from
* pvData - pointer to memory to read to
* len - length of data to read
* plenRead - pointer to DWORD for length read (optional)
*
* EXIT
* 0 if successful, error code if not (eg, error reading the disk)
*
* NOTES
* To avoid using buffers
*/
DWORD ReadStreamData(PDSTREAM pstm, DWORD pos, PVOID pvData, DWORD len, PDWORD plenRead)
{
DWORD cb;
PBYTE pbStart, pbEnd;
DWORD dwError = ERROR_SUCCESS;
ASSERT(OWNCRITICALSECTION(&pstm->s_cs));
// Use cb to temporarily hold the maximum number of bytes that
// can be read, and then adjust the length of the read downward as needed.
cb = pos > pstm->s_size? 0 : pstm->s_size - pos;
if (len > cb)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -