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
LfsLsnFinalOffset (
IN PLFCB Lfcb,
IN LSN Lsn,
IN ULONG DataLength,
OUT PLONGLONG FinalOffset
)
/*++
Routine Description:
This routine will compute the final offset of the last byte of the log
record. It does this by computing how many bytes are on the current
page and then computing how many more pages will be needed.
Arguments:
Lfcb - This is the file control block for the log file.
Lsn - This is the log record being considered.
DataLength - This is the length of the data for this log record. We will add the
header length here.
FinalOffset - Address to store the result.
Return Value:
None.
--*/
{
ULONG RemainingPageBytes;
ULONG PageOffset;
PAGED_CODE();
DebugTrace( +1, Dbg, "LfsLsnFinalOffset: Entered\n", 0 );
DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb );
DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn.LowPart );
DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn.HighPart );
DebugTrace( 0, Dbg, "DataLength -> %08lx\n", DataLength );
//
// We compute the starting log page file offset, the number of bytes
// remaining in the current log page and the position on this page
// before any data bytes.
//
LfsTruncateLsnToLogPage( Lfcb, Lsn, FinalOffset );
PageOffset = LfsLsnToPageOffset( Lfcb, Lsn );
RemainingPageBytes = (ULONG)Lfcb->LogPageSize - PageOffset;
PageOffset -= 1;
//
// Add the length of the header.
//
DataLength += Lfcb->RecordHeaderLength;
//
// If this Lsn is contained in this log page we are done.
// Otherwise we need to walk through several log pages.
//
if (DataLength > RemainingPageBytes) {
DataLength -= RemainingPageBytes;
RemainingPageBytes = (ULONG)Lfcb->LogPageDataSize;
PageOffset = (ULONG)Lfcb->LogPageDataOffset - 1;
while (TRUE) {
BOOLEAN Wrapped;
LfsNextLogPageOffset( Lfcb, *FinalOffset, FinalOffset, &Wrapped );
//
// We are done if the remaining bytes fit on this page.
//
if (DataLength <= RemainingPageBytes) {
break;
}
DataLength -= RemainingPageBytes;
}
}
//
// We add the remaining bytes to our starting position on this page
// and then add that value to the file offset of this log page.
//
*(PULONG)FinalOffset += (DataLength + PageOffset);
DebugTrace( 0, Dbg, "FinalOffset (Low) -> %08lx\n", LogPageFileOffset.LowPart );
DebugTrace( 0, Dbg, "FinalOffset (High) -> %08lx\n", LogPageFileOffset.HighPart );
DebugTrace( -1, Dbg, "LfsLsnFinalOffset: Exit\n", 0 );
return;
}
PLBCB
LfsGetLbcb (
IN PLFCB Lfcb
)
/*++
Routine Description:
This routine is called to add a Lbcb to the active queue.
Arguments:
Lfcb - This is the file control block for the log file.
Return Value:
PLBCB - Pointer to the Lbcb allocated.
--*/
{
PLBCB Lbcb = NULL;
PVOID PageHeader;
PBCB PageHeaderBcb = NULL;
BOOLEAN WrappedOrUsaError;
PAGED_CODE();
LfsDebugTrace( +1, Dbg, "LfsGetLbcb: Entered\n", 0 );
LfsDebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb );
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Pin the desired record page.
//
LfsPreparePinWriteData( Lfcb,
Lfcb->NextLogPage,
(ULONG)Lfcb->LogPageSize,
&PageHeader,
&PageHeaderBcb );
//
// Put our signature into the page so we won't fail if we
// see a previous 'BAAD' signature.
//
*((PULONG) PageHeader) = LFS_SIGNATURE_RECORD_PAGE_ULONG;
//
// Now allocate an Lbcb.
//
LfsAllocateLbcb( Lfcb, &Lbcb );
//
// If we are at the beginning of the file we test that the
// sequence number won't wrap to 0.
//
if (!FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN | LFCB_REUSE_TAIL )
&& ( Lfcb->NextLogPage == Lfcb->FirstLogPage )) {
Lfcb->SeqNumber = Lfcb->SeqNumber + 1;
//
// If the sequence number is going from 0 to 1, then
// this is the first time the log file has wrapped. We want
// to remember this because it means that we can now do
// large spiral writes.
//
if (Int64ShllMod32( Lfcb->SeqNumber, Lfcb->FileDataBits ) == 0) {
LfsDebugTrace( 0, Dbg, "Log sequence number about to wrap: Lfcb -> %08lx\n", Lfcb );
KeBugCheck( FILE_SYSTEM );
}
//
// If this number is greater or equal to the wrap sequence number in
// the Lfcb, set the wrap flag in the Lbcb.
//
if (!FlagOn( Lfcb->Flags, LFCB_LOG_WRAPPED )
&& ( Lfcb->SeqNumber >= Lfcb->SeqNumberForWrap )) {
SetFlag( Lbcb->LbcbFlags, LBCB_LOG_WRAPPED );
SetFlag( Lfcb->Flags, LFCB_LOG_WRAPPED );
}
}
//
// Now initialize the rest of the Lbcb fields.
//
Lbcb->FileOffset = Lfcb->NextLogPage;
Lbcb->SeqNumber = Lfcb->SeqNumber;
Lbcb->BufferOffset = Lfcb->LogPageDataOffset;
//
// Store the next page in the Lfcb.
//
LfsNextLogPageOffset( Lfcb,
Lfcb->NextLogPage,
&Lfcb->NextLogPage,
&WrappedOrUsaError );
Lbcb->Length = Lfcb->LogPageSize;
Lbcb->PageHeader = PageHeader;
Lbcb->LogPageBcb = PageHeaderBcb;
Lbcb->ResourceThread = ExGetCurrentResourceThread();
//
// If we are reusing a previous page then set a flag in
// the Lbcb to indicate that we should flush a copy
// first.
//
if (FlagOn( Lfcb->Flags, LFCB_REUSE_TAIL )) {
SetFlag( Lbcb->LbcbFlags, LBCB_FLUSH_COPY );
ClearFlag( Lfcb->Flags, LFCB_REUSE_TAIL );
(ULONG)Lbcb->BufferOffset = Lfcb->ReusePageOffset;
Lbcb->Flags = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Flags;
Lbcb->LastLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Copy.LastLsn;
Lbcb->LastEndLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Header.Packed.LastEndLsn;
}
//
// Put the Lbcb on the active queue
//
InsertTailList( &Lfcb->LbcbActive, &Lbcb->ActiveLinks );
SetFlag( Lbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE );
} finally {
DebugUnwind( LfsGetLbcb );
//
// If an error occurred, we need to clean up any blocks which
// have not been added to the active queue.
//
if (AbnormalTermination()) {
if (Lbcb != NULL) {
LfsDeallocateLbcb( Lfcb, Lbcb );
Lbcb = NULL;
}
//
// Unpin the system page if pinned.
//
if (PageHeaderBcb != NULL) {
CcUnpinData( PageHeaderBcb );
}
}
LfsDebugTrace( -1, Dbg, "LfsGetLbcb: Exit\n", 0 );
}
return Lbcb;
}
