BOOLEAN
LfsFindNextLsn (
IN PLFCB Lfcb,
IN PLFS_RECORD_HEADER RecordHeader,
OUT PLSN Lsn
)
/*++
Routine Description:
This routine takes as a starting point the log record header of an
Lsn in the log file. It searches for the next Lsn in the file and
returns that value in the 'Lsn' argument. The boolean return value
indicates whether there is another Lsn in the file.
Arguments:
Lfcb - This is the file control block for the log file.
RecordHeader - This is the log record for the Lsn starting point.
Lsn - This supplies the address to store the next Lsn, if found.
Return Value:
BOOLEAN - Indicates whether the next Lsn was found.
--*/
{
BOOLEAN FoundNextLsn;
LONGLONG LsnOffset;
LONGLONG EndOfLogRecord;
LONGLONG LogHeaderOffset;
LONGLONG SequenceNumber;
PLFS_RECORD_PAGE_HEADER LogRecordPage;
PBCB LogRecordPageBcb;
BOOLEAN UsaError;
PAGED_CODE();
DebugTrace( +1, Dbg, "LfsFindNextLsn: Entered\n", 0 );
DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb );
DebugTrace( 0, Dbg, "Record Header -> %08lx\n", RecordHeader );
LogRecordPageBcb = NULL;
FoundNextLsn = FALSE;
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Find the file offset of the log page which contains the end
// of the log record for this Lsn.
//
LsnOffset = LfsLsnToFileOffset( Lfcb, RecordHeader->ThisLsn );
LfsLsnFinalOffset( Lfcb,
RecordHeader->ThisLsn,
RecordHeader->ClientDataLength,
&EndOfLogRecord );
LfsTruncateOffsetToLogPage( Lfcb, EndOfLogRecord, &LogHeaderOffset );
//
// Remember the sequence number for this page.
//
SequenceNumber = LfsLsnToSeqNumber( Lfcb, RecordHeader->ThisLsn );
//
// Remember if we wrapped.
//
if ( EndOfLogRecord <= LsnOffset ) { //**** xxLeq( EndOfLogRecord, LsnOffset )
SequenceNumber = SequenceNumber + 1; //**** xxAdd( SequenceNumber, LfsLi1 );
}
//
// Pin the log page header for this page.
//
LfsPinOrMapData( Lfcb,
LogHeaderOffset,
(ULONG)Lfcb->LogPageSize,
FALSE,
FALSE,
FALSE,
&UsaError,
(PVOID *)&LogRecordPage,
&LogRecordPageBcb );
//
// If the Lsn we were given was not the last Lsn on this page, then
// the starting offset for the next Lsn is on a quad word boundary
// following the last file offset for the current Lsn. Otherwise
// the file offset is the start of the data on the next page.
//
if ( RecordHeader->ThisLsn.QuadPart == LogRecordPage->Copy.LastLsn.QuadPart ) { //**** xxEql( RecordHeader->ThisLsn, LogRecordPage->Copy.LastLsn )
BOOLEAN Wrapped;
LfsNextLogPageOffset( Lfcb,
LogHeaderOffset,
&LogHeaderOffset,
&Wrapped );
LsnOffset = LogHeaderOffset + Lfcb->LogPageDataOffset; //**** xxAdd( LogHeaderOffset, Lfcb->LogPageDataOffset );
//
// If we wrapped, we need to increment the sequence number.
//
if (Wrapped) {
SequenceNumber = SequenceNumber + 1; //**** xxAdd( SequenceNumber, LfsLi1 );
}
} else {
LiQuadAlign( EndOfLogRecord, &LsnOffset );
}
//
// Compute the Lsn based on the file offset and the sequence count.
//
Lsn->QuadPart = LfsFileOffsetToLsn( Lfcb, LsnOffset, SequenceNumber );
//
// If this Lsn is within the legal range for the file, we return TRUE.
// Otherwise FALSE indicates that there are no more Lsn's.
//
if (LfsIsLsnInFile( Lfcb, *Lsn )) {
FoundNextLsn = TRUE;
}
} finally {
DebugUnwind( LfsFindNextLsn );
//
// Unpin the log page header if held.
//
if (LogRecordPageBcb != NULL) {
CcUnpinData( LogRecordPageBcb );
}
DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart );
DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart );
DebugTrace( -1, Dbg, "LfsFindNextLsn: Exit -> %08x\n", FoundNextLsn );
}
return FoundNextLsn;
}
VOID
LfsSetBaseLsnPriv (
IN PLFCB Lfcb,
IN PLFS_CLIENT_RECORD ClientRecord,
IN LSN BaseLsn
)
/*++
Routine Description:
This worker routine is called internally by Lfs to modify the
oldest Lsn a client expects to need during restart. The Lfs is allowed to
reuse any part of the circular log file which logically precedes
this Lsn. A client may only specify a Lsn which follows the previous
Lsn specified by this client.
Arguments:
Lfcb - Log context block for this file.
ClientRecord - For the client whose base Lsn is being modified.
BaseLsn - This is the oldest Lsn the client may require during a
restart.
Return Value:
None.
--*/
{
PAGED_CODE();
LfsDebugTrace( +1, Dbg, "LfsSetBaseLsn: Entered\n", 0 );
LfsDebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb );
LfsDebugTrace( 0, Dbg, "Base Lsn (Low) -> %08lx\n", BaseLsn.LowPart );
LfsDebugTrace( 0, Dbg, "Base Lsn (High) -> %08lx\n", BaseLsn.HighPart );
//
// We only proceed if the client is moving forward in the file.
//
if ( BaseLsn.QuadPart > Lfcb->OldestLsn.QuadPart ) { //**** xxGtr( BaseLsn, Lfcb->OldestLsn )
if ( BaseLsn.QuadPart > ClientRecord->OldestLsn.QuadPart ) { //**** xxGtr( BaseLsn, ClientRecord->OldestLsn )
ClientRecord->OldestLsn = BaseLsn;
}
Lfcb->OldestLsn = BaseLsn;
//
// We walk through all the active clients and find the new
// oldest Lsn for the log file.
//
LfsFindOldestClientLsn( Lfcb->RestartArea,
Lfcb->ClientArray,
&Lfcb->OldestLsn );
Lfcb->OldestLsnOffset = LfsLsnToFileOffset( Lfcb, Lfcb->OldestLsn );
ClearFlag( Lfcb->Flags, LFCB_NO_OLDEST_LSN );
LfsFindCurrentAvail( Lfcb );
}
LfsDebugTrace( -1, Dbg, "LfsSetBaseLsnPriv: Exit\n", 0 );
return;
}
