lfsprocs.h File Reference

#include <ntos.h>
#include <string.h>
#include <zwapi.h>
#include <lfs.h>
#include <fsrtl.h>
#include "nodetype.h"
#include "LfsDisk.h"
#include "LfsStruc.h"
#include "LfsData.h"

Go to the source code of this file.

Defines
#define	FsRtlAllocatePool(a, b)   FsRtlAllocatePoolWithTag(a,b,' sfL')
#define	FsRtlAllocatePoolWithQuota(a, b)   FsRtlAllocatePoolWithQuotaTag(a,b,' sfL')
#define	LfsAllocatePoolNoRaise(a, b)   ExAllocatePoolWithTag((a),(b),MODULE_POOL_TAG)
#define	LfsAllocatePool(a, b)   ExAllocatePoolWithTag(((a) | POOL_RAISE_IF_ALLOCATION_FAILURE),(b),MODULE_POOL_TAG)
#define	LfsFreePool(pv)   ExFreePool(pv)
#define	LfsPreparePinWriteData(L, FO, LEN, BUF, B)
#define	LfsTruncateOffsetToLogPage(LFCB, LI, OUTLI)
#define	LfsLogPageOffset(LFCB, INT)   (INT & (LFCB)->LogPageMask)
#define	LfsFileOffsetToLsn(LFCB, FO, SN)
#define	LfsIsLsnInFile(LFCB, LSN)
#define	LfsComputeLsnFromLbcb(LFCB, LBCB)
#define	LfsTruncateLsnToLogPage(LFCB, LSN, FO)
#define	LfsLsnToFileOffset(LFCB, LSN)   /*xxShr*/( ((ULONGLONG)/*xxShl*/( (LSN).QuadPart << (LFCB)->SeqNumberBits )) >> ((LFCB)->SeqNumberBits - 3) )
#define	LfsLsnToSeqNumber(LFCB, LSN)   /*xxShr*/Int64ShrlMod32( ((ULONGLONG)(LSN).QuadPart), (LFCB)->FileDataBits )
#define	LfsLsnToPageOffset(LFCB, LSN)   LfsLogPageOffset( LFCB, (LSN).LowPart << 3 )
#define	LfsInitializeLcb(LCB, ID, MODE)
#define	LfsAllocateLch(NEW)
#define	LfsDeallocateLch(LCH)   ExFreePool( LCH )
#define	LfsAllocateRestartArea(RS, SIZE)
#define	LfsDeallocateRestartArea(RS)   ExFreePool( RS )
#define	LfsLbcbIsRestart(LBCB)   (FlagOn( (LBCB)->LbcbFlags, LBCB_RESTART_LBCB ))
#define	LfsAcquireLfsData()   ExAcquireFastMutex( &LfsData.LfsDataLock )
#define	LfsReleaseLfsData()   ExReleaseFastMutex( &LfsData.LfsDataLock )
#define	LfsAcquireBufferLock()   ExAcquireFastMutex( &LfsData.BufferLock )
#define	LfsReleaseBufferLock()   ExReleaseFastMutex( &LfsData.BufferLock )
#define	LfsWaitForBufferNotification()
#define	LfsNotifyBufferWaiters()   KeSetEvent( &LfsData.BufferNotification, 0, FALSE )
#define	LfsBlockBufferWaiters()   KeClearEvent( &LfsData.BufferNotification )
#define	LfsAcquireLfcb(LFCB)   ExAcquireResourceExclusive( &(LFCB)->Sync->Resource, TRUE )
#define	LfsReleaseLfcb(LFCB)
#define	LfsAcquireLch(LCH)   ExAcquireResourceExclusive( &(LCH)->Sync->Resource, TRUE )
#define	LfsReleaseLch(LCH)
#define	LfsValidateLch(LCH)
#define	LfsValidateClientId(LFCB, LCH)
#define	LfsVerifyClientLsnInRange(LFCB, CLIENT, LSN)
#define	LfsClientIdMatch(CLIENT_A, CLIENT_B)
#define	LfsValidateLcb(LCB, LCH)
#define	FlagOn(F, SF)
#define	BooleanFlagOn(F, SF)
#define	SetFlag(Flags, SingleFlag)
#define	ClearFlag(Flags, SingleFlag)
#define	WordAlign(Ptr)
#define	LongAlign(Ptr)
#define	QuadAlign(Ptr)
#define	LiQuadAlign(LI, OUT)
#define	Add2Ptr(PTR, INC, CAST)   ((CAST)((PUCHAR)(PTR) + (INC)))
#define	PtrOffset(BASE, OFFSET)   ((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))
#define	try_return(S)   { S; goto try_exit; }
Functions
NTSTATUS	LfsPinOrMapData (IN PLFCB Lfcb, IN LONGLONG FileOffset, IN ULONG Length, IN BOOLEAN PinData, IN BOOLEAN AllowErrors, IN BOOLEAN IgnoreUsaErrors, OUT PBOOLEAN UsaError, OUT PVOID *Buffer, OUT PBCB *Bcb)
VOID	LfsPinOrMapLogRecordHeader (IN PLFCB Lfcb, IN LSN Lsn, IN BOOLEAN PinData, IN BOOLEAN IgnoreUsaErrors, OUT PBOOLEAN UsaError, OUT PLFS_RECORD_HEADER *RecordHeader, OUT PBCB *Bcb)
VOID	LfsCopyReadLogRecord (IN PLFCB Lfcb, IN PLFS_RECORD_HEADER RecordHeader, OUT PVOID Buffer)
VOID	LfsFlushLfcb (IN PLFCB Lfcb, IN PLBCB Lbcb)
BOOLEAN	LfsReadRestart (IN PLFCB Lfcb, IN LONGLONG FileSize, IN BOOLEAN FirstRestart, OUT PLONGLONG RestartPageOffset, OUT PLFS_RESTART_PAGE_HEADER *RestartPage, OUT PBCB *RestartPageBcb, OUT PBOOLEAN ChkdskWasRun, OUT PBOOLEAN ValidPage, OUT PBOOLEAN UninitializedFile, OUT PBOOLEAN LogPacked, OUT PLSN LastLsn)
VOID	LfsFlushLbcb (IN PLFCB Lfcb, IN PLBCB Lbcb)
VOID	LfsFlushToLsnPriv (IN PLFCB Lfcb, IN LSN Lsn)
PLBCB	LfsGetLbcb (IN PLFCB Lfcb)
LONG	LfsExceptionFilter (IN PEXCEPTION_POINTERS ExceptionPointer)
VOID	LfsNextLogPageOffset (IN PLFCB Lfcb, IN LONGLONG CurrentLogPageOffset, OUT PLONGLONG NextLogPageOffset, OUT PBOOLEAN Wrapped)
PVOID	LfsAllocateSpanningBuffer (IN PLFCB Lfcb, IN ULONG Length)
VOID	LfsFreeSpanningBuffer (IN PVOID Buffer)
BOOLEAN	LfsWriteLogRecordIntoLogPage (IN PLFCB Lfcb, IN PLCH Lch, IN ULONG NumberOfWriteEntries, IN PLFS_WRITE_ENTRY WriteEntries, IN LFS_RECORD_TYPE RecordType, IN TRANSACTION_ID *TransactionId OPTIONAL, IN LSN ClientUndoNextLsn OPTIONAL, IN LSN ClientPreviousLsn OPTIONAL, IN LONG UndoRequirement, IN BOOLEAN ForceToDisk, OUT PLSN Lsn)
VOID	LfsLsnFinalOffset (IN PLFCB Lfcb, IN LSN Lsn, IN ULONG DataLength, OUT PLONGLONG FinalOffset)
BOOLEAN	LfsFindNextLsn (IN PLFCB Lfcb, IN PLFS_RECORD_HEADER RecordHeader, OUT PLSN Lsn)
VOID	LfsWriteLfsRestart (IN PLFCB Lfcb, IN ULONG ThisRestartSize, IN BOOLEAN WaitForIo)
VOID	LfsFindOldestClientLsn (IN PLFS_RESTART_AREA RestartArea, IN PLFS_CLIENT_RECORD ClientArray, OUT PLSN OldestLsn)
PLFCB	LfsAllocateLfcb ()
VOID	LfsDeallocateLfcb (IN PLFCB Lfcb, IN BOOLEAN CompleteTeardown)
VOID	LfsAllocateLbcb (IN PLFCB Lfcb, OUT PLBCB *Lbcb)
VOID	LfsDeallocateLbcb (IN PLFCB Lfcb, IN PLBCB Lbcb)
VOID	LfsAllocateLcb (IN PLFCB Lfcb, OUT PLCB *NewLcb)
VOID	LfsDeallocateLcb (IN PLFCB Lfcb, IN PLCB Lcb)
VOID	LfsCurrentAvailSpace (IN PLFCB Lfcb, OUT PLONGLONG CurrentAvailSpace, OUT PULONG CurrentPageBytes)
BOOLEAN	LfsVerifyLogSpaceAvail (IN PLFCB Lfcb, IN PLCH Lch, IN ULONG RemainingLogBytes, IN LONG UndoRequirement, IN BOOLEAN ForceToDisk)
VOID	LfsFindCurrentAvail (IN PLFCB Lfcb)

---

Define Documentation

#define Add2Ptr (  PTR, INC, CAST   )     ((CAST)((PUCHAR)(PTR) + (INC)))

Definition at line 721 of file lfsprocs.h.

#define BooleanFlagOn (  F, SF   )

Value: ( \ (BOOLEAN)(((F) & (SF)) != 0) \ ) Definition at line 658 of file lfsprocs.h.

#define ClearFlag (  Flags, SingleFlag   )

Value: { \ (Flags) &= ~(SingleFlag); \ } Definition at line 666 of file lfsprocs.h.

#define FlagOn (  F, SF   )

Value: ( \ (((F) & (SF))) \ ) Definition at line 654 of file lfsprocs.h.

#define FsRtlAllocatePool (  a, b   )     FsRtlAllocatePoolWithTag(a,b,' sfL')

Definition at line 43 of file lfsprocs.h.

#define FsRtlAllocatePoolWithQuota (  a, b   )     FsRtlAllocatePoolWithQuotaTag(a,b,' sfL')

Definition at line 44 of file lfsprocs.h.

#define LfsAcquireBufferLock (   )     ExAcquireFastMutex( &LfsData.BufferLock )

Definition at line 490 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer(), and LfsFreeSpanningBuffer().

#define LfsAcquireLch (  LCH   )     ExAcquireResourceExclusive( &(LCH)->Sync->Resource, TRUE )

Definition at line 517 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsDeleteLogHandle(), LfsFlushToLsn(), LfsForceWrite(), LfsQueryLastLsn(), LfsReadLogFileInformation(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsResetUndoTotal(), LfsSetBaseLsn(), LfsTerminateLogQuery(), LfsVerifyLogFile(), LfsWrite(), and LfsWriteRestartArea().

#define LfsAcquireLfcb (  LFCB   )     ExAcquireResourceExclusive( &(LFCB)->Sync->Resource, TRUE )

Definition at line 509 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer(), LfsCloseLogFile(), LfsFlushLbcb(), LfsFlushLfcb(), LfsInitializeLogFile(), LfsRestartLogFile(), and LfsWriteLogRecordIntoLogPage().

#define LfsAcquireLfsData (   )     ExAcquireFastMutex( &LfsData.LfsDataLock )

Definition at line 484 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsInitializeLogFile(), and LfsOpenLogFile().

#define LfsAllocateLch (  NEW   )

Value: { \ *(NEW) = FsRtlAllocatePool( PagedPool, sizeof( LCH )); \ RtlZeroMemory( (*NEW), sizeof( LCH )); \ (*(NEW))->NodeTypeCode = LFS_NTC_LCH; \ (*(NEW))->NodeByteSize = sizeof( LCH ); \ } Definition at line 428 of file lfsprocs.h. Referenced by LfsOpenLogFile().

#define LfsAllocatePool (  a, b   )     ExAllocatePoolWithTag(((a) | POOL_RAISE_IF_ALLOCATION_FAILURE),(b),MODULE_POOL_TAG)

Definition at line 47 of file lfsprocs.h.

#define LfsAllocatePoolNoRaise (  a, b   )     ExAllocatePoolWithTag((a),(b),MODULE_POOL_TAG)

Definition at line 46 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer(), and LfsInitializeLogFileService().

#define LfsAllocateRestartArea (  RS, SIZE   )

Value: *(RS) = FsRtlAllocatePool( PagedPool, (SIZE) ); \ RtlZeroMemory( *(RS), (SIZE) ) Definition at line 438 of file lfsprocs.h. Referenced by LfsInitializeLogFile(), LfsRestartLogFile(), and LfsWriteLfsRestart().

#define LfsBlockBufferWaiters (   )     KeClearEvent( &LfsData.BufferNotification )

Definition at line 506 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer().

#define LfsClientIdMatch (  CLIENT_A, CLIENT_B   )

Value: ((BOOLEAN) ((CLIENT_A)->SeqNumber == (CLIENT_B)->SeqNumber \ && (CLIENT_A)->ClientIndex == (CLIENT_B)->ClientIndex)) Definition at line 607 of file lfsprocs.h. Referenced by LfsSearchForwardByClient().

#define LfsComputeLsnFromLbcb (  LFCB, LBCB   )

Value: ( \ LfsFileOffsetToLsn( LFCB, \ (LBCB)->FileOffset + (LBCB)->BufferOffset, \ (LBCB)->SeqNumber ) \ ) Definition at line 291 of file lfsprocs.h. Referenced by LfsWriteLogRecordIntoLogPage().

#define LfsDeallocateLch (  LCH   )     ExFreePool( LCH )

Definition at line 435 of file lfsprocs.h. Referenced by LfsDeleteLogHandle(), and LfsOpenLogFile().

#define LfsDeallocateRestartArea (  RS   )     ExFreePool( RS )

Definition at line 442 of file lfsprocs.h. Referenced by LfsDeallocateLbcb(), LfsDeallocateLfcb(), LfsInitializeLogFile(), and LfsRestartLogFile().

#define LfsFileOffsetToLsn (  LFCB, FO, SN   )

Value: ( \ (((ULONGLONG)(FO)) >> 3) + Int64ShllMod32((SN), (LFCB)->FileDataBits) \ ) Definition at line 283 of file lfsprocs.h. Referenced by LfsFindNextLsn(), and LfsUpdateLfcbFromNoRestart().

#define LfsFreePool (  pv   )     ExFreePool(pv)

Definition at line 48 of file lfsprocs.h. Referenced by LfsFreeSpanningBuffer(), and LfsInitializeLogFileService().

#define LfsInitializeLcb (  LCB, ID, MODE   )

Value: (LCB)->ClientId = ID; \ (LCB)->ContextMode = MODE Definition at line 423 of file lfsprocs.h. Referenced by LfsReadLogRecord().

#define LfsIsLsnInFile (  LFCB, LSN   )

Value: (/*xxGeq*/( (LSN).QuadPart >= ((LFCB)->OldestLsn).QuadPart ) \ && /*xxLeq*/( (LSN).QuadPart <= ((LFCB)->RestartArea->CurrentLsn).QuadPart )) Definition at line 287 of file lfsprocs.h. Referenced by LfsFindNextLsn().

#define LfsLbcbIsRestart (  LBCB   )     (FlagOn( (LBCB)->LbcbFlags, LBCB_RESTART_LBCB ))

Definition at line 445 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsFindFirstIo(), LfsFlushLbcb(), and LfsFlushToLsnPriv().

#define LfsLogPageOffset (  LFCB, INT   )     (INT & (LFCB)->LogPageMask)

Definition at line 188 of file lfsprocs.h.

#define LfsLsnToFileOffset (  LFCB, LSN   )     /*xxShr*/( ((ULONGLONG)/*xxShl*/( (LSN).QuadPart << (LFCB)->SeqNumberBits )) >> ((LFCB)->SeqNumberBits - 3) )

Definition at line 302 of file lfsprocs.h. Referenced by LfsFindNextLsn(), LfsSetBaseLsnPriv(), and LfsUpdateLfcbFromRestart().

#define LfsLsnToPageOffset (  LFCB, LSN   )     LfsLogPageOffset( LFCB, (LSN).LowPart << 3 )

Definition at line 308 of file lfsprocs.h. Referenced by LfsCopyReadLogRecord(), LfsFindLogRecord(), LfsLsnFinalOffset(), and LfsPinOrMapLogRecordHeader().

#define LfsLsnToSeqNumber (  LFCB, LSN   )     /*xxShr*/Int64ShrlMod32( ((ULONGLONG)(LSN).QuadPart), (LFCB)->FileDataBits )

Definition at line 305 of file lfsprocs.h. Referenced by LfsCheckSubsequentLogPage(), LfsFindLastLsn(), LfsFindNextLsn(), LfsUpdateLfcbFromNoRestart(), and LfsUpdateLfcbFromRestart().

#define LfsNotifyBufferWaiters (   )     KeSetEvent( &LfsData.BufferNotification, 0, FALSE )

Definition at line 503 of file lfsprocs.h. Referenced by LfsFreeSpanningBuffer().

#define LfsPreparePinWriteData (  L, FO, LEN, BUF, B   )

Value: { \ LONGLONG _LocalFileOffset = (FO); \ CcPreparePinWrite( (L)->FileObject, \ (PLARGE_INTEGER)&_LocalFileOffset, \ (LEN), \ FALSE, \ TRUE, \ (B), \ (BUF) ); \ } Definition at line 80 of file lfsprocs.h. Referenced by LfsFlushLfcb(), and LfsGetLbcb().

#define LfsReleaseBufferLock (   )     ExReleaseFastMutex( &LfsData.BufferLock )

Definition at line 493 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer(), and LfsFreeSpanningBuffer().

#define LfsReleaseLch (  LCH   )

Value: if ((LCH)->Sync->Resource.OwnerThreads[0].OwnerThread == ExGetCurrentResourceThread()) { \ ExReleaseResource( &(LCH)->Sync->Resource ); \ } Definition at line 520 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsDeleteLogHandle(), LfsFlushToLsn(), LfsForceWrite(), LfsQueryLastLsn(), LfsReadLogFileInformation(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsResetUndoTotal(), LfsSetBaseLsn(), LfsTerminateLogQuery(), LfsVerifyLogFile(), LfsWrite(), and LfsWriteRestartArea().

#define LfsReleaseLfcb (  LFCB   )

Value: if ((LFCB)->Sync->Resource.OwnerThreads[0].OwnerThread == ExGetCurrentResourceThread()) {\ ExReleaseResource( &(LFCB)->Sync->Resource ); \ } Definition at line 512 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer(), LfsCloseLogFile(), LfsFlushLbcb(), LfsFlushLfcb(), LfsInitializeLogFile(), LfsOpenLogFile(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsRestartLogFile(), LfsVerifyLogFile(), and LfsWriteLogRecordIntoLogPage().

#define LfsReleaseLfsData (   )     ExReleaseFastMutex( &LfsData.LfsDataLock )

Definition at line 487 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsInitializeLogFile(), and LfsOpenLogFile().

#define LfsTruncateLsnToLogPage (  LFCB, LSN, FO   )

Value: { \ *(FO) = LfsLsnToFileOffset( LFCB, LSN ); \ *((PULONG)(FO)) &= (LFCB)->LogPageInverseMask; \ } Definition at line 297 of file lfsprocs.h. Referenced by LfsCheckSubsequentLogPage(), LfsCopyReadLogRecord(), LfsLsnFinalOffset(), and LfsPinOrMapLogRecordHeader().

#define LfsTruncateOffsetToLogPage (  LFCB, LI, OUTLI   )

Value: *(OUTLI) = LI; \ *((PULONG)(OUTLI)) &= (LFCB)->SystemPageInverseMask Definition at line 184 of file lfsprocs.h. Referenced by LfsFindCurrentAvail(), LfsFindNextLsn(), LfsNextLogPageOffset(), and LfsUpdateLfcbFromRestart().

#define LfsValidateClientId (  LFCB, LCH   )

Value: if ((LCH)->ClientId.ClientIndex >= (LFCB)->RestartArea->LogClients \ || (LCH)->ClientId.SeqNumber \ != Add2Ptr( Lfcb->ClientArray, \ (LCH)->ClientArrayByteOffset, \ PLFS_CLIENT_RECORD )->SeqNumber) { \ ExRaiseStatus( STATUS_ACCESS_DENIED ); \ } Definition at line 593 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsFlushToLsn(), LfsForceWrite(), LfsQueryLastLsn(), LfsReadLogFileInformation(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsResetUndoTotal(), LfsSetBaseLsn(), LfsTerminateLogQuery(), LfsWrite(), and LfsWriteRestartArea().

#define LfsValidateLcb (  LCB, LCH   )

Value: if (LCB == NULL \ || (LCB)->NodeTypeCode != LFS_NTC_LCB \ || !LfsClientIdMatch( &(LCB)->ClientId, &(LCH)->ClientId )) { \ ExRaiseStatus( STATUS_ACCESS_DENIED ); \ } Definition at line 611 of file lfsprocs.h. Referenced by LfsReadNextLogRecord(), and LfsTerminateLogQuery().

#define LfsValidateLch (  LCH   )

Value: if ((LCH) == NULL \ || (LCH)->NodeTypeCode != LFS_NTC_LCH \ || ((LCH)->Lfcb != NULL \ && (LCH)->Lfcb->NodeTypeCode != LFS_NTC_LFCB)) { \ \ ExRaiseStatus( STATUS_ACCESS_DENIED ); \ } Definition at line 584 of file lfsprocs.h. Referenced by LfsCloseLogFile(), LfsFlushToLsn(), LfsForceWrite(), LfsQueryLastLsn(), LfsReadLogFileInformation(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsResetUndoTotal(), LfsSetBaseLsn(), LfsTerminateLogQuery(), LfsWrite(), and LfsWriteRestartArea().

#define LfsVerifyClientLsnInRange (  LFCB, CLIENT, LSN   )

Value: (/*xxGeq*/( (LSN).QuadPart >= ((CLIENT)->OldestLsn).QuadPart ) \ && /*xxLeq*/( (LSN).QuadPart <= ((LFCB)->RestartArea->CurrentLsn).QuadPart ) \ && /*xxNeqZero*/( (LSN).QuadPart != 0 )) Definition at line 602 of file lfsprocs.h. Referenced by LfsFindClientNextLsn(), and LfsReadLogRecord().

#define LfsWaitForBufferNotification (   )

Value: KeWaitForSingleObject( &LfsData.BufferNotification, \ Executive, \ KernelMode, \ FALSE, \ NULL ) Definition at line 496 of file lfsprocs.h. Referenced by LfsAllocateSpanningBuffer().

#define LiQuadAlign (  LI, OUT   )

Value: { \ *(OUT) = /*xxAdd*/( (LI) + 7 ); \ *((PULONG)(OUT)) &= 0xfffffff8; \ } Definition at line 701 of file lfsprocs.h. Referenced by LfsFindNextLsn().

#define LongAlign (  Ptr   )

Value: ( \ ((((ULONG)(Ptr)) + 3) & 0xfffffffc) \ ) Definition at line 684 of file lfsprocs.h.

#define PtrOffset (  BASE, OFFSET   )     ((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))

Definition at line 723 of file lfsprocs.h.

#define QuadAlign (  Ptr   )

Value: ( \ ((((ULONG)(Ptr)) + 7) & 0xfffffff8) \ ) Definition at line 693 of file lfsprocs.h.

#define SetFlag (  Flags, SingleFlag   )

Value: { \ (Flags) |= (SingleFlag); \ } Definition at line 662 of file lfsprocs.h.

#define try_return (  S   )     { S; goto try_exit; }

Definition at line 754 of file lfsprocs.h.

#define WordAlign (  Ptr   )

Value: ( \ ((((ULONG)(Ptr)) + 1) & 0xfffffffe) \ ) Definition at line 675 of file lfsprocs.h.

---

Function Documentation

VOID LfsAllocateLbcb (  IN PLFCB  Lfcb, OUT PLBCB *  Lbcb )

Definition at line 315 of file lfs/strucsup.c. References ExAllocatePoolWithTag, ExRaiseStatus(), LBCB, LFCB_RESERVE_LBCB_COUNT, LFS_NTC_LBCB, _LBCB::NodeByteSize, _LBCB::NodeTypeCode, NULL, PAGED_CODE, and PagedPool. Referenced by LfsGetLbcb(), LfsUpdateLfcbFromNoRestart(), LfsUpdateLfcbFromRestart(), and LfsWriteLfsRestart(). : This routine will allocate the next Lbcb. If the pool allocation fails we will look at the private queue of Lbcb's. Arguments: Lfcb - Supplies a pointer to the log file control block. Lbcb - Address to store the allocated Lbcb. Return Value: None --*/ { PLBCB NewLbcb = NULL; PAGED_CODE(); // // If there are enough entries on the look-aside list then get one from // there. // if (Lfcb->SpareLbcbCount > LFCB_RESERVE_LBCB_COUNT) { NewLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink; Lfcb->SpareLbcbCount -= 1; RemoveHeadList( &Lfcb->SpareLbcbList ); // // Otherwise try to allocate from pool. // } else { NewLbcb = ExAllocatePoolWithTag( PagedPool, sizeof( LBCB ), ' sfL' ); } // // If we didn't get one then look at the look-aside list. // if (NewLbcb == NULL) { if (Lfcb->SpareLbcbCount != 0) { NewLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink; Lfcb->SpareLbcbCount -= 1; RemoveHeadList( &Lfcb->SpareLbcbList ); } else { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } } // // Initialize the structure. // RtlZeroMemory( NewLbcb, sizeof( LBCB )); NewLbcb->NodeTypeCode = LFS_NTC_LBCB; NewLbcb->NodeByteSize = sizeof( LBCB ); // // Return it to the user. // *Lbcb = NewLbcb; return; }

VOID LfsAllocateLcb (  IN PLFCB  Lfcb, OUT PLCB *  NewLcb )

Definition at line 463 of file lfs/strucsup.c. References ExAllocatePoolWithTag, ExRaiseStatus(), LCB, LFCB_RESERVE_LCB_COUNT, LFS_NTC_LCB, NULL, and PagedPool. Referenced by LfsReadLogRecord(). : This routine will allocate an Lcb. If the pool fails we will fall back on our spare list. A failure then will result in an exception Arguments: Lfcb - Supplies a pointer to the log file control block. Lcb - This will contain the new lcb Return Value: None --*/ { ExAcquireFastMutex( &(Lfcb->Sync->SpareListMutex) ); try { *NewLcb = NULL; if (Lfcb->SpareLcbCount < LFCB_RESERVE_LCB_COUNT) { (*NewLcb) = ExAllocatePoolWithTag( PagedPool, sizeof( LCB ), ' sfL' ); } if ((*NewLcb) == NULL) { if (Lfcb->SpareLcbCount > 0) { *NewLcb = (PLCB) Lfcb->SpareLcbList.Flink; Lfcb->SpareLcbCount -= 1; RemoveHeadList( &Lfcb->SpareLcbList ); } else { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } } RtlZeroMemory( (*NewLcb), sizeof( LCB ) ); (*NewLcb)->NodeTypeCode = LFS_NTC_LCB; (*NewLcb)->NodeByteSize = sizeof( LCB ); } finally { ExReleaseFastMutex( &(Lfcb->Sync->SpareListMutex) ); } }

PLFCB LfsAllocateLfcb (   )

Definition at line 41 of file lfs/strucsup.c. References Count, Dbg, DebugTrace, DebugUnwind, _LFCB_SYNC::Event, ExAllocatePoolWithTag, ExInitializeFastMutex, ExInitializeResource, FsRtlAllocatePool, KeInitializeEvent, _LFCB::LbcbActive, _LFCB::LbcbWorkque, _LFCB::LchLinks, LFCB, LFCB_RESERVE_LBCB_COUNT, LFCB_RESERVE_LCB_COUNT, LFS_NTC_LFCB, LfsDeallocateLfcb(), LfsLi1, _LFCB::NextRestartLsn, _LFCB::NodeByteSize, _LFCB::NodeTypeCode, NonPagedPool, NULL, PAGED_CODE, PagedPool, _LFCB_SYNC::Resource, _LFCB::SpareLbcbCount, _LFCB::SpareLbcbList, _LFCB::SpareLcbCount, _LFCB::SpareLcbList, _LFCB_SYNC::SpareListMutex, _LFCB::Sync, TRUE, and _LFCB_SYNC::UserCount. Referenced by LfsInitializeLogFile(), and LfsRestartLogFile(). : This routine allocates and initializes a log file control block. Arguments: Return Value: PLFCB - A pointer to the log file control block just allocated and initialized. --*/ { PLFCB Lfcb = NULL; ULONG Count; PLBCB NextLbcb; PLCB NextLcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsAllocateLfcb: Entered\n", 0 ); // // Use a try-finally to facilitate cleanup. // try { // // Allocate and zero the structure for the Lfcb. // Lfcb = FsRtlAllocatePool( PagedPool, sizeof( LFCB )); // // Zero out the structure initially. // RtlZeroMemory( Lfcb, sizeof( LFCB )); // // Initialize the log file control block. // Lfcb->NodeTypeCode = LFS_NTC_LFCB; Lfcb->NodeByteSize = sizeof( LFCB ); // // Initialize the client links. // InitializeListHead( &Lfcb->LchLinks ); // // Initialize the Lbcb links. // InitializeListHead( &Lfcb->LbcbWorkque ); InitializeListHead( &Lfcb->LbcbActive ); // // Initialize and allocate the spare Lbcb queue. // InitializeListHead( &Lfcb->SpareLbcbList ); for (Count = 0; Count < LFCB_RESERVE_LBCB_COUNT; Count++) { NextLbcb = ExAllocatePoolWithTag( PagedPool, sizeof( LBCB ), ' sfL' ); if (NextLbcb != NULL) { InsertHeadList( &Lfcb->SpareLbcbList, (PLIST_ENTRY) NextLbcb ); Lfcb->SpareLbcbCount += 1; } } // // Initialize and allocate the spare Lcb queue. // InitializeListHead( &Lfcb->SpareLcbList ); for (Count = 0; Count < LFCB_RESERVE_LCB_COUNT; Count++) { NextLcb = ExAllocatePoolWithTag( PagedPool, sizeof( LCB ), ' sfL' ); if (NextLcb != NULL) { InsertHeadList( &Lfcb->SpareLcbList, (PLIST_ENTRY) NextLcb ); Lfcb->SpareLcbCount += 1; } } // // Allocate the Lfcb synchronization event. // Lfcb->Sync = FsRtlAllocatePool( NonPagedPool, sizeof( LFCB_SYNC )); ExInitializeResource( &Lfcb->Sync->Resource ); // // Initialize the pseudo Lsn for the restart Lbcb's // Lfcb->NextRestartLsn = LfsLi1; // // Initialize the event to the signalled state. // KeInitializeEvent( &Lfcb->Sync->Event, NotificationEvent, TRUE ); Lfcb->Sync->UserCount = 0; // // Initialize the spare list mutex // ExInitializeFastMutex( &(Lfcb->Sync->SpareListMutex) ); } finally { DebugUnwind( LfsAllocateFileControlBlock ); if (AbnormalTermination() && Lfcb != NULL) { LfsDeallocateLfcb( Lfcb, TRUE ); Lfcb = NULL; } DebugTrace( -1, Dbg, "LfsAllocateLfcb: Exit -> %08lx\n", Lfcb ); } return Lfcb; }

PVOID LfsAllocateSpanningBuffer (  IN PLFCB  Lfcb, IN ULONG  Length )

Definition at line 113 of file logpgsup.c. References ASSERT, _LFS_DATA::Buffer1, _LFS_DATA::Buffer2, _LFS_DATA::BufferFlags, _LFS_DATA::BufferOwner, Dbg, DebugTrace, ERESOURCE_THREAD, ExGetCurrentResourceThread, ExRaiseStatus(), FALSE, FlagOn, LFS_BUFFER1_OWNED, LFS_BUFFER2_OWNED, LFS_BUFFER_SIZE, LfsAcquireBufferLock, LfsAcquireLfcb, LfsAllocatePoolNoRaise, LfsBlockBufferWaiters, LfsData, LfsReleaseBufferLock, LfsReleaseLfcb, LfsWaitForBufferNotification, NULL, PAGED_CODE, PagedPool, SetFlag, and TRUE. Referenced by LfsFindLogRecord(). : This routine is called to allocate a spare buffer to read a file record which spans a log page. We will first try to allocate one. If that fails we will use one of the existing spare buffers. If that fails then we will raise. Arguments: Lfcb - This is the file control block for the log file. Length - Length of the buffer required. Return Value: PVOID - Pointer to the buffer to use for reading the log record. May be either from pool or from the auxilary buffer pool. --*/ { PVOID NewBuffer = NULL; ERESOURCE_THREAD Thread; BOOLEAN Wait = FALSE; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsAllocateSpanningBuffer: Entered\n", 0 ); // // Loop while we don't have a buffer. First try to get our reserved buffer // without waiting. Then try to allocate a buffer. Finally wait for the reserved // buffer as the final alternative. // do { // // Skip the reserved buffer if the request is larger than we can read into it. // if (Length <= LFS_BUFFER_SIZE) { // // If this thread already owns one buffer it can get the second directly. // Thread = ExGetCurrentResourceThread(); if (Thread == LfsData.BufferOwner) { if (!FlagOn( LfsData.BufferFlags, LFS_BUFFER1_OWNED )) { SetFlag( LfsData.BufferFlags, LFS_BUFFER1_OWNED ); NewBuffer = LfsData.Buffer1; break; } else if (!FlagOn( LfsData.BufferFlags, LFS_BUFFER2_OWNED )) { SetFlag( LfsData.BufferFlags, LFS_BUFFER2_OWNED ); NewBuffer = LfsData.Buffer2; break; } else if (Wait) { // // This shouldn't happen but handle anyway. // DebugTrace( -1, Dbg, "LfsAllocateSpanningBuffer: Exit\n", 0 ); ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // Otherwise acquire the buffer lock and check the state of the buffers. // } else { BOOLEAN LfcbOwned = TRUE; while (TRUE) { LfsAcquireBufferLock(); // // Check to see if the buffers are available. No // need to drop the Lfcb in the typical case. // if (LfsData.BufferOwner == (ERESOURCE_THREAD) NULL) { ASSERT( !FlagOn( LfsData.BufferFlags, LFS_BUFFER1_OWNED | LFS_BUFFER2_OWNED )); NewBuffer = LfsData.Buffer1; LfsData.BufferOwner = Thread; SetFlag( LfsData.BufferFlags, LFS_BUFFER1_OWNED ); LfsBlockBufferWaiters(); // // Reacquire the Lfcb if needed. // if (!LfcbOwned) { LfsAcquireLfcb( Lfcb ); } // // Break out. // LfsReleaseBufferLock(); break; } // // Release the Lfcb and wait on the notification for the buffers. // if (Wait) { if (LfcbOwned) { LfsReleaseLfcb( Lfcb ); LfcbOwned = FALSE; } LfsReleaseBufferLock(); LfsWaitForBufferNotification(); } else { // // Go ahead and try to allocate a buffer from pool next. // LfsReleaseBufferLock(); break; } } } // // Raise if we already tried the allocate path. // } else if (Wait) { DebugTrace( -1, Dbg, "LfsAllocateSpanningBuffer: Exit\n", 0 ); ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // Try pool if we didn't get a buffer above. // if (NewBuffer == NULL) { // // Try pool next but don't let this fail on pool allocation. // NewBuffer = LfsAllocatePoolNoRaise( PagedPool, Length ); } // // Wait on the next pass through the loop. // Wait = TRUE; } while (NewBuffer == NULL); DebugTrace( -1, Dbg, "LfsAllocateSpanningBuffer: Exit\n", 0 ); return NewBuffer; }

VOID LfsCopyReadLogRecord (  IN PLFCB  Lfcb, IN PLFS_RECORD_HEADER  RecordHeader, OUT PVOID  Buffer )

Definition at line 339 of file lfs/cachesup.c. References Add2Ptr, Buffer, CcUnpinData(), Dbg, DebugTrace, ExRaiseStatus(), FALSE, FlagOn, LFCB_PACK_LOG, LfsLsnToPageOffset, LfsNextLogPageOffset(), LfsPinOrMapData(), LfsTruncateLsnToLogPage, LOG_PAGE_LOG_RECORD_END, NULL, PAGED_CODE, and TRUE. Referenced by LfsFindLogRecord(), and LfsReadRestartArea(). : This routines copies a log record from the file to a buffer. The log record may span several log pages and may even wrap in the file. Arguments: Lfcb - A pointer to the control block for the log file. RecordHeader - Pointer to the log record header for this log record. Buffer - Pointer to the buffer to store the log record. Return Value: None. --*/ { PBCB Bcb = NULL; BOOLEAN UsaError; PLFS_RECORD_PAGE_HEADER PageHeader; LONGLONG LogPageFileOffset; ULONG LogPageOffset; ULONG RemainingTransferBytes; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsCopyReadLogRecord: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "RecordHeader -> %08lx\n", RecordHeader ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", Buffer ); // // We find the file offset of the log page containing the start of // this log record, the offset within the page to start the transfer from, // the number of bytes to transfer on this page and the starting // position in the buffer to begin the transfer to. // LfsTruncateLsnToLogPage( Lfcb, RecordHeader->ThisLsn, &LogPageFileOffset ); LogPageOffset = LfsLsnToPageOffset( Lfcb, RecordHeader->ThisLsn ) + Lfcb->RecordHeaderLength; RemainingTransferBytes = RecordHeader->ClientDataLength; // // Use a try-finally to facilitate cleanup. // try { // // While there are more bytes to transfer, we continue to attempt to // perform the read. // while (TRUE) { ULONG RemainingPageBytes; BOOLEAN Wrapped; RemainingPageBytes = (ULONG)Lfcb->LogPageSize - LogPageOffset; // // We compute the number of bytes to read from this log page and // call the cache package to perform the transfer. // if (RemainingTransferBytes <= RemainingPageBytes) { RemainingPageBytes = RemainingTransferBytes; } RemainingTransferBytes -= RemainingPageBytes; // // Unpin any previous buffer. // if (Bcb != NULL) { CcUnpinData( Bcb ); Bcb = NULL; } LfsPinOrMapData( Lfcb, LogPageFileOffset, (ULONG)Lfcb->LogPageSize, FALSE, FALSE, TRUE, &UsaError, (PVOID *) &PageHeader, &Bcb ); // // The last Lsn on this page better be greater or equal to the Lsn we // are copying. // if ( PageHeader->Copy.LastLsn.QuadPart < RecordHeader->ThisLsn.QuadPart ) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } RtlCopyMemory( Buffer, Add2Ptr( PageHeader, LogPageOffset, PVOID ), RemainingPageBytes ); // // If there are no more bytes to transfer, we exit the loop. // if (RemainingTransferBytes == 0) { // // Our log record better not span this page. // if (!FlagOn( PageHeader->Flags, LOG_PAGE_LOG_RECORD_END ) || (FlagOn( Lfcb->Flags, LFCB_PACK_LOG ) && ( RecordHeader->ThisLsn.QuadPart > PageHeader->Header.Packed.LastEndLsn.QuadPart ))) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } break; } // // If the page header indicates that the log record ended on this page, // this is a disk corrupt condition. For a packed page it means // that the last Lsn and the last Ending Lsn are the same. // if (FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { // // If there is no spanning log record this is an error. // if (( PageHeader->Copy.LastLsn.QuadPart == PageHeader->Header.Packed.LastEndLsn.QuadPart ) || ( RecordHeader->ThisLsn.QuadPart > PageHeader->Copy.LastLsn.QuadPart )) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } // // For an unpacked page it simply means that the page // contains the end of a log record. // } else if (FlagOn( PageHeader->Flags, LOG_PAGE_LOG_RECORD_END )) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } // // We find the start of the next log page and the offset within // that page to start transferring bytes. // LfsNextLogPageOffset( Lfcb, LogPageFileOffset, &LogPageFileOffset, &Wrapped ); LogPageOffset = (ULONG)Lfcb->LogPageDataOffset; // // We also adjust our pointer in the user's buffer to transfer // the next block to. // Buffer = Add2Ptr( Buffer, RemainingPageBytes, PVOID ); } } finally { // // Unpin any previous buffer. // if (Bcb != NULL) { CcUnpinData( Bcb ); Bcb = NULL; } DebugTrace( -1, Dbg, "LfsCopyReadLogRecord: Exit\n", 0 ); } return; }

VOID LfsCurrentAvailSpace (  IN PLFCB  Lfcb, OUT PLONGLONG  CurrentAvailSpace, OUT PULONG  CurrentPageBytes )

Definition at line 36 of file lfs/verfysup.c. References _LBCB::BufferOffset, Dbg, DebugTrace, FlagOn, LBCB_FLUSH_COPY, LBCB_NOT_EMPTY, _LBCB::LbcbFlags, and PAGED_CODE. Referenced by LfsFlushToLsnPriv(), LfsReadLogFileInformation(), and LfsVerifyLogSpaceAvail(). : This routine is called to determine the available log space in the log file. It returns the total number of free bytes and the number available on the active page if present. The total free bytes will reflect all of the empty pages as well as the number in the active page. Arguments: Lfcb - Lfcb for this log file. CurrentAvailSpace - This is the number of bytes available for log records. CurrentPageBytes - This is the number of bytes remaining on the current log page. Return Value: None. --*/ { *CurrentPageBytes = 0; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsCurrentAvailSpace: Entered\n", 0 ); // // Get the total number from the Lfcb. // *CurrentAvailSpace = Lfcb->CurrentAvailable; // // We now look to see if there are any bytes available on the Lbcb in // the active queue. We can add this to the bytes available in the // log pages and also give this back to the caller. // if (!IsListEmpty( &Lfcb->LbcbActive )) { PLBCB ThisLbcb; ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); // // If the page is not empty or the page is empty but this is a // restart page then add the remaining bytes on this page. // if (FlagOn( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY | LBCB_FLUSH_COPY )) { *CurrentPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; *CurrentAvailSpace = *CurrentAvailSpace + *CurrentPageBytes; //**** xxAdd( *CurrentAvailSpace, xxFromUlong( *CurrentPageBytes )); } } DebugTrace( +1, Dbg, "LfsCurrentAvailSpace: Exit\n", 0 ); return; }

VOID LfsDeallocateLbcb (  IN PLFCB  Lfcb, IN PLBCB  Lbcb )

Definition at line 402 of file lfs/strucsup.c. References ExFreePool(), FlagOn, LBCB_RESTART_LBCB, LFCB_MAX_LBCB_COUNT, LfsDeallocateRestartArea, NULL, and PAGED_CODE. Referenced by LfsCloseLogFile(), LfsDeallocateLfcb(), LfsFlushLfcb(), and LfsGetLbcb(). : This routine will deallocate the Lbcb. If we need one for the look-aside list we will put it there. Arguments: Lfcb - Supplies a pointer to the log file control block. Lbcb - This is the Lbcb to deallocate. Return Value: None --*/ { PAGED_CODE(); // // Deallocate any restart area attached to this Lbcb. // if (FlagOn( Lbcb->LbcbFlags, LBCB_RESTART_LBCB ) && (Lbcb->PageHeader != NULL)) { LfsDeallocateRestartArea( Lbcb->PageHeader ); } // // Put this in the Lbcb queue if it is short. // if (Lfcb->SpareLbcbCount < LFCB_MAX_LBCB_COUNT) { InsertHeadList( &Lfcb->SpareLbcbList, (PLIST_ENTRY) Lbcb ); Lfcb->SpareLbcbCount += 1; // // Otherwise just free the pool block. // } else { ExFreePool( Lbcb ); } return; }

VOID LfsDeallocateLcb (  IN PLFCB  Lfcb, IN PLCB  Lcb )

Definition at line 518 of file lfs/strucsup.c. References CcUnpinData(), ExFreePool(), LFCB_MAX_LCB_COUNT, LfsFreeSpanningBuffer(), and NULL. Referenced by LfsReadLogRecord(), and LfsTerminateLogQuery(). : This routine will deallocate an Lcb. We'll cache the old lcb if there aren't too many already on the spare list Arguments: Lfcb - Supplies a pointer to the log file control block. Lcb - This will contain the lcb to release Return Value: None --*/ { if (Lcb->RecordHeaderBcb != NULL) { CcUnpinData( Lcb->RecordHeaderBcb ); } if ((Lcb->CurrentLogRecord != NULL) && Lcb->AuxilaryBuffer) { LfsFreeSpanningBuffer( Lcb->CurrentLogRecord ); } ExAcquireFastMutex( &(Lfcb->Sync->SpareListMutex) ); try { if (Lfcb->SpareLcbCount < LFCB_MAX_LCB_COUNT) { InsertHeadList( &Lfcb->SpareLcbList, (PLIST_ENTRY) Lcb ); Lfcb->SpareLcbCount += 1; } else { ExFreePool( Lcb ); } } finally { ExReleaseFastMutex( &(Lfcb->Sync->SpareListMutex) ); } }

VOID LfsDeallocateLfcb (  IN PLFCB  Lfcb, IN BOOLEAN  CompleteTeardown )

Definition at line 188 of file lfs/strucsup.c. References ASSERT, Dbg, DebugTrace, ExDeleteResource, ExFreePool(), LfsDeallocateLbcb(), LfsDeallocateRestartArea, NULL, and PAGED_CODE. Referenced by LfsAllocateLfcb(), LfsCloseLogFile(), LfsInitializeLogFile(), LfsOpenLogFile(), and LfsRestartLogFile(). : This routine releases the resources associated with a log file control block. Arguments: Lfcb - Supplies a pointer to the log file control block. CompleteTeardown - Indicates if we are to completely remove this Lfcb. Return Value: None --*/ { PLBCB NextLbcb; PLCB NextLcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsDeallocateLfcb: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); // // Check that there are no buffer blocks. // ASSERT( IsListEmpty( &Lfcb->LbcbActive )); ASSERT( IsListEmpty( &Lfcb->LbcbWorkque )); // // Check that we have no clients. // ASSERT( IsListEmpty( &Lfcb->LchLinks )); // // If there is a restart area we deallocate it. // if (Lfcb->RestartArea != NULL) { LfsDeallocateRestartArea( Lfcb->RestartArea ); } // // If there are any of the tail Lbcb's, deallocate them now. // if (Lfcb->ActiveTail != NULL) { LfsDeallocateLbcb( Lfcb, Lfcb->ActiveTail ); Lfcb->ActiveTail = NULL; } if (Lfcb->PrevTail != NULL) { LfsDeallocateLbcb( Lfcb, Lfcb->PrevTail ); Lfcb->PrevTail = NULL; } // // Only do the following if we are to remove the Lfcb completely. // if (CompleteTeardown) { // // If there is a resource structure we deallocate it. // if (Lfcb->Sync != NULL) { ExDeleteResource( &Lfcb->Sync->Resource ); ExFreePool( Lfcb->Sync ); } } // // Deallocate all of the spare Lbcb's. // while (!IsListEmpty( &Lfcb->SpareLbcbList )) { NextLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink; RemoveHeadList( &Lfcb->SpareLbcbList ); ExFreePool( NextLbcb ); } // // Deallocate all of the spare Lcb's. // while (!IsListEmpty( &Lfcb->SpareLcbList )) { NextLcb = (PLCB) Lfcb->SpareLcbList.Flink; RemoveHeadList( &Lfcb->SpareLcbList ); ExFreePool( NextLcb ); } // // Discard the Lfcb structure. // ExFreePool( Lfcb ); DebugTrace( -1, Dbg, "LfsDeallocateLfcb: Exit\n", 0 ); return; }

LONG LfsExceptionFilter (  IN PEXCEPTION_POINTERS  ExceptionPointer  )

Definition at line 58 of file lfsdata.c. References ASSERT, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, FsRtlIsNtstatusExpected(), and NTSTATUS(). Referenced by LfsCloseLogFile(), LfsDeleteLogHandle(), LfsFlushToLsn(), LfsForceWrite(), LfsInitializeLogFile(), LfsOpenLogFile(), LfsPinOrMapData(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsSetBaseLsn(), LfsWrite(), and LfsWriteRestartArea(). 00064 : 00065 00066 This routine is used to decide if we should or should not handle 00067 an exception status that is being raised. It indicates that we should handle 00068 the exception or bug check the system. 00069 00070 Arguments: 00071 00072 ExceptionCode - Supplies the exception code to being checked. 00073 00074 Return Value: 00075 00076 ULONG - returns EXCEPTION_EXECUTE_HANDLER or bugchecks 00077 00078 --*/ 00079 00080 { 00081 NTSTATUS ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode; 00082 00083 #ifdef NTFS_RESTART 00084 ASSERT( (ExceptionCode != STATUS_DISK_CORRUPT_ERROR) && 00085 (ExceptionCode != STATUS_FILE_CORRUPT_ERROR) ); 00086 #endif 00087 00088 //if (ExceptionCode != STATUS_LOG_FILE_FULL) { 00089 // 00090 // DbgPrint("Status not LOGFILE FULL, ExceptionPointers = %08lx\n", ExceptionPointer); 00091 // DbgBreakPoint(); 00092 //} 00093 00094 if (!FsRtlIsNtstatusExpected( ExceptionCode )) { 00095 00096 return EXCEPTION_CONTINUE_SEARCH; 00097 00098 } else { 00099 00100 return EXCEPTION_EXECUTE_HANDLER; 00101 } 00102 } }

VOID LfsFindCurrentAvail (  IN PLFCB  Lfcb  )

Definition at line 412 of file lfs/verfysup.c. References Dbg, DebugTrace, FlagOn, LFCB_NO_LAST_LSN, LFCB_NO_OLDEST_LSN, LFCB_REUSE_TAIL, LfsTruncateOffsetToLogPage, and PAGED_CODE. Referenced by LfsRestartLogFile(), LfsSetBaseLsnPriv(), and LfsUpdateLfcbFromRestart(). 00418 : 00419 00420 This routine is called to calculate the number of bytes available for log 00421 records which are in completely empty log record pages. It ignores any 00422 partial pages in the active work queue and ignores any page which is 00423 going to be reused. 00424 00425 Arguments: 00426 00427 Lfcb - Lfcb for this log file. 00428 00429 Return Value: 00430 00431 None. 00432 00433 --*/ 00434 00435 { 00436 LONGLONG OldestPageOffset; 00437 LONGLONG NextFreePageOffset; 00438 LONGLONG FreeBytes; 00439 00440 PAGED_CODE(); 00441 00442 DebugTrace( +1, Dbg, "LfsFindCurrentAvail: Entered\n", 0 ); 00443 DebugTrace( 0, Dbg, "Lfcb -> %08x\n", Lfcb ); 00444 00445 // 00446 // If there is a last lsn in the restart area then we know 00447 // that we will have to compute the free range. 00448 // 00449 00450 if (!FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN )) { 00451 00452 // 00453 // If there is no oldest Lsn then start at the 00454 // first page of the file. 00455 // 00456 00457 if (FlagOn( Lfcb->Flags, LFCB_NO_OLDEST_LSN )) { 00458 00459 OldestPageOffset = Lfcb->FirstLogPage; 00460 00461 } else { 00462 00463 LfsTruncateOffsetToLogPage( Lfcb, 00464 Lfcb->OldestLsnOffset, 00465 &OldestPageOffset ); 00466 } 00467 00468 // 00469 // We will use the next log page offset to compute the 00470 // next free page. If we are going to reuse this page 00471 // go to the next page, if we are at the first page then 00472 // use the end of the file. 00473 // 00474 00475 if (FlagOn( Lfcb->Flags, LFCB_REUSE_TAIL )) { 00476 00477 NextFreePageOffset = Lfcb->NextLogPage + Lfcb->LogPageSize; //**** xxAdd( Lfcb->NextLogPage, Lfcb->LogPageSize ); 00478 00479 } else if ( Lfcb->NextLogPage == Lfcb->FirstLogPage ) { //**** xxEql( Lfcb->NextLogPage, Lfcb->FirstLogPage ) 00480 00481 NextFreePageOffset = Lfcb->FileSize; 00482 00483 } else { 00484 00485 NextFreePageOffset = Lfcb->NextLogPage; 00486 } 00487 00488 // 00489 // If the two offsets are the same then there is no available space. 00490 // 00491 00492 if ( OldestPageOffset == NextFreePageOffset ) { //**** xxEql( OldestPageOffset, NextFreePageOffset ) 00493 00494 Lfcb->CurrentAvailable = 0; 00495 00496 } else { 00497 00498 // 00499 // If the free offset follows the oldest offset then subtract 00500 // this range from the total available pages. 00501 // 00502 00503 if ( OldestPageOffset < NextFreePageOffset ) { //**** xxLtr( OldestPageOffset, NextFreePageOffset ) 00504 00505 FreeBytes = Lfcb->TotalAvailInPages - ( NextFreePageOffset - OldestPageOffset ); //**** xxSub( Lfcb->TotalAvailInPages, xxSub( NextFreePageOffset, OldestPageOffset )); 00506 00507 } else { 00508 00509 FreeBytes = OldestPageOffset - NextFreePageOffset; //**** xxSub( OldestPageOffset, NextFreePageOffset ); 00510 } 00511 00512 // 00513 // We now have the total bytes in the pages available. We 00514 // now have to subtract the size of the page header to get 00515 // the total available bytes. 00516 // 00517 // We will convert the bytes to pages and then multiple 00518 // by the data size of each page. 00519 // 00520 00521 FreeBytes = Int64ShrlMod32(((ULONGLONG)(FreeBytes)), Lfcb->LogPageShift); 00522 00523 Lfcb->CurrentAvailable = FreeBytes * (ULONG)Lfcb->ReservedLogPageSize; //**** xxXMul( FreeBytes, Lfcb->ReservedLogPageSize.LowPart ); 00524 } 00525 00526 // 00527 // Otherwise the entire file is available. 00528 // 00529 00530 } else { 00531 00532 Lfcb->CurrentAvailable = Lfcb->MaxCurrentAvail; 00533 } 00534 00535 DebugTrace( -1, Dbg, "LfsFindCurrentAvail: Exit\n", 0 ); 00536 00537 return; 00538 } }

BOOLEAN LfsFindNextLsn (  IN PLFCB  Lfcb, IN PLFS_RECORD_HEADER  RecordHeader, OUT PLSN  Lsn )

Definition at line 148 of file lsnsup.c. References CcUnpinData(), Dbg, DebugTrace, DebugUnwind, FALSE, LfsFileOffsetToLsn, LfsFindNextLsn(), LfsIsLsnInFile, LfsLsnFinalOffset(), LfsLsnToFileOffset, LfsLsnToSeqNumber, LfsNextLogPageOffset(), LfsPinOrMapData(), LfsTruncateOffsetToLogPage, LiQuadAlign, NULL, PAGED_CODE, and TRUE. Referenced by LfsFindNextLsn(), and LfsSearchForwardByClient(). : 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 LfsFindOldestClientLsn (  IN PLFS_RESTART_AREA  RestartArea, IN PLFS_CLIENT_RECORD  ClientArray, OUT PLSN  OldestLsn )

Definition at line 189 of file rstrtsup.c. References Dbg, DebugTrace, LFS_NO_CLIENT, _LFS_CLIENT_RECORD::NextClient, _LFS_CLIENT_RECORD::OldestLsn, PAGED_CODE, and USHORT. Referenced by LfsSetBaseLsnPriv(), and LfsUpdateLfcbFromRestart(). : This routine walks through the active clients to determine the oldest Lsn the system must maintain. Arguments: RestartArea - This is the Restart Area to examine. ClientArray - This is the start of the client data array. OldestLsn - We store the oldest Lsn we find in this value. It is initialized with a starting value, we won't return a more recent Lsn. Return Value: None. --*/ { USHORT NextClient; PLFS_CLIENT_RECORD ClientBlock; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFindOldestClientLsn: Entered\n", 0 ); DebugTrace( 0, Dbg, "RestartArea -> %08lx\n", RestartArea ); DebugTrace( 0, Dbg, "Base Lsn (Low) -> %08lx\n", BaseLsn.LowPart ); DebugTrace( 0, Dbg, "Base Lsn (High) -> %08lx\n", BaseLsn.HighPart ); // // Take the first client off the in use list. // NextClient = RestartArea->ClientInUseList; // // While there are more clients, compare their oldest Lsn with the // current oldest. // while (NextClient != LFS_NO_CLIENT) { ClientBlock = ClientArray + NextClient; // // We ignore this block if it's oldest Lsn is 0. // if (( ClientBlock->OldestLsn.QuadPart != 0 ) && ( ClientBlock->OldestLsn.QuadPart < OldestLsn->QuadPart )) { *OldestLsn = ClientBlock->OldestLsn; } // // Try the next client block. // NextClient = ClientBlock->NextClient; } DebugTrace( 0, Dbg, "OldestLsn (Low) -> %08lx\n", BaseLsn.LowPart ); DebugTrace( 0, Dbg, "OldestLsn (High) -> %08lx\n", BaseLsn.HighPart ); DebugTrace( -1, Dbg, "LfsFindOldestClientLsn: Exit\n", 0 ); return; }

VOID LfsFlushLbcb (  IN PLFCB  Lfcb, IN PLBCB  Lbcb )

Definition at line 37 of file lbcbsup.c. References Dbg, DebugTrace, Executive, FALSE, KernelMode, KeWaitForSingleObject(), LfsAcquireLfcb, LfsFlushLfcb(), LfsLbcbIsRestart, LfsNoIoInProgress, LfsReleaseLfcb, LSN, NULL, PAGED_CODE, and PLSN. Referenced by LfsFlushToLsnPriv(), and LfsWriteLfsRestart(). : This routine is called to make sure the data within an Lbcb makes it out to disk. The Lbcb must either already be in the workque or it must be a restart Lbcb. Arguments: Lfcb - This is the file control block for the log file. Lbcb - This is the Lbcb to flush. Return Value: None. --*/ { LSN LastLsn; PLSN FlushedLsn; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushLbcb: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lbcb -> %08lx\n", Lbcb ); LastLsn = Lbcb->LastEndLsn; // // If this is a restart area we use the restart counter in the // Lfcb. Otherwise we can use the LastFlushedLsn value in the // Lfcb. This way we can determine that the Lbcb that interests // us has made it out to disk. // if (LfsLbcbIsRestart( Lbcb )) { FlushedLsn = &Lfcb->LastFlushedRestartLsn; } else { FlushedLsn = &Lfcb->LastFlushedLsn; } // // 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. // do { // // // If we can do the Io, call down to flush the Lfcb. // if (Lfcb->LfsIoState == LfsNoIoInProgress) { LfsFlushLfcb( Lfcb, Lbcb ); break; } // // Otherwise we release the Lfcb and immediately wait on the event. // Lfcb->Waiters += 1; LfsReleaseLfcb( Lfcb ); KeWaitForSingleObject( &Lfcb->Sync->Event, Executive, KernelMode, FALSE, NULL ); LfsAcquireLfcb( Lfcb ); Lfcb->Waiters -= 1; } while ( LastLsn.QuadPart > FlushedLsn->QuadPart ); DebugTrace( -1, Dbg, "LfsFlushLbcb: Exit\n", 0 ); return; }

VOID LfsFlushLfcb (  IN PLFCB  Lfcb, IN PLBCB  Lbcb )

Definition at line 551 of file lfs/cachesup.c. References Add2Ptr, ASSERT, CcFlushCache(), CcMapData(), CcSetDirtyPinnedData(), CcUnpinData(), CcUnpinDataForThread(), _LFS_RESTART_PAGE_HEADER::ChkDskLsn, ClearFlag, _LFS_RECORD_PAGE_HEADER::Copy, Count, Dbg, DebugTrace, DebugUnwind, ExGetCurrentResourceThread, ExRaiseStatus(), FALSE, _LBCB::FileOffset, FlagOn, _LBCB::Flags, KeClearEvent, KeSetEvent(), _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB, _LBCB::Length, LFCB_FINAL_SHUTDOWN, LFCB_LOG_WRAPPED, LFCB_MULTIPLE_PAGE_IO, LFCB_READ_FIRST_RESTART, LFCB_READ_SECOND_RESTART, LFS_SIGNATURE_RECORD_PAGE_ULONG, LFS_SIGNATURE_RESTART_PAGE_ULONG, LfsAcquireLfcb, LfsClientThreadIo, LfsDeallocateLbcb(), LfsFindFirstIo(), LfsFlushLfcb(), LfsLi0, LfsNoIoInProgress, LfsPinOrMapData(), LfsPreparePinWriteData, LfsReleaseLfcb, LfsUsaSeqNumber, LOG_PAGE_LOG_RECORD_END, _LBCB::LogPageBcb, _LFS_RESTART_PAGE_HEADER::LogPageSize, LSN, _LFS_RESTART_PAGE_HEADER::MajorVersion, _LFS_RESTART_PAGE_HEADER::MinorVersion, _LFS_RECORD_PAGE_HEADER::MultiSectorHeader, _LFS_RESTART_PAGE_HEADER::MultiSectorHeader, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, _LFS_RECORD_PAGE_HEADER::PageCount, PAGED_CODE, _LBCB::PageHeader, _LFS_RECORD_PAGE_HEADER::PagePosition, PLFS_RESTART_AREA, PUSHORT, _LBCB::ResourceThread, RESTART_SINGLE_PAGE_IO, _LFS_RESTART_PAGE_HEADER::RestartOffset, SetFlag, _MULTI_SECTOR_HEADER::Signature, Status, _LFS_RESTART_PAGE_HEADER::SystemPageSize, TRUE, try_return, _MULTI_SECTOR_HEADER::UpdateSequenceArrayOffset, _MULTI_SECTOR_HEADER::UpdateSequenceArraySize, USHORT, and _LBCB::WorkqueLinks. Referenced by LfsFlushLbcb(), and LfsFlushLfcb(). : This routine is called to flush the current Lbcbs in on the Lfcb work queue. It will flush up to the I/O which contains the desired Lbcb. Arguments: Lfcb - This is the file control block for the log file. Lbcb - This is the block which is needed to be flushed to disk. Return Value: None. --*/ { PLBCB FirstLbcb; PLBCB ThisLbcb; PLBCB NextLbcb; PLBCB TargetLbcb; PULONG Signature; LONGLONG FileOffset; ULONG Length; BOOLEAN RaiseCorrupt = FALSE; BOOLEAN ValidLastLsn = FALSE; BOOLEAN ContainsLastEntry = FALSE; BOOLEAN LfsRestart; BOOLEAN UseTailCopy; ULONG IoBlocks; ULONG NewLfcbFlags = 0; PBCB MapPageBcb = NULL; PVOID MapPage; LSN LastLsn; IO_STATUS_BLOCK Iosb; PBCB PageBcb = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushLfcb: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); // // Use a try-finally to facilitate cleanup. // try { // // If there are no elements on the list, we are done. // if (IsListEmpty( &Lfcb->LbcbWorkque )) { try_return( NOTHING ); } // // Mark the Lfcb as Io in progress. // Lfcb->LfsIoState = LfsClientThreadIo; #ifdef BRIANDBG Lfcb->LfsIoThread = ExGetCurrentResourceThread(); #endif // // Remember the first Lbcb in the list. // FirstLbcb = CONTAINING_RECORD( Lfcb->LbcbWorkque.Flink, LBCB, WorkqueLinks ); // // We continue looping and performing I/o for as long as possible. // while (!ContainsLastEntry) { ASSERT( Lfcb->PageToDirty == NULL ); // // Reset the notify event for all of the waiting threads. // KeClearEvent( &Lfcb->Sync->Event ); // // Find the block of Lbcb's that make up the first I/O, remembering // how many there are. Also remember if this I/O contains the // last element on the list when we were called. // LfsFindFirstIo( Lfcb, Lbcb, FirstLbcb, &NextLbcb, &FileOffset, &ContainsLastEntry, &LfsRestart, &UseTailCopy, &IoBlocks ); Length = IoBlocks * (ULONG) Lfcb->LogPageSize; if (UseTailCopy) { TargetLbcb = Lfcb->ActiveTail; Lfcb->ActiveTail = Lfcb->PrevTail; Lfcb->PrevTail = TargetLbcb; FileOffset = TargetLbcb->FileOffset; } else { TargetLbcb = FirstLbcb; } // // Give up the Lfcb unless we are looking at an active page. // if (!UseTailCopy) { LfsReleaseLfcb( Lfcb ); } // // If this I/O involves the Lfs restart area, write it to the // cache pages. // if (LfsRestart) { PLFS_RESTART_PAGE_HEADER RestartPage; BOOLEAN UsaError; NTSTATUS Status; // // If there was some error in initially reading the restart page then // it is OK to settle for a page of zeroes. // if (FlagOn( Lfcb->Flags, LFCB_READ_FIRST_RESTART | LFCB_READ_SECOND_RESTART ) && ((FileOffset == 0) ? FlagOn( Lfcb->Flags, LFCB_READ_FIRST_RESTART ) : FlagOn( Lfcb->Flags, LFCB_READ_SECOND_RESTART ))) { LfsPreparePinWriteData( Lfcb, FileOffset, (ULONG) Lfcb->SystemPageSize, &RestartPage, &PageBcb ); Status = STATUS_SUCCESS; if (FileOffset == 0) { SetFlag( NewLfcbFlags, LFCB_READ_FIRST_RESTART ); } else { SetFlag( NewLfcbFlags, LFCB_READ_SECOND_RESTART ); } } else { Status = LfsPinOrMapData( Lfcb, FileOffset, (ULONG)Lfcb->SystemPageSize, TRUE, TRUE, TRUE, &UsaError, &RestartPage, &PageBcb ); } if (NT_SUCCESS( Status )) { // // Initialize the restart page header. // Signature = (PULONG) &RestartPage->MultiSectorHeader.Signature; *Signature = LFS_SIGNATURE_RESTART_PAGE_ULONG; RestartPage->ChkDskLsn = LfsLi0; RestartPage->MultiSectorHeader.UpdateSequenceArrayOffset = Lfcb->RestartUsaOffset; RestartPage->MultiSectorHeader.UpdateSequenceArraySize = Lfcb->RestartUsaArraySize; RestartPage->SystemPageSize = (ULONG)Lfcb->SystemPageSize; RestartPage->LogPageSize = (ULONG)Lfcb->LogPageSize; RestartPage->RestartOffset = (USHORT) Lfcb->RestartDataOffset; RestartPage->MajorVersion = Lfcb->MajorVersion; RestartPage->MinorVersion = Lfcb->MinorVersion; // // If the Lfcb indicates that the file has wrapped, then clear the // first pass flag in the restart area. // if (FlagOn( Lfcb->Flags, LFCB_LOG_WRAPPED )) { ClearFlag( ((PLFS_RESTART_AREA) FirstLbcb->PageHeader)->Flags, RESTART_SINGLE_PAGE_IO ); SetFlag( Lfcb->Flags, LFCB_MULTIPLE_PAGE_IO ); } // // Write the page header into the page and mark the page dirty. // RtlCopyMemory( Add2Ptr( RestartPage, Lfcb->RestartDataOffset, PVOID ), FirstLbcb->PageHeader, (ULONG)FirstLbcb->Length ); // // Make sure the modified bit gets set in the pfn database. The // cache manager should do this even for files we told him not to // lazy write. // CcSetDirtyPinnedData( PageBcb, NULL ); // // We unpin any buffers pinned on this page. // CcUnpinData( PageBcb ); PageBcb = NULL; LastLsn = FirstLbcb->LastLsn; ValidLastLsn = TRUE; // // Use a system page size as the length we need to flush. // Length = (ULONG)Lfcb->SystemPageSize; } else { RaiseCorrupt = TRUE; } // // Otherwise these are log record pages // } else { PLFS_RECORD_PAGE_HEADER RecordPageHeader; ULONG Count; // // Mark the last Lsn fields for the page headers and each // page's position in the transfer. Also unpin all of the // log pages. // Count = 1; ThisLbcb = FirstLbcb; while (TRUE) { // // If we have to use the tail copy, then pin a page to use. // if (UseTailCopy) { BOOLEAN UsaError; if (!NT_SUCCESS( LfsPinOrMapData( Lfcb, TargetLbcb->FileOffset, (ULONG)Lfcb->LogPageSize, TRUE, TRUE, TRUE, &UsaError, &RecordPageHeader, &PageBcb ))) { RaiseCorrupt = TRUE; break; } } else { PUSHORT SeqNumber; RecordPageHeader = (PLFS_RECORD_PAGE_HEADER) ThisLbcb->PageHeader; // // If the sequence number is zero then this is probably a // page of zeroes produced by the cache manager. In order // to insure that we don't have the same sequence number // on each page we will seed the sequence number. // SeqNumber = Add2Ptr( RecordPageHeader, Lfcb->LogRecordUsaOffset, PUSHORT ); if (*SeqNumber == 0) { *SeqNumber = LfsUsaSeqNumber; LfsUsaSeqNumber += 1; } } // // Make sure the modified bit gets set in the pfn database. The // cache manager should do this even for files we told him not to // lazy write. // if (UseTailCopy) { // // Store the file offset of the real page in the header. // Also set the flag indicating the page is a tail copy. // RtlCopyMemory( RecordPageHeader, ThisLbcb->PageHeader, (ULONG)Lfcb->LogPageSize ); RecordPageHeader->Copy.FileOffset = ThisLbcb->FileOffset; } // // We update all of fields as yet not updated. // RecordPageHeader->PagePosition = (USHORT) Count; RecordPageHeader->PageCount = (USHORT) IoBlocks; // // We set up the update sequence array for this structure. // Signature = (PULONG) &RecordPageHeader->MultiSectorHeader.Signature; *Signature = LFS_SIGNATURE_RECORD_PAGE_ULONG; RecordPageHeader->MultiSectorHeader.UpdateSequenceArrayOffset = Lfcb->LogRecordUsaOffset; RecordPageHeader->MultiSectorHeader.UpdateSequenceArraySize = Lfcb->LogRecordUsaArraySize; // // Make sure the modified bit gets set in the pfn database. The // cache manager should do this even for files we told him not to // lazy write. // if (UseTailCopy) { CcSetDirtyPinnedData( PageBcb, NULL ); CcUnpinData( PageBcb ); PageBcb = NULL; } else { CcSetDirtyPinnedData( ThisLbcb->LogPageBcb, NULL ); // // We unpin any buffers pinned on this page. // CcUnpinDataForThread( ThisLbcb->LogPageBcb, ThisLbcb->ResourceThread ); } // // Remember the last lsn and its length if this is the final // page of an Lsn. // if (FlagOn( ThisLbcb->Flags, LOG_PAGE_LOG_RECORD_END )) { LastLsn = ThisLbcb->LastEndLsn; ValidLastLsn = TRUE; } // // Exit the loop if this is the last block. // if (Count == IoBlocks) { break; } // // Otherwise move to the next entry. // ThisLbcb = CONTAINING_RECORD( ThisLbcb->WorkqueLinks.Flink, LBCB, WorkqueLinks ); Count += 1; } } // // Remember the range we are flushing and find the second half of a page // if necessary. // Lfcb->UserWriteData->FileOffset = FileOffset; Lfcb->UserWriteData->Length = Length; if (!UseTailCopy && !LfsRestart) { PLBCB TailLbcb; PLIST_ENTRY Links; LONGLONG NextOffset; // // We are flushing log records. If the current request does not end on // a system page boundary then check if there is another page in // memory that we are concerned with. // if (FlagOn( (ULONG)(FileOffset + Length), (PAGE_SIZE - 1) )) { NextOffset = FileOffset + Length; LfsAcquireLfcb( Lfcb ); // // Start by looking through the Lbcbs on the active queue. // Links = Lfcb->LbcbActive.Flink; while (Links != &Lfcb->LbcbActive) { TailLbcb = CONTAINING_RECORD( Links, LBCB, ActiveLinks ); if (TailLbcb->FileOffset == NextOffset) { Lfcb->PageToDirty = TailLbcb; break; } Links = Links->Flink; } // // If we didn't find it then scan to the end of the workque. // if (Lfcb->PageToDirty == NULL) { Links = Lfcb->LbcbWorkque.Flink; while (Links != &Lfcb->LbcbWorkque) { TailLbcb = CONTAINING_RECORD( Links, LBCB, WorkqueLinks ); if (TailLbcb->FileOffset == NextOffset) { Lfcb->PageToDirty = TailLbcb; break; } Links = Links->Flink; } } // // If we found an Lbcb then unpin the page temporarily. // Other users will have to detect this is not pinned. // if (Lfcb->PageToDirty != NULL) { // // Go ahead and map this page to keep the virtual address // valid. // CcMapData( Lfcb->FileObject, (PLARGE_INTEGER) &Lfcb->PageToDirty->FileOffset, (ULONG) Lfcb->LogPageSize, TRUE, &MapPageBcb, &MapPage ); CcUnpinDataForThread( Lfcb->PageToDirty->LogPageBcb, Lfcb->PageToDirty->ResourceThread ); Lfcb->PageToDirty->LogPageBcb = NULL; } LfsReleaseLfcb( Lfcb ); } } // // We are ready to do the I/O. Flush the pages to the log file. // CcFlushCache( Lfcb->FileObject->SectionObjectPointer, (PLARGE_INTEGER)&FileOffset, Length, &Iosb ); // // Recover the state of any partial page first. // if (Lfcb->PageToDirty != NULL) { LfsPreparePinWriteData( Lfcb, Lfcb->PageToDirty->FileOffset, (ULONG) Lfcb->LogPageSize, &Lfcb->PageToDirty->PageHeader, &Lfcb->PageToDirty->LogPageBcb ); Lfcb->PageToDirty->ResourceThread = ExGetCurrentResourceThread(); Lfcb->PageToDirty = NULL; CcUnpinData( MapPageBcb ); MapPageBcb = NULL; } if (!NT_SUCCESS( Iosb.Status )) { LONG BytesRemaining = (LONG) Length; // // If we get an error then try each individual page. // while (BytesRemaining > 0) { // // Remember the range we are flushing and find the second half of a page // if necessary. // Lfcb->UserWriteData->FileOffset = FileOffset; Lfcb->UserWriteData->Length = Length; if (!UseTailCopy && !LfsRestart) { PLBCB TailLbcb; PLIST_ENTRY Links; LONGLONG NextOffset; // // We are flushing log records. If the current request does not end on // a system page boundary then check if there is another page in // memory that we are concerned with. // if (FlagOn( (ULONG)(FileOffset + Length), (PAGE_SIZE - 1) )) { NextOffset = FileOffset + Length; LfsAcquireLfcb( Lfcb ); // // Start by looking through the Lbcbs on the active queue. // Links = Lfcb->LbcbActive.Flink; while (Links != &Lfcb->LbcbActive) { TailLbcb = CONTAINING_RECORD( Links, LBCB, ActiveLinks ); if (TailLbcb->FileOffset == NextOffset) { Lfcb->PageToDirty = TailLbcb; break; } Links = Links->Flink; } // // If we didn't find it then scan to the end of the workque. // if (Lfcb->PageToDirty == NULL) { Links = Lfcb->LbcbWorkque.Flink; while (Links != &Lfcb->LbcbWorkque) { TailLbcb = CONTAINING_RECORD( Links, LBCB, WorkqueLinks ); if (TailLbcb->FileOffset == NextOffset) { Lfcb->PageToDirty = TailLbcb; break; } Links = Links->Flink; } } // // If we found an Lbcb then unpin the page temporarily. // Other users will have to detect this is not pinned. // if (Lfcb->PageToDirty != NULL) { CcMapData( Lfcb->FileObject, (PLARGE_INTEGER) &Lfcb->PageToDirty->FileOffset, (ULONG) Lfcb->PageToDirty->Length, TRUE, &MapPageBcb, &MapPage ); CcUnpinDataForThread( Lfcb->PageToDirty->LogPageBcb, Lfcb->PageToDirty->ResourceThread ); Lfcb->PageToDirty->LogPageBcb = NULL; } } LfsReleaseLfcb( Lfcb ); } CcFlushCache( Lfcb->FileObject->SectionObjectPointer, (PLARGE_INTEGER)&FileOffset, (ULONG)Lfcb->SystemPageSize, &Iosb ); // // Recover the state of any partial page first. // if (Lfcb->PageToDirty != NULL) { LfsPreparePinWriteData( Lfcb, Lfcb->PageToDirty->FileOffset, (ULONG) Lfcb->PageToDirty->Length, &Lfcb->PageToDirty->PageHeader, &Lfcb->PageToDirty->LogPageBcb ); Lfcb->PageToDirty->ResourceThread = ExGetCurrentResourceThread(); Lfcb->PageToDirty = NULL; CcUnpinData( MapPageBcb ); MapPageBcb = NULL; } if (!NT_SUCCESS( Iosb.Status )) { #ifdef NTFS_RESTART ASSERT( FALSE ); #endif RaiseCorrupt = TRUE; } BytesRemaining -= (LONG)Lfcb->SystemPageSize; FileOffset = FileOffset + Lfcb->SystemPageSize; } } // // Reacquire the Lfcb, remembering that we have it. // if (!UseTailCopy) { LfsAcquireLfcb( Lfcb ); } // // Update the last flushed Lsn value if this isn't a // restart write. // if (!LfsRestart) { if (ValidLastLsn) { Lfcb->LastFlushedLsn = LastLsn; } // // Remember the Lsn we assigned to this restart area. // } else { Lfcb->LastFlushedRestartLsn = LastLsn; // // Clear any neccessary flags on a successful operation. // if (!RaiseCorrupt) { ClearFlag( Lfcb->Flags, NewLfcbFlags ); NewLfcbFlags = 0; } // // If this is the first write of a restart area and we have // updated the LogOpenCount then update the field in the Lfcb. // if (NT_SUCCESS( Iosb.Status ) && (Lfcb->CurrentOpenLogCount != ((PLFS_RESTART_AREA) FirstLbcb->PageHeader)->RestartOpenLogCount)) { Lfcb->CurrentOpenLogCount = ((PLFS_RESTART_AREA) FirstLbcb->PageHeader)->RestartOpenLogCount; } } // // Walk through all the Lbcb's we flushed, deallocating the Lbcbs. // if (!UseTailCopy) { PLBCB TempLbcb; ThisLbcb = FirstLbcb; while (TRUE) { // // Remember the next entry on the list. // TempLbcb = CONTAINING_RECORD( ThisLbcb->WorkqueLinks.Flink, LBCB, WorkqueLinks ); // // Remove it from the LbcbWorkque queue. // RemoveEntryList( &ThisLbcb->WorkqueLinks ); // // Deallocate the structure. // LfsDeallocateLbcb( Lfcb, ThisLbcb ); if (IoBlocks-- == 1) { break; } ThisLbcb = TempLbcb; } } // // If we flushed the Lbcb we were interested in, we are done. // We will signal all waiting threads regardless // KeSetEvent( &Lfcb->Sync->Event, 0, FALSE ); // // Remember the starting Lbcb for the next I/O. // FirstLbcb = NextLbcb; } try_exit: NOTHING; } finally { DebugUnwind( LfsFlushLfcb ); ASSERT( Lfcb->PageToDirty == NULL ); // // Show that there is no Io in progress. // Lfcb->LfsIoState = LfsNoIoInProgress; #ifdef BRIANDBG Lfcb->LfsIoThread = 0; #endif // // Make sure we didn't leave any pages pinned. // if (PageBcb != NULL) { CcUnpinData( PageBcb ); } DebugTrace( -1, Dbg, "LfsFlushLfcb: Exit\n", 0 ); } // // If the Io failed at some point, we raise a corrupt disk error. // The only exception is if this is the final flush of the log file. // In this case the client may not be able to cleanup after this error. // if (RaiseCorrupt && (!FlagOn( Lfcb->Flags, LFCB_FINAL_SHUTDOWN ))) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } return; }

VOID LfsFlushToLsnPriv (  IN PLFCB  Lfcb, IN LSN  Lsn )

Definition at line 134 of file lbcbsup.c. References _LBCB::ActiveLinks, ClearFlag, Dbg, DebugTrace, ExRaiseStatus(), FALSE, FlagOn, _LBCB::Flags, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, LFCB_PACK_LOG, LfsCurrentAvailSpace(), LfsFlushLbcb(), LfsLbcbIsRestart, LOG_PAGE_LOG_RECORD_END, NULL, PAGED_CODE, and TRUE. Referenced by LfsFlushToLsn(), and LfsForceWrite(). : 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. Return Value: None. --*/ { BOOLEAN UseLastRecordLbcb = FALSE; PLBCB LastRecordLbcb = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushToLsnPriv: 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 ); // // We check if the Lsn is in the valid range. Raising an // exception if not. // if (Lsn.QuadPart > Lfcb->RestartArea->CurrentLsn.QuadPart) { UseLastRecordLbcb = TRUE; } // // If the Lsn has already been flushed we are done. // Otherwise we need to look through the workqueues and the // active queue. // if (Lsn.QuadPart > Lfcb->LastFlushedLsn.QuadPart) { PLIST_ENTRY ThisEntry; PLBCB ThisLbcb; // // Check the workqueue first. We are looking for the last // buffer block of a log page block which contains this // Lsn. // ThisEntry = Lfcb->LbcbWorkque.Flink; // // We keep looping. // while (TRUE) { ThisLbcb = CONTAINING_RECORD( ThisEntry, LBCB, WorkqueLinks ); // // We pass over any restart areas. We also skip any // Lbcb's which do not contain the end of a log record. // if (!LfsLbcbIsRestart( ThisLbcb ) && FlagOn( ThisLbcb->Flags, LOG_PAGE_LOG_RECORD_END )) { LastRecordLbcb = ThisLbcb; // // If the last complete Lsn in this Lbcb is greater or equal // to the desired Lsn, we exit the loop. // if (ThisLbcb->LastEndLsn.QuadPart >= Lsn.QuadPart) { break; } } // // Otherwise move to the next Lbcb. // ThisEntry = ThisEntry->Flink; // // If we have reached the end of the list then break out. We // were given an Lsn which is larger than any flushed Lsn so // we will just flush to the end of the log file. // if (ThisEntry == &Lfcb->LbcbWorkque) { if (UseLastRecordLbcb) { ThisLbcb = LastRecordLbcb; } break; } } if (ThisLbcb != NULL) { // // If we are not supporting a packed log file and this Lbcb is from // the active queue, we need to check that losing the tail of the // will not swallow up any of our reserved space. // if (!FlagOn( Lfcb->Flags, LFCB_PACK_LOG ) && FlagOn( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE )) { LONGLONG CurrentAvail; LONGLONG UnusedBytes; // // Find the unused bytes. // UnusedBytes = 0; LfsCurrentAvailSpace( Lfcb, &CurrentAvail, (PULONG)&UnusedBytes ); CurrentAvail = CurrentAvail - Lfcb->TotalUndoCommitment; if (UnusedBytes > CurrentAvail) { DebugTrace( -1, Dbg, "Have to preserve these bytes for possible aborts\n", 0 ); ExRaiseStatus( STATUS_LOG_FILE_FULL ); } // // We want to make sure we don't write any more data into this // page. Remove this from the active queue. // RemoveEntryList( &ThisLbcb->ActiveLinks ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); } // // We now have the Lbcb we want to flush to disk. // LfsFlushLbcb( Lfcb, ThisLbcb ); } } DebugTrace( -1, Dbg, "LfsFlushToLsnPriv: Exit\n", 0 ); return; }

VOID LfsFreeSpanningBuffer (  IN PVOID  Buffer  )

Definition at line 297 of file logpgsup.c. References ASSERT, Buffer, _LFS_DATA::Buffer1, _LFS_DATA::BufferFlags, _LFS_DATA::BufferOwner, ClearFlag, Dbg, DebugTrace, ERESOURCE_THREAD, ExGetCurrentResourceThread, FlagOn, LFS_BUFFER1_OWNED, LFS_BUFFER2_OWNED, LfsAcquireBufferLock, LfsData, LfsFreePool, LfsNotifyBufferWaiters, LfsReleaseBufferLock, NULL, and PAGED_CODE. Referenced by LfsDeallocateLcb(), LfsFindLogRecord(), and LfsReadNextLogRecord(). : This routine is called to free a buffer used to read a log record which spans pages. We will check if it is one of our special buffers and deal with synchronization in that case. Arguments: Buffer - Buffer to free. Return Value: None. --*/ { ERESOURCE_THREAD Thread; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFreeSpanningBuffer: Entered\n", 0 ); // // Do an unsafe test of the buffer flags. If we own a buffer then they must be non-zero. // Otherwise do the correct check of the resource thread. // if (!FlagOn( LfsData.BufferFlags, LFS_BUFFER1_OWNED | LFS_BUFFER2_OWNED ) || (LfsData.BufferOwner != ExGetCurrentResourceThread())) { LfsFreePool( Buffer ); } else { // // Acquire the lock for synchronization. // LfsAcquireBufferLock(); // // Check which buffer it is. // if (Buffer == LfsData.Buffer1) { ClearFlag( LfsData.BufferFlags, LFS_BUFFER1_OWNED ); } else { // // It better be buffer2 // ASSERT( FlagOn( LfsData.BufferFlags, LFS_BUFFER2_OWNED )); ClearFlag( LfsData.BufferFlags, LFS_BUFFER2_OWNED ); } // // If no buffers owned then signal the waiters. // if (!FlagOn( LfsData.BufferFlags, LFS_BUFFER1_OWNED | LFS_BUFFER2_OWNED )) { LfsData.BufferOwner = (ERESOURCE_THREAD) NULL; LfsNotifyBufferWaiters(); } LfsReleaseBufferLock(); } DebugTrace( -1, Dbg, "LfsFreeSpanningBuffer: Exit\n", 0 ); return; }

PLBCB LfsGetLbcb (  IN PLFCB  Lfcb  )

Definition at line 311 of file lbcbsup.c. References _LBCB::ActiveLinks, _LBCB::BufferOffset, CcSetBcbOwnerPointer(), CcUnpinData(), ClearFlag, Dbg, DebugTrace, DebugUnwind, ERESOURCE_THREAD, ExGetCurrentResourceThread, _LBCB::FileOffset, FlagOn, _LBCB::Flags, KeBugCheck(), _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB_FLUSH_COPY, LBCB_LOG_WRAPPED, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, _LBCB::Length, LFCB_LOG_WRAPPED, LFCB_NO_LAST_LSN, LFCB_REUSE_TAIL, LFS_SIGNATURE_RECORD_PAGE_ULONG, LfsAllocateLbcb(), LfsDeallocateLbcb(), LfsGetLbcb(), LfsNextLogPageOffset(), LfsPreparePinWriteData, _LBCB::LogPageBcb, NULL, PAGED_CODE, _LBCB::PageHeader, _LBCB::ResourceThread, _LBCB::SeqNumber, and SetFlag. Referenced by LfsGetLbcb(), and LfsPrepareLfcbForLogRecord(). 00317 : 00318 00319 This routine is called to add a Lbcb to the active queue. 00320 00321 Arguments: 00322 00323 Lfcb - This is the file control block for the log file. 00324 00325 Return Value: 00326 00327 PLBCB - Pointer to the Lbcb allocated. 00328 00329 --*/ 00330 00331 { 00332 PLBCB Lbcb = NULL; 00333 PVOID PageHeader; 00334 PBCB PageHeaderBcb = NULL; 00335 00336 BOOLEAN WrappedOrUsaError; 00337 00338 PAGED_CODE(); 00339 00340 DebugTrace( +1, Dbg, "LfsGetLbcb: Entered\n", 0 ); 00341 DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); 00342 00343 // 00344 // Use a try-finally to facilitate cleanup. 00345 // 00346 00347 try { 00348 00349 // 00350 // Pin the desired record page. 00351 // 00352 00353 LfsPreparePinWriteData( Lfcb, 00354 Lfcb->NextLogPage, 00355 (ULONG)Lfcb->LogPageSize, 00356 &PageHeader, 00357 &PageHeaderBcb ); 00358 00359 // 00360 // Put our signature into the page so we won't fail if we 00361 // see a previous 'BAAD' signature. 00362 // 00363 00364 *((PULONG) PageHeader) = LFS_SIGNATURE_RECORD_PAGE_ULONG; 00365 00366 // 00367 // Now allocate an Lbcb. 00368 // 00369 00370 LfsAllocateLbcb( Lfcb, &Lbcb ); 00371 00372 // 00373 // If we are at the beginning of the file we test that the 00374 // sequence number won't wrap to 0. 00375 // 00376 00377 if (!FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN | LFCB_REUSE_TAIL ) 00378 && ( Lfcb->NextLogPage == Lfcb->FirstLogPage )) { 00379 00380 Lfcb->SeqNumber = Lfcb->SeqNumber + 1; 00381 00382 // 00383 // If the sequence number is going from 0 to 1, then 00384 // this is the first time the log file has wrapped. We want 00385 // to remember this because it means that we can now do 00386 // large spiral writes. 00387 // 00388 00389 if (Int64ShllMod32( Lfcb->SeqNumber, Lfcb->FileDataBits ) == 0) { 00390 00391 DebugTrace( 0, Dbg, "Log sequence number about to wrap: Lfcb -> %08lx\n", Lfcb ); 00392 KeBugCheck( FILE_SYSTEM ); 00393 } 00394 00395 // 00396 // If this number is greater or equal to the wrap sequence number in 00397 // the Lfcb, set the wrap flag in the Lbcb. 00398 // 00399 00400 if (!FlagOn( Lfcb->Flags, LFCB_LOG_WRAPPED ) 00401 && ( Lfcb->SeqNumber >= Lfcb->SeqNumberForWrap )) { 00402 00403 SetFlag( Lbcb->LbcbFlags, LBCB_LOG_WRAPPED ); 00404 SetFlag( Lfcb->Flags, LFCB_LOG_WRAPPED ); 00405 } 00406 } 00407 00408 // 00409 // Now initialize the rest of the Lbcb fields. 00410 // 00411 00412 Lbcb->FileOffset = Lfcb->NextLogPage; 00413 Lbcb->SeqNumber = Lfcb->SeqNumber; 00414 Lbcb->BufferOffset = Lfcb->LogPageDataOffset; 00415 00416 // 00417 // Store the next page in the Lfcb. 00418 // 00419 00420 LfsNextLogPageOffset( Lfcb, 00421 Lfcb->NextLogPage, 00422 &Lfcb->NextLogPage, 00423 &WrappedOrUsaError ); 00424 00425 Lbcb->Length = Lfcb->LogPageSize; 00426 Lbcb->PageHeader = PageHeader; 00427 Lbcb->LogPageBcb = PageHeaderBcb; 00428 00429 Lbcb->ResourceThread = ExGetCurrentResourceThread(); 00430 Lbcb->ResourceThread = (ERESOURCE_THREAD) ((ULONG) Lbcb->ResourceThread | 3); 00431 00432 // 00433 // If we are reusing a previous page then set a flag in 00434 // the Lbcb to indicate that we should flush a copy 00435 // first. 00436 // 00437 00438 if (FlagOn( Lfcb->Flags, LFCB_REUSE_TAIL )) { 00439 00440 SetFlag( Lbcb->LbcbFlags, LBCB_FLUSH_COPY ); 00441 ClearFlag( Lfcb->Flags, LFCB_REUSE_TAIL ); 00442 00443 (ULONG)Lbcb->BufferOffset = Lfcb->ReusePageOffset; 00444 00445 Lbcb->Flags = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Flags; 00446 Lbcb->LastLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Copy.LastLsn; 00447 Lbcb->LastEndLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Header.Packed.LastEndLsn; 00448 } 00449 00450 // 00451 // Put the Lbcb on the active queue 00452 // 00453 00454 InsertTailList( &Lfcb->LbcbActive, &Lbcb->ActiveLinks ); 00455 00456 SetFlag( Lbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); 00457 00458 // 00459 // Now that we have succeeded, set the owner thread to Thread + 1 so the resource 00460 // package will know not to peek in this thread. It may be deallocated before 00461 // we release the Bcb during flush. 00462 // 00463 00464 CcSetBcbOwnerPointer( Lbcb->LogPageBcb, (PVOID) Lbcb->ResourceThread ); 00465 00466 } finally { 00467 00468 DebugUnwind( LfsGetLbcb ); 00469 00470 // 00471 // If an error occurred, we need to clean up any blocks which 00472 // have not been added to the active queue. 00473 // 00474 00475 if (AbnormalTermination()) { 00476 00477 if (Lbcb != NULL) { 00478 00479 LfsDeallocateLbcb( Lfcb, Lbcb ); 00480 Lbcb = NULL; 00481 } 00482 00483 // 00484 // Unpin the system page if pinned. 00485 // 00486 00487 if (PageHeaderBcb != NULL) { 00488 00489 CcUnpinData( PageHeaderBcb ); 00490 } 00491 } 00492 00493 DebugTrace( -1, Dbg, "LfsGetLbcb: Exit\n", 0 ); 00494 } 00495 00496 return Lbcb; 00497 } }

VOID LfsLsnFinalOffset (  IN PLFCB  Lfcb, IN LSN  Lsn, IN ULONG  DataLength, OUT PLONGLONG  FinalOffset )

Definition at line 36 of file lsnsup.c. References Dbg, DebugTrace, LfsLsnToPageOffset, LfsNextLogPageOffset(), LfsTruncateLsnToLogPage, PAGED_CODE, and TRUE. Referenced by LfsFindNextLsn(), and LfsUpdateLfcbFromRestart(). : 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; }

VOID LfsNextLogPageOffset (  IN PLFCB  Lfcb, IN LONGLONG  CurrentLogPageOffset, OUT PLONGLONG  NextLogPageOffset, OUT PBOOLEAN  Wrapped )

Definition at line 40 of file logpgsup.c. References Dbg, DebugTrace, FALSE, LfsTruncateOffsetToLogPage, PAGED_CODE, and TRUE. Referenced by LfsCopyReadLogRecord(), LfsFindLastLsn(), LfsFindNextLsn(), LfsGetLbcb(), LfsLsnFinalOffset(), and LfsUpdateLfcbFromRestart(). : This routine will compute the offset in the log file of the next log page. Arguments: Lfcb - This is the file control block for the log file. CurrentLogPageOffset - This is the file offset of the current log page. NextLogPageOffset - Address to store the next log page to use. Wrapped - This is a pointer to a boolean variable that, if present, we use to indicate whether we wrapped in the log file. Return Value: None. --*/ { PAGED_CODE(); DebugTrace( +1, Dbg, "LfsNextLogPageOffset: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "CurrentLogPageOffset (Low) -> %08lx\n", CurrentLogPageOffset.LowPart ); DebugTrace( 0, Dbg, "CurrentLogPageOffset (High) -> %08lx\n", CurrentLogPageOffset.HighPart ); DebugTrace( 0, Dbg, "Wrapped -> %08lx\n", Wrapped ); // // We add the log page size to the current log offset. // LfsTruncateOffsetToLogPage( Lfcb, CurrentLogPageOffset, &CurrentLogPageOffset ); *NextLogPageOffset = CurrentLogPageOffset + Lfcb->LogPageSize; //**** xxAdd( CurrentLogPageOffset, Lfcb->LogPageSize ); // // If the result is larger than the file, we use the first page offset // in the file. // if ( *NextLogPageOffset >= Lfcb->FileSize ) { //**** xxGeq( *NextLogPageOffset, Lfcb->FileSize ) *NextLogPageOffset = Lfcb->FirstLogPage; *Wrapped = TRUE; } else { *Wrapped = FALSE; } DebugTrace( 0, Dbg, "NextLogPageOffset (Low) -> %08lx\n", NextLogPageOffset->LowPart ); DebugTrace( 0, Dbg, "NextLogPageOffset (High) -> %08lx\n", NextLogPageOffset->HighPart ); DebugTrace( 0, Dbg, "Wrapped -> %08x\n", *Wrapped ); DebugTrace( -1, Dbg, "LfsNextLogPageOffset: Exit\n", 0 ); return; }

NTSTATUS LfsPinOrMapData (  IN PLFCB  Lfcb, IN LONGLONG  FileOffset, IN ULONG  Length, IN BOOLEAN  PinData, IN BOOLEAN  AllowErrors, IN BOOLEAN  IgnoreUsaErrors, OUT PBOOLEAN  UsaError, OUT PVOID *  Buffer, OUT PBCB *  Bcb )

Definition at line 84 of file lfs/cachesup.c. References Buffer, CcMapData(), CcPinRead(), CcUnpinData(), Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, LFS_SIGNATURE_BAD_USA_ULONG, LfsExceptionFilter(), LfsPinOrMapData(), NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, Status, and TRUE. Referenced by LfsCopyReadLogRecord(), LfsFindLastLsn(), LfsFindNextLsn(), LfsFlushLfcb(), LfsInitializeLogFilePriv(), LfsPinOrMapData(), LfsPinOrMapLogRecordHeader(), LfsReadRestart(), and LfsRestartLogFile(). : This routine will pin or map a portion of the log file. Arguments: Lfcb - This is the file control block for the log file. FileOffset - This is the offset of the log page to pin. Length - This is the length of the data to access. PinData - Boolean indicating if we are to pin or map this data. AllowErrors - This boolean indicates whether we should raise on an I/O error or return on an I/O error. IgnoreUsaErrors - Boolean indicating whether we will raise on Usa errors. UsaError - Address to store whether the Usa had an error. Buffer - This is the address to store the address of the data. Bcb - This is the Bcb for this operation. Return Value: NTSTATUS - The result of the I/O. --*/ { volatile NTSTATUS Status; ULONG Signature; BOOLEAN Result = FALSE; Status = STATUS_SUCCESS; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsPinReadLogPage: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "FileOffset (Low) -> %08lx\n", FileOffset.HighPart ); DebugTrace( 0, Dbg, "FileOffset (High) -> %08lx\n", FileOffset.LowPart ); DebugTrace( 0, Dbg, "Length -> %08lx\n", Length ); DebugTrace( 0, Dbg, "PinData -> %04x\n", PinData ); DebugTrace( 0, Dbg, "AllowErrors -> %08x\n", AllowErrors ); DebugTrace( 0, Dbg, "IgnoreUsaErrors -> %04x\n", IgnoreUsaErrors ); // // Use a try-finally to facilitate cleanup. // try { // // Use a try-except to catch cache manager errors. // try { // // We call the cache to perform the work. // if (PinData) { Result = CcPinRead( Lfcb->FileObject, (PLARGE_INTEGER)&FileOffset, Length, TRUE, Bcb, Buffer ); } else { Result = CcMapData( Lfcb->FileObject, (PLARGE_INTEGER)&FileOffset, Length, TRUE, Bcb, Buffer ); } // // Capture the signature now while we are within the // exception filter. // Signature = *((PULONG) *Buffer); } except( LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); if (Result) { CcUnpinData( *Bcb ); *Bcb = NULL; } } *UsaError = FALSE; // // If an error occurred, we raise the status. // if (!NT_SUCCESS( Status )) { if (!AllowErrors) { DebugTrace( 0, Dbg, "Read on log page failed -> %08lx\n", Status ); ExRaiseStatus( Status ); } // // Check that the update sequence array for this // page is valid. // } else if (Signature == LFS_SIGNATURE_BAD_USA_ULONG) { // // If we don't allow errors, raise an error status. // if (!IgnoreUsaErrors) { DebugTrace( 0, Dbg, "Usa error on log page\n", 0 ); ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } *UsaError = TRUE; } } finally { DebugUnwind( LfsPinOrMapData ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", *Buffer ); DebugTrace( 0, Dbg, "Bcb -> %08lx\n", *Bcb ); DebugTrace( -1, Dbg, "LfsPinOrMapData: Exit -> %08lx\n", Status ); } return Status; }

VOID LfsPinOrMapLogRecordHeader (  IN PLFCB  Lfcb, IN LSN  Lsn, IN BOOLEAN  PinData, IN BOOLEAN  IgnoreUsaErrors, OUT PBOOLEAN  UsaError, OUT PLFS_RECORD_HEADER *  RecordHeader, OUT PBCB *  Bcb )

Definition at line 248 of file lfs/cachesup.c. References Add2Ptr, Dbg, DebugTrace, FALSE, LfsLsnToPageOffset, LfsPinOrMapData(), LfsTruncateLsnToLogPage, PAGED_CODE, PLFS_RECORD_HEADER, and PLFS_RECORD_PAGE_HEADER. Referenced by LfsFindClientNextLsn(), LfsFindLogRecord(), LfsReadRestartArea(), and LfsSearchForwardByClient(). : This routine will pin or map a log record for read access. Arguments: Lfcb - This is the file control block for the log file. Lsn - This is the Lsn whose header should be pinned. PinData - Boolean indicating if we are to pin or map this data. IgnoreUsaErrors - Boolean indicating whether we will raise on Usa errors. UsaError - Address to store whether the Usa had an error. RecordHeader - This is the address to store the address of the pinned data. Bcb - This is the Bcb for this pin operation. Return Value: None. --*/ { PLFS_RECORD_PAGE_HEADER LogPageHeader; LONGLONG LogPage; ULONG PageOffset; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsPinOrMapLogRecordHeader: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn.HighPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn.LowPart ); DebugTrace( 0, Dbg, "PinData -> %04x\n", PinData ); DebugTrace( 0, Dbg, "IgnoreUsaErrors -> %04x\n", IgnoreUsaErrors ); // // Compute the log page and the offset of the log record header // in the log page. // LfsTruncateLsnToLogPage( Lfcb, Lsn, &LogPage ); PageOffset = LfsLsnToPageOffset( Lfcb, Lsn ); // // Call the cache manager to pin the page. // LfsPinOrMapData( Lfcb, LogPage, (ULONG)Lfcb->LogPageSize, PinData, FALSE, IgnoreUsaErrors, UsaError, (PVOID *) &LogPageHeader, Bcb ); // // The actual offset we need is at PageOffset from the start of the page. // *RecordHeader = Add2Ptr( LogPageHeader, PageOffset, PLFS_RECORD_HEADER ); DebugTrace( 0, Dbg, "Record Header -> %08lx\n", *RecordHeader ); DebugTrace( 0, Dbg, "Bcb -> %08lx\n", *Bcb ); DebugTrace( -1, Dbg, "LfsPinOrMapLogRecordHeader: Exit\n", 0 ); return; }

BOOLEAN LfsReadRestart (  IN PLFCB  Lfcb, IN LONGLONG  FileSize, IN BOOLEAN  FirstRestart, OUT PLONGLONG  RestartPageOffset, OUT PLFS_RESTART_PAGE_HEADER *  RestartPage, OUT PBCB *  RestartPageBcb, OUT PBOOLEAN  ChkdskWasRun, OUT PBOOLEAN  ValidPage, OUT PBOOLEAN  UninitializedFile, OUT PBOOLEAN  LogPacked, OUT PLSN  LastLsn )

Definition at line 1402 of file lfs/cachesup.c. References Add2Ptr, CcUnpinData(), _LFS_RESTART_AREA::ClientInUseList, _LFS_RESTART_AREA::CurrentLsn, Dbg, DebugTrace, DebugUnwind, FALSE, LFS_NO_CLIENT, LFS_SIGNATURE_MODIFIED_ULONG, LFS_SIGNATURE_RECORD_PAGE_ULONG, LFS_SIGNATURE_RESTART_PAGE_ULONG, LFS_SIGNATURE_UNINITIALIZED_ULONG, LfsIsClientAreaValid(), LfsIsRestartAreaValid(), LfsIsRestartPageHeaderValid(), LfsPinOrMapData(), LfsReadRestart(), NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PLSN, SEQUENCE_NUMBER_STRIDE, Status, and TRUE. Referenced by LfsReadRestart(), and LfsRestartLogFile(). : This routine will walk through 512 blocks of the file looking for a valid restart page header. It will stop the first time we find a valid page header. Arguments: Lfcb - This is the Lfcb for the log file. FileSize - Size in bytes for the log file. FirstRestart - Indicates if we are looking for the first valid restart area. RestartPageOffset - This is the location to store the offset in the file where the log page was found. RestartPage - This is the location to store the address of the pinned restart page. RestartPageBcb - This is the location to store the Bcb for this cache pin operation. ChkdskWasRun - Address to store whether checkdisk was run on this volume. ValidPage - Address to store whether there was valid data on this page. UninitializedFile - Address to store whether this is an uninitialized log file. Return value only valid if for the first restart area. LogPacked - Address to store whether the log file is packed. LastLsn - Address to store the last Lsn for this restart page. It will be the chkdsk value if checkdisk was run. Otherwise it is the LastFlushedLsn for this restart page. Return Value: BOOLEAN - TRUE if a restart area was found, FALSE otherwise. --*/ { ULONG FileOffsetIncrement; LONGLONG FileOffset; PLFS_RESTART_AREA RestartArea; NTSTATUS Status; PLFS_RESTART_PAGE_HEADER ThisPage; PBCB ThisPageBcb = NULL; BOOLEAN FoundRestart = FALSE; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsReadRestart: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); // // Use a try-finally to facilitate cleanup. // *UninitializedFile = TRUE; *ValidPage = FALSE; *ChkdskWasRun = FALSE; *LogPacked = FALSE; try { // // Determine which restart area we are looking for. // if (FirstRestart) { FileOffset = 0; FileOffsetIncrement = SEQUENCE_NUMBER_STRIDE; } else { FileOffset = SEQUENCE_NUMBER_STRIDE; FileOffsetIncrement = 0; } // // We loop continuously until we succeed, pin a log record page // or exhaust the number of possible tries. // while ( FileOffset < FileSize ) { ULONG Signature; BOOLEAN UsaError; if (ThisPageBcb != NULL) { CcUnpinData( ThisPageBcb ); ThisPageBcb = NULL; } // // Attempt to pin a page header at the current offset. // Status = LfsPinOrMapData( Lfcb, FileOffset, SEQUENCE_NUMBER_STRIDE, TRUE, TRUE, TRUE, &UsaError, (PVOID *)&ThisPage, &ThisPageBcb ); // // // If we succeeded, we look at the 4 byte signature. // if (NT_SUCCESS( Status )) { Signature = *((PULONG) &ThisPage->MultiSectorHeader.Signature); // // If the signature is a log record page, we will exit. // if (Signature == LFS_SIGNATURE_RECORD_PAGE_ULONG) { *UninitializedFile = FALSE; break; } // // Continue analyzing the page if the signature is chkdsk or // a restart page. // if (Signature == LFS_SIGNATURE_MODIFIED_ULONG || Signature == LFS_SIGNATURE_RESTART_PAGE_ULONG) { *UninitializedFile = FALSE; // // Remember where we found this page. // *RestartPageOffset = FileOffset; // // Let's check the restart area if this is a valid page. // if (LfsIsRestartPageHeaderValid( FileOffset, ThisPage, LogPacked ) && LfsIsRestartAreaValid( ThisPage, *LogPacked )) { // // We have a valid restart page header and restart area. // If chkdsk was run or we have no clients then // we have no more checking to do. // RestartArea = Add2Ptr( ThisPage, ThisPage->RestartOffset, PLFS_RESTART_AREA ); if (Signature == LFS_SIGNATURE_RESTART_PAGE_ULONG && RestartArea->ClientInUseList != LFS_NO_CLIENT) { // // Pin the entire restart area if we didn't have an earlier // CcUnpinData( ThisPageBcb ); ThisPageBcb = NULL; Status = LfsPinOrMapData( Lfcb, FileOffset, ThisPage->SystemPageSize, TRUE, TRUE, TRUE, &UsaError, (PVOID *)&ThisPage, &ThisPageBcb ); if (NT_SUCCESS( Status ) && LfsIsClientAreaValid( ThisPage, *LogPacked, UsaError )) { *ValidPage = TRUE; RestartArea = Add2Ptr( ThisPage, ThisPage->RestartOffset, PLFS_RESTART_AREA ); } } else { *ValidPage = TRUE; } } // // If chkdsk was run then update the caller's values and return. // if (Signature == LFS_SIGNATURE_MODIFIED_ULONG) { *ChkdskWasRun = TRUE; *LastLsn = ThisPage->ChkDskLsn; FoundRestart = TRUE; *RestartPageBcb = ThisPageBcb; *RestartPage = ThisPage; ThisPageBcb = NULL; break; } // // If we have a valid page then copy the values we need from it. // if (*ValidPage) { *LastLsn = RestartArea->CurrentLsn; FoundRestart = TRUE; *RestartPageBcb = ThisPageBcb; *RestartPage = ThisPage; ThisPageBcb = NULL; break; } // // Remember if the signature does not indicate uninitialized file. // } else if (Signature != LFS_SIGNATURE_UNINITIALIZED_ULONG) { *UninitializedFile = FALSE; } } // // Move to the next possible log page. // FileOffset = FileOffset << 1; (ULONG)FileOffset += FileOffsetIncrement; FileOffsetIncrement = 0; } } finally { DebugUnwind( LfsReadRestart ); // // Unpin the log pages if pinned. // if (ThisPageBcb != NULL) { CcUnpinData( ThisPageBcb ); } DebugTrace( 0, Dbg, "RestartPageAddress (Low) -> %08lx\n", RestartPageAddress->LowPart ); DebugTrace( 0, Dbg, "RestartPageAddress (High) -> %08lx\n", RestartPageAddress->HighPart ); DebugTrace( 0, Dbg, "FirstRestartPage -> %08lx\n", *FirstRestartPage ); DebugTrace( -1, Dbg, "LfsReadRestart: Exit\n", 0 ); } return FoundRestart; }

BOOLEAN LfsVerifyLogSpaceAvail (  IN PLFCB  Lfcb, IN PLCH  Lch, IN ULONG  RemainingLogBytes, IN LONG  UndoRequirement, IN BOOLEAN  ForceToDisk )

Definition at line 114 of file lfs/verfysup.c. References Dbg, DebugTrace, ExRaiseStatus(), FALSE, FlagOn, LFCB_PACK_LOG, LfsCurrentAvailSpace(), PAGED_CODE, and TRUE. Referenced by LfsWriteLogRecordIntoLogPage(). : This routine is called to verify that we may write this log record into the log file. We want to always leave room for each transaction to abort. We determine how much space the current log record will take and the worst case for its undo operation. If this space is available we update the corresponding values in the Lfcb and Lch for bookkeeping. Otherwise we raise a status indicating that the log file is full. The disk usage is different for the packed and unpacked cases. Make the following adjustments after finding the total available and amount still remaining on the last active page, Packed Case: Size needed for log record is data size plus header size. Undo requirement is the undo data size plus the header size. We have already taken into account the end of the pages except for the current page. Add the log record size to the undo requirement to get the log file usage. Compare this number with the actual available space (Available - CommittedUndo). If the space is not available, then raise LOG_FILE_FULL. Must take into account any unused bytes at the end of the current page. Unpacked Case: Size needed is initially header size plus data size. If the log record can't begin on the current page then add the bytes being thrown away to the log record size. If the page is being forced to disk then add any remaining bytes on the last page. To the bytes being used. Undo requirement is twice the sum of the header size and undo size. We double the requested size since the log record will always fit on a page. This can be a positive or negative number. Add the log record usage to the undo usage to get the log file usage. Compare this number with the actual available space (Available - CommittedUndo). If the space is not available, then raise LOG_FILE_FULL. Arguments: Lfcb - Lfcb for this log file. Lch - Client handle RemainingLogBytes - Number of bytes for the current log record UndoRequirement - User's requirement for the undo record. ForceToDisk - Indicates if this log record will be flushed to disk. Return Value: BOOLEAN - Advisory, indicates that there is less than 1/4 of the log file available. --*/ { ULONG CurrentLogRecordSize; ULONG LogRecordStart; ULONG TailBytes; LONGLONG CurrentAvailSpace; ULONG CurrentPageBytes; LONGLONG LogFileUsage; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsVerifyLogSpaceAvail: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08x\n", Lfcb ); DebugTrace( 0, Dbg, "Lch -> %08lx\n", Lch ); DebugTrace( 0, Dbg, "RemainingLogBytes -> %08lx\n", RemainingLogBytes ); DebugTrace( 0, Dbg, "UndoRequirement -> %08lx\n", UndoRequirement ); DebugTrace( 0, Dbg, "ForceToDisk -> %04x\n", ForceToDisk ); // // Start by collecting the current data on the file. // LfsCurrentAvailSpace( Lfcb, &CurrentAvailSpace, &CurrentPageBytes ); // // We compute the amount of space needed for the current log record by // adding up the following: // // Space at end of current log page which won't be used. // Size of header for log record. // Size of client data in log record. // Size of wasted portion of log page if this is forced to disk. // // // Start with the size of the header and the client data. // CurrentLogRecordSize = RemainingLogBytes + Lfcb->RecordHeaderLength; // // If the log is packed and there are bytes on the current page we need // to take into account any bytes at the end of the page which won't // be used. This will happen if the log record spills into the end of // the log page but doesn't use up the page. If the remaining bytes are // less than a record header size we must throw them away. // if (FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { if (CurrentPageBytes != 0 && CurrentLogRecordSize < CurrentPageBytes && (CurrentPageBytes - CurrentLogRecordSize) < Lfcb->RecordHeaderLength) { CurrentLogRecordSize += (CurrentPageBytes - CurrentLogRecordSize); } // // If this is the unpacked case we need to check for bytes being thrown away // on the current page or the last page. // } else { // // If there is an active Lbcb, we need to add any bytes that // would be thrown away at the end. // if (CurrentPageBytes != 0) { // // We won't use this log page unless the new log record will fit or // unless this is the first log record in the page. // if ((CurrentPageBytes != (ULONG)Lfcb->LogPageDataSize) && (CurrentLogRecordSize > CurrentPageBytes)) { CurrentLogRecordSize += CurrentPageBytes; // // Remember that we will start this log record at the first // byte in the data portion of a page. // LogRecordStart = 0; // // Otherwise this will start at the current offset into the // data portion of the log page. // } else { LogRecordStart = (ULONG)Lfcb->LogPageDataSize - CurrentPageBytes; } // // If there was no Lbcb, then we know that we will start at the first // byte of the data portion. // } else { LogRecordStart = 0; } // // We always assume that we will use up the rest of the bytes on the last page // in computing whether the log record will fit in the available space. We // only subtract that space from the available space if this is a force write. // if (ForceToDisk) { // // We take into account where we start on a log page and continue // to subtract log pages until we know the amount on the last // page. // TailBytes = RemainingLogBytes + Lfcb->RecordHeaderLength + LogRecordStart; while (TailBytes > (ULONG)Lfcb->LogPageDataSize) { TailBytes -= (ULONG)Lfcb->LogPageDataSize; } TailBytes = (ULONG)Lfcb->LogPageDataSize - TailBytes; CurrentLogRecordSize += TailBytes; } } // // We now know the number of bytes needed for the current log page. // Next we compute the number of bytes being reserved by UndoRequirement. // If the UndoRequirement is positive, we will add to the amount reserved // in the log file. If it is negative, we will subtract from the amount // reserved in the log file. // // // When we have an actual reserve amount, we convert it to positive // and then reserve twice the space required to hold the data and // its header (up to the maximum of a single page. // if (UndoRequirement != 0) { if (!FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { UndoRequirement *= 2; } if (UndoRequirement < 0) { UndoRequirement -= (2 * Lfcb->RecordHeaderLength); } else { UndoRequirement += (2 * Lfcb->RecordHeaderLength); } } // // Now compute the net log file usage. The result may be positive or // negative. // LogFileUsage = ((LONG) CurrentLogRecordSize) + UndoRequirement; //**** xxFromLong( ((LONG) CurrentLogRecordSize) + UndoRequirement ); // // The actual available space is the CurrentAvail minus the reserved // undo value in the Lfcb. // CurrentAvailSpace = CurrentAvailSpace - Lfcb->TotalUndoCommitment; //**** xxSub( CurrentAvailSpace, Lfcb->TotalUndoCommitment ); // // If this log file usage is greater than the available log file space // then we raise a status code. // #ifdef LFS_RAISE if (LfsRaiseFull) { LfsRaiseFull = FALSE; DebugTrace( -1, Dbg, "LfsVerifyLogSpaceAvail: About to raise\n", 0 ); ExRaiseStatus( STATUS_LOG_FILE_FULL ); } #endif if (LogFileUsage > CurrentAvailSpace) { DebugTrace( -1, Dbg, "LfsVerifyLogSpaceAvail: About to raise\n", 0 ); ExRaiseStatus( STATUS_LOG_FILE_FULL ); } Lfcb->TotalUndoCommitment = Lfcb->TotalUndoCommitment + UndoRequirement; //**** xxAdd( Lfcb->TotalUndoCommitment, xxFromLong( UndoRequirement )); Lch->ClientUndoCommitment = Lch->ClientUndoCommitment + UndoRequirement; //**** xxAdd( Lch->ClientUndoCommitment, xxFromLong( UndoRequirement )); DebugTrace( -1, Dbg, "LfsVerifyLogSpaceAvail: Exit\n", 0 ); // // Now check if the log file is almost used up. // if ((CurrentAvailSpace - LogFileUsage) < (Lfcb->TotalAvailable >> 2)) { return TRUE; } return FALSE; }

VOID LfsWriteLfsRestart (  IN PLFCB  Lfcb, IN ULONG  ThisRestartSize, IN BOOLEAN  WaitForIo )

Definition at line 36 of file rstrtsup.c. References _LBCB::ActiveLinks, Add2Ptr, ClearFlag, _LFS_RESTART_AREA::ClientArrayOffset, Dbg, DebugTrace, DebugUnwind, ExFreePool(), _LBCB::FileOffset, FlagOn, _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB_NOT_EMPTY, LBCB_ON_ACTIVE_QUEUE, LBCB_RESTART_LBCB, _LBCB::LbcbFlags, _LBCB::Length, LFCB_PACK_LOG, LfsAllocateLbcb(), LfsAllocateRestartArea, LfsFlushLbcb(), LfsWriteLfsRestart(), NULL, PAGED_CODE, _LBCB::PageHeader, SetFlag, and _LBCB::WorkqueLinks. Referenced by LfsCloseLogFile(), LfsInitializeLogFilePriv(), LfsSetBaseLsn(), LfsWriteLfsRestart(), and LfsWriteRestartArea(). : This routine puts the Lfs restart area on the queue of operations to write to the file. We do this by allocating a second restart area and attaching it to the Lfcb. We also allocate a buffer control block to use for this write. We look at the WaitForIo boolean to determine whether this thread can perform the I/O. This also indicates whether this thread gives up the Lfcb. Arguments: Lfcb - A pointer to the log file control block for this operation. ThisRestartSize - This is the size to use for the restart area. WaitForIo - Indicates if this thread is to perform the work. Return Value: None. --*/ { PLBCB NewLbcb = NULL; PLFS_RESTART_AREA NewRestart = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsWriteLfsRestart: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Write Chkdsk -> %04x\n", WriteChkdsk ); DebugTrace( 0, Dbg, "Restart Size -> %08lx\n", ThisRestartSize ); DebugTrace( 0, Dbg, "WaitForIo -> %08lx\n", WaitForIo ); // // Use a try-finally to facilitate cleanup. // try { PLBCB ActiveLbcb; // // We allocate another restart area and // copy the current area into it. Attach the new area to the Lfcb. // LfsAllocateRestartArea( &NewRestart, ThisRestartSize ); // // We allocate a Lbcb structure and update the values to // reflect this restart area. // LfsAllocateLbcb( Lfcb, &NewLbcb ); SetFlag( NewLbcb->LbcbFlags, LBCB_RESTART_LBCB ); // // If this is the second page, then add a system page to the offset. // if (!Lfcb->InitialRestartArea) { NewLbcb->FileOffset = Lfcb->SystemPageSize + NewLbcb->FileOffset; } (ULONG)NewLbcb->Length = ThisRestartSize; NewLbcb->PageHeader = (PVOID) Lfcb->RestartArea; // // Lets put the current lsn in the Lbcb. // NewLbcb->LastEndLsn = NewLbcb->LastLsn = Lfcb->NextRestartLsn; Lfcb->NextRestartLsn.QuadPart = 1 + Lfcb->NextRestartLsn.QuadPart; // // Copy the existing restart area into the new area. // RtlCopyMemory( NewRestart, Lfcb->RestartArea, ThisRestartSize ); Lfcb->RestartArea = NewRestart; Lfcb->ClientArray = Add2Ptr( NewRestart, Lfcb->ClientArrayOffset, PLFS_CLIENT_RECORD ); NewRestart = NULL; // // Update the Lfcb to indicate that the other restart area // on the disk is to be used. // Lfcb->InitialRestartArea = !Lfcb->InitialRestartArea; // // Add this Lbcb to the end of the workque and flush to that point. // InsertTailList( &Lfcb->LbcbWorkque, &NewLbcb->WorkqueLinks ); // // If we don't support a packed log file then we need to make // sure that all file records written out ahead of this // restart area make it out to disk and we don't add anything // to this page. // if (!FlagOn( Lfcb->Flags, LFCB_PACK_LOG ) && !IsListEmpty( &Lfcb->LbcbActive )) { ActiveLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); if (FlagOn( ActiveLbcb->LbcbFlags, LBCB_NOT_EMPTY )) { RemoveEntryList( &ActiveLbcb->ActiveLinks ); ClearFlag( ActiveLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); } } if (WaitForIo) { LfsFlushLbcb( Lfcb, NewLbcb ); } } finally { DebugUnwind( LfsWriteLfsRestart ); if (NewRestart != NULL) { ExFreePool( NewRestart ); } DebugTrace( -1, Dbg, "LfsWriteLfsRestart: Exit\n", 0 ); } return; }

BOOLEAN LfsWriteLogRecordIntoLogPage (  IN PLFCB  Lfcb, IN PLCH  Lch, IN ULONG  NumberOfWriteEntries, IN PLFS_WRITE_ENTRY  WriteEntries, IN LFS_RECORD_TYPE  RecordType, IN TRANSACTION_ID *TransactionId  OPTIONAL, IN LSN ClientUndoNextLsn  OPTIONAL, IN LSN ClientPreviousLsn  OPTIONAL, IN LONG  UndoRequirement, IN BOOLEAN  ForceToDisk, OUT PLSN  Lsn )

Definition at line 55 of file logrcsup.c. References Add2Ptr, _LFS_WRITE_ENTRY::Buffer, _LBCB::BufferOffset, _LFS_WRITE_ENTRY::ByteLength, ClearFlag, _LFS_RECORD_HEADER::ClientDataLength, _LFS_RECORD_HEADER::ClientId, _LFS_RECORD_HEADER::ClientPreviousLsn, _LFS_RECORD_HEADER::ClientUndoNextLsn, _LFS_RECORD_PAGE_HEADER::Copy, Dbg, DebugTrace, Executive, FALSE, FlagOn, _LFS_RECORD_HEADER::Flags, _LBCB::Flags, _LFS_RECORD_PAGE_HEADER::Flags, _LFS_RECORD_PAGE_HEADER::Header, KernelMode, KeWaitForSingleObject(), _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB_NOT_EMPTY, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, LFCB_NO_LAST_LSN, LFCB_PACK_LOG, LfsAcquireLfcb, LfsComputeLsnFromLbcb, LfsPrepareLfcbForLogRecord(), LfsReleaseLfcb, LfsTransferLogBytes(), LfsVerifyLogSpaceAvail(), LOG_PAGE_LOG_RECORD_END, LOG_RECORD_MULTI_PAGE, _LBCB::LogPageBcb, LSN, NULL, PAGED_CODE, _LBCB::PageHeader, QuadAlign, _LFS_RECORD_HEADER::RecordType, SetFlag, _LFS_RECORD_HEADER::ThisLsn, _LFS_RECORD_HEADER::TransactionId, TRUE, USHORT, and _LBCB::WorkqueLinks. Referenced by LfsForceWrite(), LfsWrite(), and LfsWriteRestartArea(). : This routine is called to write a log record into the log file using the cache manager. If there is room in the current log page it is added to that. Otherwise we allocate a new log page and write the log record header for this log page. We then write the log record into the remaining bytes of this page and into any subsequent pages if needed. Arguments: Lfcb - File control block for this log file. Lch - This is the client handle, we may update the undo space for this client. NumberOfWriteEntries - Number of components of the log record. WriteEntries - Pointer to an array of write entries. UndoRequirement - Signed value indicating the requirement to write an abort log record for this log record. A negative value indicates that this is the abort record. RecordType - The Lfs-defined type of this log record. TransactionId - Pointer to the transaction structure containing the Id for transaction containing this operation. ClientUndoNextLsn - This is the Lsn provided by the client for use in his restart. Will be the zero Lsn for a restart log record. ClientPreviousLsn - This is the Lsn provided by the client for use in his restart. Will the the zero Lsn for a restart log record. UndoRequirement - This is the data size for the undo record for this log record. ForceToDisk - Indicates if this log record will be flushed immediately to disk. Lsn - A pointer to store the Lsn for this log record. Return Value: BOOLEAN - Advisory, TRUE indicates that less than 1/4 of the log file is available. --*/ { PLFS_WRITE_ENTRY ThisWriteEntry; ULONG RemainingLogBytes; ULONG OriginalLogBytes; ULONG RemainingPageBytes; ULONG HeaderAdjust; PLBCB ThisLbcb; LSN NextLsn; PLFS_RECORD_HEADER RecordHeader; PCHAR CurrentBuffer; ULONG CurrentByteCount; ULONG PadBytes; BOOLEAN LogFileFull = FALSE; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsWriteLogRecordIntoLogPage: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lch -> %08lx\n", Lch ); DebugTrace( 0, Dbg, "Number of Write Entries -> %08lx\n", NumberOfWriteEntries ); DebugTrace( 0, Dbg, "Write Entries -> %08lx\n", WriteEntries ); DebugTrace( 0, Dbg, "Record Type -> %08lx\n", RecordType ); DebugTrace( 0, Dbg, "Transaction Id -> %08lx\n", TransactionId ); DebugTrace( 0, Dbg, "ClientUndoNextLsn (Low) -> %08lx\n", ClientUndoNextLsn.LowPart ); DebugTrace( 0, Dbg, "ClientUndoNextLsn (High) -> %08lx\n", ClientUndoNextLsn.HighPart ); DebugTrace( 0, Dbg, "ClientPreviousLsn (Low) -> %08lx\n", ClientPreviousLsn.LowPart ); DebugTrace( 0, Dbg, "ClientPreviousLsn (High) -> %08lx\n", ClientPreviousLsn.HighPart ); DebugTrace( 0, Dbg, "UndoRequirement -> %08lx\n", UndoRequirement ); DebugTrace( 0, Dbg, "ForceToDisk -> %04x\n", ForceToDisk ); // // We compute the size of this log record. // ThisWriteEntry = WriteEntries; RemainingLogBytes = 0; while (NumberOfWriteEntries--) { RemainingLogBytes += QuadAlign( ThisWriteEntry->ByteLength ); ThisWriteEntry++; } OriginalLogBytes = RemainingLogBytes; ThisWriteEntry = WriteEntries; // // Loop until we have the Lbcb and we know it is not part of // a partial page transfer. We need to make sure we have // a Bcb for this page. // while (TRUE) { LogFileFull = LfsVerifyLogSpaceAvail( Lfcb, Lch, RemainingLogBytes, UndoRequirement, ForceToDisk ); // // We update the Lfcb so that we can start putting the log record into // the top of the Lbcb active list. // LfsPrepareLfcbForLogRecord( Lfcb, RemainingLogBytes + Lfcb->RecordHeaderLength ); ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); // // If there is a Bcb then we are golden. // if (ThisLbcb->LogPageBcb != NULL) { break; } // // Otherwise we want to drop the Lfcb and wait for the IO to complete. // Lfcb->Waiters += 1; LfsReleaseLfcb( Lfcb ); KeWaitForSingleObject( &Lfcb->Sync->Event, Executive, KernelMode, FALSE, NULL ); LfsAcquireLfcb( Lfcb ); Lfcb->Waiters -= 1; } RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; // // Compute the Lsn starting in the next log buffer. // NextLsn.QuadPart = LfsComputeLsnFromLbcb( Lfcb, ThisLbcb ); // // We get a pointer to the log record header and the start of the // log record in the pinned buffer. // RecordHeader = Add2Ptr( ThisLbcb->PageHeader, (ULONG)ThisLbcb->BufferOffset, PLFS_RECORD_HEADER ); // // We update the record header. // // // Zero out the structure initially. // RtlZeroMemory( RecordHeader, Lfcb->RecordHeaderLength ); // // Update all the fields. // RecordHeader->ThisLsn = NextLsn; RecordHeader->ClientPreviousLsn = ClientPreviousLsn; RecordHeader->ClientUndoNextLsn = ClientUndoNextLsn; if (TransactionId != NULL) { RecordHeader->TransactionId = *TransactionId; } RecordHeader->ClientDataLength = RemainingLogBytes; RecordHeader->ClientId = Lch->ClientId; RecordHeader->RecordType = RecordType; // // Check if this is a multi-page record. // if (RemainingLogBytes + Lfcb->RecordHeaderLength > RemainingPageBytes) { SetFlag( RecordHeader->Flags, LOG_RECORD_MULTI_PAGE ); } RemainingPageBytes -= Lfcb->RecordHeaderLength; // // Update the buffer position in the Lbcb // (ULONG)ThisLbcb->BufferOffset += Lfcb->RecordHeaderLength; HeaderAdjust = Lfcb->RecordHeaderLength; // // Remember the values in the current write entry. // CurrentBuffer = ThisWriteEntry->Buffer; CurrentByteCount = ThisWriteEntry->ByteLength; PadBytes = (8 - (CurrentByteCount & ~(0xfffffff8))) & ~(0xfffffff8); // // Continue to transfer bytes until all the client's data has // been transferred. // while (RemainingLogBytes != 0) { PLFS_RECORD_PAGE_HEADER PageHeader; PageHeader = (PLFS_RECORD_PAGE_HEADER) ThisLbcb->PageHeader; // // If the Lbcb is empty and we are about to store data into it we // subtract the data size of the page from the available space. // Update all the information we want to put in the header. // if (!FlagOn( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY )) { // // We subtract this page from the available pages only if // we are at the beginning of the page. Otherwise this // could be a reuse page. In that case it has already // been subtracted. // if ((ULONG)ThisLbcb->BufferOffset - HeaderAdjust == (ULONG)Lfcb->LogPageDataOffset) { Lfcb->CurrentAvailable = Lfcb->CurrentAvailable - Lfcb->ReservedLogPageSize; //**** xxSub( Lfcb->CurrentAvailable, Lfcb->ReservedLogPageSize ); } InsertTailList( &Lfcb->LbcbWorkque, &ThisLbcb->WorkqueLinks ); SetFlag( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY ); } HeaderAdjust = 0; // // Compute the number of transfer bytes. Update the remaining // page bytes, remaining log bytes and position in the write // buffer array. This routine also copies the bytes into the buffer. // LfsTransferLogBytes( ThisLbcb, &ThisWriteEntry, &CurrentBuffer, &CurrentByteCount, &PadBytes, &RemainingPageBytes, &RemainingLogBytes ); // // This log record ends on this page. Update the fields for the // ending Lsn. // if (RemainingLogBytes == 0) { SetFlag( ThisLbcb->Flags, LOG_PAGE_LOG_RECORD_END ); ThisLbcb->LastEndLsn = NextLsn; if (FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { PageHeader->Header.Packed.LastEndLsn = NextLsn; PageHeader->Header.Packed.NextRecordOffset = (USHORT)ThisLbcb->BufferOffset; } } // // We are done with this page, update the fields in the page header. // if (RemainingPageBytes == 0 || RemainingLogBytes == 0) { // // We are done with this page. Update the Lbcb and page header. // ThisLbcb->LastLsn = NextLsn; PageHeader->Copy.LastLsn = NextLsn; PageHeader->Flags = ThisLbcb->Flags; // // We can't put any more log records on this page. Remove // it from the active queue. // if (RemainingPageBytes < Lfcb->RecordHeaderLength) { RemoveHeadList( &Lfcb->LbcbActive ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); // // If there are more log bytes then get the next Lbcb. // if (RemainingLogBytes != 0) { ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; } } } } *Lsn = NextLsn; Lfcb->RestartArea->CurrentLsn = NextLsn; Lfcb->RestartArea->LastLsnDataLength = OriginalLogBytes; ClearFlag( Lfcb->Flags, LFCB_NO_LAST_LSN ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( -1, Dbg, "LfsWriteLogRecordIntoLogPage: Exit\n", 0 ); return LogFileFull; }

---