|
|
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
LbcbSup.c
Abstract:
This module provides support for manipulating log buffer control blocks.
Author:
Brian Andrew [BrianAn] 20-June-1991
Revision History:
--*/
#include "lfsprocs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_LBCB_SUP)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, LfsFlushToLsnPriv)
#pragma alloc_text(PAGE, LfsGetLbcb)
#endif
extern LARGE_INTEGER LiMinus1;
VOIDLfsFlushToLsnPriv ( IN PLFCB Lfcb, IN LSN Lsn, IN BOOLEAN RestartLsn )
/*++
Routine Description:
This routine is the worker routine which performs the work of flushing a particular Lsn to disk. This routine is always called with the Lfcb acquired. This routines makes no guarantee about whether the Lfcb is acquired on exit.
Arguments:
Lfcb - This is the file control block for the log file.
Lsn - This is the Lsn to flush to disk. RestartLsn - whether this lsn is a lfs restart lsn
Return Value:
None.
--*/
{ LSN FlushedLsn; volatile LARGE_INTEGER StartTime; LFS_WAITER LfsWaiter; BOOLEAN OwnedExclusive; BOOLEAN Flush; PAGED_CODE();
DebugTrace( +1, Dbg, "LfsFlushLbcb: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lbcb -> %08lx\n", Lbcb );
KeQueryTickCount( &StartTime );
//
// Convert max lsn to the current lsn which will not change since we hold the
// lfcb at least shared at this point and writers need it exclusive
// We do not care if the log progresses beyond this point
//
if (!RestartLsn && (Lsn.QuadPart > Lfcb->RestartArea->CurrentLsn.QuadPart)) {
Lsn = Lfcb->RestartArea->CurrentLsn; }
//
// Init a wait entry - this is a lightweight operation
//
KeInitializeEvent( &LfsWaiter.Event, SynchronizationEvent, FALSE ); LfsWaiter.Lsn.QuadPart = Lsn.QuadPart;
//
// We loop here until the desired Lsn has made it to disk.
// If we are able to do the I/O, we will perform it.
//
OwnedExclusive = ExIsResourceAcquiredExclusiveLite( &Lfcb->Sync->Resource );
while (TRUE) {
Flush = FALSE;
ExAcquireFastMutexUnsafe( &Lfcb->Sync->Mutex );
if (RestartLsn) { FlushedLsn = Lfcb->LastFlushedRestartLsn; } else { FlushedLsn = Lfcb->LastFlushedLsn; }
//
// Check if we still need to flush or can immediately return
//
if (Lsn.QuadPart <= FlushedLsn.QuadPart) { ExReleaseFastMutexUnsafe( &Lfcb->Sync->Mutex ); break; }
if (Lfcb->Sync->LfsIoState == LfsNoIoInProgress) { Lfcb->Sync->LfsIoState = LfsClientThreadIo; Lfcb->LfsIoThread = ExGetCurrentResourceThread(); Flush = TRUE; } else {
PLFS_WAITER TempWaiter = (PLFS_WAITER)Lfcb->WaiterList.Flink;
//
// Insert the wait entry in the sorted list of waiters -
// find its place first
//
while ((PVOID)TempWaiter != &Lfcb->WaiterList) {
if (TempWaiter->Lsn.QuadPart > Lsn.QuadPart) { break; } TempWaiter = (PLFS_WAITER)TempWaiter->Waiters.Flink; }
InsertTailList( &TempWaiter->Waiters, &LfsWaiter.Waiters );
} ExReleaseFastMutexUnsafe( &Lfcb->Sync->Mutex );
//
//
// If we can do the Io, call down to flush the Lfcb.
//
if (Flush) { LfsFlushLfcb( Lfcb, Lsn, RestartLsn ); break; }
//
// Otherwise we release the Lfcb and immediately wait on the event.
//
InterlockedIncrement( &Lfcb->Waiters ); LfsReleaseLfcb( Lfcb );
KeWaitForSingleObject( &LfsWaiter.Event, Executive, KernelMode, FALSE, NULL );
if (OwnedExclusive) { LfsAcquireLfcbExclusive( Lfcb ); } else { LfsAcquireLfcbShared( Lfcb ); } InterlockedDecrement( &Lfcb->Waiters ); }
DebugTrace( -1, Dbg, "LfsFlushToLsnPriv: Exit\n", 0 ); return;}
PLBCBLfsGetLbcb ( 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();
DebugTrace( +1, Dbg, "LfsGetLbcb: Entered\n", 0 ); DebugTrace( 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, FlagOn( Lfcb->Flags, LFCB_REUSE_TAIL ), &PageHeader, &PageHeaderBcb );
#ifdef LFS_CLUSTER_CHECK
//
// Check the page to see if there is already data on this page with the current sequence
// number. Useful to track cases where ntfs didn't find the correct end of the log or
// where the cluster service has the volume mounted twice.
//
if (LfsTestCheckLbcb && *((PULONG) PageHeader) == LFS_SIGNATURE_RECORD_PAGE_ULONG) {
LSN LastLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Copy.LastLsn;
//
// This is not an exhaustive test but should be sufficient to catch the typical case.
//
ASSERT( FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN | LFCB_REUSE_TAIL ) || (LfsLsnToSeqNumber( Lfcb, LastLsn ) < (ULONGLONG) Lfcb->SeqNumber) || (Lfcb->NextLogPage == Lfcb->FirstLogPage) ); }#endif
//
// 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) {
DebugTrace( 0, Dbg, "Log sequence number about to wrap: Lfcb -> %08lx\n", Lfcb ); KeBugCheckEx( FILE_SYSTEM, 4, 0, 0, 0 ); }
//
// 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(); Lbcb->ResourceThread = (ERESOURCE_THREAD) ((ULONG) Lbcb->ResourceThread | 3);
//
// 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 );
//
// Now that we have succeeded, set the owner thread to Thread + 1 so the resource
// package will know not to peek in this thread. It may be deallocated before
// we release the Bcb during flush.
//
CcSetBcbOwnerPointer( Lbcb->LogPageBcb, (PVOID) Lbcb->ResourceThread );
} 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 ); } }
DebugTrace( -1, Dbg, "LfsGetLbcb: Exit\n", 0 ); }
return Lbcb;}
|
