lfs.h File Reference

Go to the source code of this file.

Classes
struct	_MULTI_SECTOR_HEADER
struct	_LFS_WRITE_DATA
struct	_LFS_WRITE_ENTRY
struct	_LOG_FILE_INFORMATION
Defines
#define	SEQUENCE_NUMBER_STRIDE   (512)
#define	LFS_DEFAULT_LOG_PAGE_SIZE   (0x1000)
Typedefs
typedef USHORT	UPDATE_SEQUENCE_NUMBER
typedef USHORT *	PUPDATE_SEQUENCE_NUMBER
typedef _MULTI_SECTOR_HEADER	MULTI_SECTOR_HEADER
typedef _MULTI_SECTOR_HEADER *	PMULTI_SECTOR_HEADER
typedef UPDATE_SEQUENCE_NUMBER	UPDATE_SEQUENCE_ARRAY [1]
typedef UPDATE_SEQUENCE_ARRAY *	PUPDATE_SEQUENCE_ARRAY
typedef _LFS_WRITE_DATA	LFS_WRITE_DATA
typedef _LFS_WRITE_DATA *	PLFS_WRITE_DATA
typedef LARGE_INTEGER	LSN
typedef LARGE_INTEGER *	PLSN
typedef enum _LFS_RECORD_TYPE	LFS_RECORD_TYPE
typedef enum _LFS_RECORD_TYPE *	PLFS_RECORD_TYPE
typedef enum _LFS_CONTEXT_MODE	LFS_CONTEXT_MODE
typedef enum _LFS_CONTEXT_MODE *	PLFS_CONTEXT_MODE
typedef ULONG	TRANSACTION_ID
typedef ULONG *	PTRANSACTION_ID
typedef enum _TRANSACTION_STATE	TRANSACTION_STATE
typedef enum _TRANSACTION_STATE *	PTRANSACTION_STATE
typedef enum _LFS_INFO	LFS_INFO
typedef enum _LFS_INFO *	PLFS_INFO
typedef PVOID	LFS_LOG_HANDLE
typedef PVOID *	PLFS_LOG_HANDLE
typedef PVOID	LFS_LOG_CONTEXT
typedef PVOID *	PLFS_LOG_CONTEXT
typedef _LFS_WRITE_ENTRY	LFS_WRITE_ENTRY
typedef _LFS_WRITE_ENTRY *	PLFS_WRITE_ENTRY
typedef _LOG_FILE_INFORMATION	LOG_FILE_INFORMATION
typedef _LOG_FILE_INFORMATION *	PLOG_FILE_INFORMATION
Enumerations
enum	_LFS_RECORD_TYPE { LfsClientRecord = 1, LfsClientRestart }
enum	_LFS_CONTEXT_MODE { LfsContextUndoNext = 1, LfsContextPrevious, LfsContextForward }
enum	_TRANSACTION_STATE { TransactionUninitialized = 0, TransactionActive, TransactionPrepared, TransactionCommitted }
enum	_LFS_INFO { LfsUseUsa = 1, LfsPackLog, LfsFixedPageSize }
Functions
BOOLEAN	LfsInitializeLogFileService ()
VOID	LfsInitializeLogFile (IN PFILE_OBJECT LogFile, IN USHORT MaximumClients, IN ULONG LogPageSize OPTIONAL, IN LONGLONG FileSize, OUT PLFS_WRITE_DATA WriteData)
ULONG	LfsOpenLogFile (IN PFILE_OBJECT LogFile, IN UNICODE_STRING ClientName, IN USHORT MaximumClients, IN ULONG LogPageSize OPTIONAL, IN LONGLONG FileSize, IN OUT PLFS_INFO LfsInfo, OUT PLFS_LOG_HANDLE LogHandle, OUT PLFS_WRITE_DATA WriteData)
VOID	LfsCloseLogFile (IN LFS_LOG_HANDLE LogHandle)
VOID	LfsDeleteLogHandle (IN LFS_LOG_HANDLE LogHandle)
VOID	LfsReadLogFileInformation (IN LFS_LOG_HANDLE LogHandle, IN PLOG_FILE_INFORMATION Buffer, IN OUT PULONG Length)
BOOLEAN	LfsVerifyLogFile (IN LFS_LOG_HANDLE LogHandle, IN PVOID LogFileHeader, IN ULONG Length)
NTSTATUS	LfsReadRestartArea (IN LFS_LOG_HANDLE LogHandle, IN OUT PULONG BufferLength, IN PVOID Buffer, OUT PLSN Lsn)
VOID	LfsWriteRestartArea (IN LFS_LOG_HANDLE LogHandle, IN ULONG BufferLength, IN PVOID Buffer, OUT PLSN Lsn)
VOID	LfsSetBaseLsn (IN LFS_LOG_HANDLE LogHandle, IN LSN BaseLsn)
VOID	LfsResetUndoTotal (IN LFS_LOG_HANDLE LogHandle, IN ULONG NumberRecords, IN LONG ResetTotal)
BOOLEAN	LfsWrite (IN LFS_LOG_HANDLE LogHandle, IN ULONG NumberOfWriteEntries, IN PLFS_WRITE_ENTRY WriteEntries, IN LFS_RECORD_TYPE RecordType, IN TRANSACTION_ID *TransactionId OPTIONAL, IN LSN UndoNextLsn, IN LSN PreviousLsn, IN LONG UndoRequirement, OUT PLSN Lsn)
BOOLEAN	LfsForceWrite (IN LFS_LOG_HANDLE LogHandle, IN ULONG NumberOfWriteEntries, IN PLFS_WRITE_ENTRY WriteEntries, IN LFS_RECORD_TYPE RecordType, IN TRANSACTION_ID *TransactionId OPTIONAL, IN LSN UndoNextLsn, IN LSN PreviousLsn, IN LONG UndoRequirement, OUT PLSN Lsn)
VOID	LfsFlushToLsn (IN LFS_LOG_HANDLE LogHandle, IN LSN Lsn)
VOID	LfsCheckWriteRange (IN PLFS_WRITE_DATA WriteData, IN OUT PLONGLONG FlushOffset, IN OUT PULONG FlushLength)
VOID	LfsReadLogRecord (IN LFS_LOG_HANDLE LogHandle, IN LSN FirstLsn, IN LFS_CONTEXT_MODE ContextMode, OUT PLFS_LOG_CONTEXT Context, OUT PLFS_RECORD_TYPE RecordType, OUT TRANSACTION_ID *TransactionId, OUT PLSN UndoNextLsn, OUT PLSN PreviousLsn, OUT PULONG BufferLength, OUT PVOID *Buffer)
BOOLEAN	LfsReadNextLogRecord (IN LFS_LOG_HANDLE LogHandle, IN OUT LFS_LOG_CONTEXT Context, OUT PLFS_RECORD_TYPE RecordType, OUT TRANSACTION_ID *TransactionId, OUT PLSN UndoNextLsn, OUT PLSN PreviousLsn, OUT PLSN Lsn, OUT PULONG BufferLength, OUT PVOID *Buffer)
VOID	LfsTerminateLogQuery (IN LFS_LOG_HANDLE LogHandle, IN LFS_LOG_CONTEXT Context)
LSN	LfsQueryLastLsn (IN LFS_LOG_HANDLE LogHandle)
Variables
LSN	LfsZeroLsn

---

Define Documentation

#define LFS_DEFAULT_LOG_PAGE_SIZE   (0x1000)

Definition at line 153 of file lfs.h. Referenced by LfsInitializeLogFile(), LfsNormalizeBasicLogFile(), and LfsRestartLogFile().

#define SEQUENCE_NUMBER_STRIDE   (512)

Definition at line 73 of file lfs.h. Referenced by LfsIsRestartPageHeaderValid(), and LfsReadRestart().

---

Typedef Documentation

typedef enum _LFS_CONTEXT_MODE LFS_CONTEXT_MODE

typedef enum _LFS_INFO LFS_INFO

typedef PVOID LFS_LOG_CONTEXT

Definition at line 199 of file lfs.h.

typedef PVOID LFS_LOG_HANDLE

Definition at line 197 of file lfs.h. Referenced by LfsOpenLogFile().

typedef enum _LFS_RECORD_TYPE LFS_RECORD_TYPE

typedef struct _LFS_WRITE_DATA LFS_WRITE_DATA

typedef struct _LFS_WRITE_ENTRY LFS_WRITE_ENTRY

typedef struct _LOG_FILE_INFORMATION LOG_FILE_INFORMATION

typedef LARGE_INTEGER LSN

Definition at line 140 of file lfs.h. Referenced by LfsCheckSubsequentLogPage(), LfsFindClientNextLsn(), LfsFindLastLsn(), LfsFlushLbcb(), LfsFlushLfcb(), LfsIsRestartAreaValid(), LfsQueryLastLsn(), LfsRestartLogFile(), LfsSearchForwardByClient(), LfsUpdateLfcbFromNoRestart(), LfsUpdateLfcbFromRestart(), and LfsWriteLogRecordIntoLogPage().

typedef struct _MULTI_SECTOR_HEADER MULTI_SECTOR_HEADER

typedef enum _LFS_CONTEXT_MODE * PLFS_CONTEXT_MODE

typedef enum _LFS_INFO * PLFS_INFO

typedef PVOID * PLFS_LOG_CONTEXT

Definition at line 199 of file lfs.h.

typedef PVOID * PLFS_LOG_HANDLE

Definition at line 197 of file lfs.h.

typedef enum _LFS_RECORD_TYPE * PLFS_RECORD_TYPE

typedef struct _LFS_WRITE_DATA * PLFS_WRITE_DATA

typedef struct _LFS_WRITE_ENTRY * PLFS_WRITE_ENTRY

Referenced by LfsWrite().

typedef struct _LOG_FILE_INFORMATION * PLOG_FILE_INFORMATION

typedef LARGE_INTEGER * PLSN

Definition at line 140 of file lfs.h. Referenced by LfsFlushLbcb(), and LfsReadRestart().

typedef struct _MULTI_SECTOR_HEADER * PMULTI_SECTOR_HEADER

typedef ULONG * PTRANSACTION_ID

Definition at line 178 of file lfs.h.

typedef enum _TRANSACTION_STATE * PTRANSACTION_STATE

typedef UPDATE_SEQUENCE_ARRAY* PUPDATE_SEQUENCE_ARRAY

Definition at line 117 of file lfs.h.

typedef USHORT * PUPDATE_SEQUENCE_NUMBER

Definition at line 75 of file lfs.h.

typedef ULONG TRANSACTION_ID

Definition at line 178 of file lfs.h.

typedef enum _TRANSACTION_STATE TRANSACTION_STATE

typedef UPDATE_SEQUENCE_NUMBER UPDATE_SEQUENCE_ARRAY[1]

Definition at line 115 of file lfs.h.

typedef USHORT UPDATE_SEQUENCE_NUMBER

Definition at line 75 of file lfs.h. Referenced by LfsIsRestartPageHeaderValid(), LfsUpdateLfcbFromNoRestart(), and LfsUpdateLfcbFromRestart().

---

Enumeration Type Documentation

enum _LFS_CONTEXT_MODE

Enumeration values: LfsContextUndoNext  LfsContextPrevious  LfsContextForward  Definition at line 170 of file lfs.h. { LfsContextUndoNext = 1, LfsContextPrevious, LfsContextForward } LFS_CONTEXT_MODE, *PLFS_CONTEXT_MODE;

enum _LFS_INFO

Enumeration values: LfsUseUsa  LfsPackLog  LfsFixedPageSize  Definition at line 189 of file lfs.h. { LfsUseUsa = 1, LfsPackLog, LfsFixedPageSize } LFS_INFO, *PLFS_INFO;

enum _LFS_RECORD_TYPE

Enumeration values: LfsClientRecord  LfsClientRestart  Definition at line 159 of file lfs.h. { LfsClientRecord = 1, LfsClientRestart } LFS_RECORD_TYPE, *PLFS_RECORD_TYPE;

enum _TRANSACTION_STATE

Enumeration values: TransactionUninitialized  TransactionActive  TransactionPrepared  TransactionCommitted  Definition at line 180 of file lfs.h. { TransactionUninitialized = 0, TransactionActive, TransactionPrepared, TransactionCommitted } TRANSACTION_STATE, *PTRANSACTION_STATE;

---

Function Documentation

VOID LfsCheckWriteRange (  IN PLFS_WRITE_DATA  WriteData, IN OUT PLONGLONG  FlushOffset, IN OUT PULONG  FlushLength )

Definition at line 477 of file lfs/write.c. References _LBCB::FileOffset, LFS_SIGNATURE_RECORD_PAGE_ULONG, NULL, PAGE_SIZE, PAGED_CODE, _LBCB::PageHeader, _LFCB::PageToDirty, and _LFCB::SystemPageSize. : This routine is called Ntfs to Lfs when a flush occurs. This will give Lfs a chance to trim the amount of the flush. Lfs can then use a 4K log record page size for all systems (Intel and Alpha). This routine will trim the size of the IO request to the value stored in the Lfcb for this volume. We will also redirty the second half of the page if we have begun writing log records into it. Arguments: WriteData - This is the data in the user's data structure which is maintained by Lfs to describe the current writes. FlushOffset - On input this is the start of the flush passed to Ntfs from MM. On output this is the start of the actual range to flush. FlushLength - On input this is the length of the flush from the given FlushOffset. On output this is the length of the flush from the possibly modified FlushOffset. Return Value: None --*/ { PLIST_ENTRY Links; PLFCB Lfcb; PLFCB NextLfcb; PAGED_CODE(); // // Find the correct Lfcb for this request. // Lfcb = WriteData->Lfcb; // // Trim the write if not a system page size. // if (PAGE_SIZE != Lfcb->SystemPageSize) { // // Check if we are trimming before the write. // if (*FlushOffset < WriteData->FileOffset) { *FlushLength -= (ULONG) (WriteData->FileOffset - *FlushOffset); *FlushOffset = WriteData->FileOffset; } // // Check that we aren't flushing too much. // if (*FlushOffset + *FlushLength > WriteData->FileOffset + WriteData->Length) { *FlushLength = (ULONG) (WriteData->FileOffset + WriteData->Length - *FlushOffset); } // // Finally check if we have to redirty a page. // if ((Lfcb->PageToDirty != NULL) && (*FlushLength + *FlushOffset == Lfcb->PageToDirty->FileOffset)) { *((PULONG) (Lfcb->PageToDirty->PageHeader)) = LFS_SIGNATURE_RECORD_PAGE_ULONG; } } return; }

VOID LfsCloseLogFile (  IN LFS_LOG_HANDLE  LogHandle  )

Definition at line 706 of file lfs/registry.c. References _LBCB::ActiveLinks, Add2Ptr, CcUnpinDataForThread(), ClearFlag, _LFCB::ClientArray, _LCH::ClientArrayByteOffset, _LFS_RESTART_AREA::ClientFreeList, _LCH::ClientId, _LFS_CLIENT_ID::ClientIndex, _LFS_RESTART_AREA::ClientInUseList, _LFS_CLIENT_RECORD::ClientRestartLsn, Dbg, DebugTrace, DebugUnwind, _LFCB_SYNC::Event, Executive, FALSE, FlagOn, _LFCB::Flags, KernelMode, KeWaitForSingleObject(), LBCB_NOT_EMPTY, LBCB_ON_ACTIVE_QUEUE, _LFCB::LbcbActive, _LBCB::LbcbFlags, _LFCB::LbcbWorkque, _LCH::LchLinks, _LCH::Lfcb, LFCB_FINAL_SHUTDOWN, _LFCB::LfcbLinks, LFS_NO_CLIENT, LfsAcquireLch, LfsAcquireLfcb, LfsAcquireLfsData, LfsAddClientToList(), LfsCloseLogFile(), LfsDeallocateLbcb(), LfsDeallocateLfcb(), LfsExceptionFilter(), _LFCB::LfsIoState, LfsLbcbIsRestart, LfsNoIoInProgress, LfsReleaseLch, LfsReleaseLfcb, LfsReleaseLfsData, LfsRemoveClientFromList(), LfsValidateClientId, LfsValidateLch, LfsWriteLfsRestart(), LfsZeroLsn, _LBCB::LogPageBcb, NTSTATUS(), NULL, PAGED_CODE, _LBCB::ResourceThread, _LFCB::RestartArea, _LFCB::RestartAreaSize, _LFS_CLIENT_RECORD::SeqNumber, SetFlag, Status, _LFCB::Sync, TRUE, try_return, USHORT, _LFCB::Waiters, and _LBCB::WorkqueLinks. Referenced by LfsCloseLogFile(). : This routine is called when a client detaches itself from the log file. On return, all prior references to this client in the log file are inaccessible. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLCH Lch; PLFCB Lfcb; USHORT ClientIndex; PLFS_CLIENT_RECORD ClientRecord; BOOLEAN FlushRestart; BOOLEAN ExitLoop; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsCloseLogFile: Entered\n", 0 ); DebugTrace( 0, Dbg, "LogHandle -> %08lx\n", LogHandle ); Lch = (PLCH) LogHandle; // // Enclose this in a loop. We will loop as long as there are waiters or there is an IO // in progress. // while (TRUE) { // // Always assume we exit the loop. // ExitLoop = TRUE; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Protect this entry point with a try-except. // try { // // Use a try-finally to facilitate cleanup. // // // Acquire the global data block and the log file control block. // LfsAcquireLfsData(); try { PLBCB ThisLbcb; LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then return immediately. // if (Lfcb == NULL) { try_return( NOTHING ); } // // Check that there are no waiters or IO in progress before proceeding. // if ((Lfcb->Waiters != 0) || (Lfcb->LfsIoState != LfsNoIoInProgress)) { ExitLoop = FALSE; Lfcb->Waiters += 1; try_return( NOTHING ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); ClientRecord = Add2Ptr( Lfcb->ClientArray, Lch->ClientArrayByteOffset, PLFS_CLIENT_RECORD ); #if 1 // // Increment the client sequence number in the restart area. // This will prevent anyone else from accessing this client block. // ClientIndex = Lch->ClientId.ClientIndex; ClientRecord->SeqNumber++; #endif // // Remember if this client wrote a restart area. // FlushRestart = (BOOLEAN) ( LfsZeroLsn.QuadPart != ClientRecord->ClientRestartLsn.QuadPart ); #if 1 // // Remove the client from the log file in use list. // LfsRemoveClientFromList( Lfcb->ClientArray, ClientRecord, &Lfcb->RestartArea->ClientInUseList ); // // Add the client block to the log file free list // LfsAddClientToList( Lfcb->ClientArray, ClientIndex, &Lfcb->RestartArea->ClientFreeList ); // // If this is the last client then move the last active Lbcb off // the active queue. // if (Lfcb->RestartArea->ClientInUseList == LFS_NO_CLIENT) { #endif // // Set the flag to indicate we are at the final close. // SetFlag( Lfcb->Flags, LFCB_FINAL_SHUTDOWN ); // // Walk through the active queue and remove any Lbcb's with // data from that queue. That will allow them to get out to disk. // while (!IsListEmpty( &Lfcb->LbcbActive )) { ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); RemoveEntryList( &ThisLbcb->ActiveLinks ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); // // If this page has some new entries, allow it to // be flushed to disk. Otherwise deallocate it. // if (!FlagOn( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY )) { RemoveEntryList( &ThisLbcb->WorkqueLinks ); if (ThisLbcb->LogPageBcb != NULL) { CcUnpinDataForThread( ThisLbcb->LogPageBcb, ThisLbcb->ResourceThread ); } LfsDeallocateLbcb( Lfcb, ThisLbcb ); } } // // It's possible that we have the two restart areas in the workque. // They can be removed and the memory deallocated if we have no // more clients. // // We skip this action if the there is Io in progress or the user // had a restart area. // if ((Lfcb->LfsIoState == LfsNoIoInProgress) && !FlushRestart) { PLIST_ENTRY Links; // // Now walk through the workque list looking for a non-restart // entry. // Links = Lfcb->LbcbWorkque.Flink; while (Links != &Lfcb->LbcbWorkque) { ThisLbcb = CONTAINING_RECORD( Links, LBCB, WorkqueLinks ); // // If this is not a restart area, we exit and remember that // we need to flush the restart areas. // if (!LfsLbcbIsRestart( ThisLbcb )) { FlushRestart = TRUE; break; } Links = Links->Flink; } // // If we are still not to flush the restart areas remove // all of the restart areas from the queue. // if (!FlushRestart) { while (!IsListEmpty( &Lfcb->LbcbWorkque)) { ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbWorkque.Blink, LBCB, WorkqueLinks ); RemoveEntryList( &ThisLbcb->WorkqueLinks ); LfsDeallocateLbcb( Lfcb, ThisLbcb ); } } } else { FlushRestart = TRUE; } #if 1 // // We will have to flush the restart area in this case. // } else { FlushRestart = TRUE; } #endif // // Flush the new restart area if we need to. // if (FlushRestart) { LfsWriteLfsRestart( Lfcb, Lfcb->RestartAreaSize, FALSE ); LfsWriteLfsRestart( Lfcb, Lfcb->RestartAreaSize, TRUE ); } // // Clear the Lfcb pointer in the client handle. // Lch->Lfcb = NULL; RemoveEntryList( &Lch->LchLinks ); // // If there are no active clients, we can remove this log file // control block from the active queue. // #if 1 if (Lfcb->RestartArea->ClientInUseList == LFS_NO_CLIENT) { #endif RemoveEntryList( &Lfcb->LfcbLinks ); LfsDeallocateLfcb( Lfcb, FALSE ); #if 1 } #endif try_exit: NOTHING; } finally { DebugUnwind( LfsCloseLogFile ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); // // Release the global data block if held. // LfsReleaseLfsData(); DebugTrace( -1, Dbg, "LfsCloseLogFile: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } // // Test if we want to exit the loop now. // if (ExitLoop) { break; } // // Wait for the io to complete. // KeWaitForSingleObject( &Lfcb->Sync->Event, Executive, KernelMode, FALSE, NULL ); LfsAcquireLfcb( Lfcb ); Lfcb->Waiters -= 1; LfsReleaseLfcb( Lfcb ); } // // We always let this operation succeed. // return; }

VOID LfsDeleteLogHandle (  IN LFS_LOG_HANDLE  LogHandle  )

Definition at line 1063 of file lfs/registry.c. References ExDeleteResource, ExFreePool(), LFS_NTC_LCH, LfsAcquireLch, LfsDeallocateLch, LfsExceptionFilter(), LfsReleaseLch, _LCH::NodeTypeCode, NULL, PAGED_CODE, _LFCB_SYNC::Resource, _LCH::Sync, and _LFCB_SYNC::UserCount. : This routine is called when a client is tearing down the last of his volume structures. There will be no more references to this handle. If it is the last handle for the log file then we will deallocate the Sync structure as well. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Return Value: None --*/ { PLCH Lch; PAGED_CODE(); // // If the log handle is null then return immediately. // Lch = (PLCH) LogHandle; if ((Lch == NULL) || (Lch->NodeTypeCode != LFS_NTC_LCH)) { return; } // // Ignore all errors from now on. // try { LfsAcquireLch( Lch ); Lch->Sync->UserCount -= 1; // // If we are the last user then deallocate the sync structure. // if (Lch->Sync->UserCount == 0) { ExDeleteResource( &Lch->Sync->Resource ); ExFreePool( Lch->Sync ); } else { LfsReleaseLch( Lch ); } LfsDeallocateLch( Lch ); } except (LfsExceptionFilter( GetExceptionInformation() )) { NOTHING; } return; }

VOID LfsFlushToLsn (  IN LFS_LOG_HANDLE  LogHandle, IN LSN  Lsn )

Definition at line 360 of file lfs/write.c. References Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), _LCH::Lfcb, LfsAcquireLch, LfsExceptionFilter(), LfsFlushToLsn(), LfsFlushToLsnPriv(), LfsReleaseLch, LfsValidateClientId, LfsValidateLch, NTSTATUS(), NULL, PAGED_CODE, and Status. Referenced by LfsFlushToLsn(). : This routine is called by a client to insure that all log records to a certain point have been flushed to the file. This is done by checking if the desired Lsn has even been written at all. If so we check if it has been flushed to the file. If not, we simply write the current restart area to the disk. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Lsn - This is the Lsn that must be on the disk on return from this routine. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLCH Lch; PLFCB Lfcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushToLsn: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn.LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn.HighPart ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the log file has been closed we will assume the Lsn has been flushed. // if (Lfcb != NULL) { // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Call our common routine to perform the work. // LfsFlushToLsnPriv( Lfcb, Lsn ); } } finally { DebugUnwind( LfsFlushToLsn ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( -1, Dbg, "LfsFlushToLsn: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return; }

BOOLEAN LfsForceWrite (  IN LFS_LOG_HANDLE  LogHandle, IN ULONG  NumberOfWriteEntries, IN PLFS_WRITE_ENTRY  WriteEntries, IN LFS_RECORD_TYPE  RecordType, IN TRANSACTION_ID *TransactionId  OPTIONAL, IN LSN  UndoNextLsn, IN LSN  PreviousLsn, IN LONG  UndoRequirement, OUT PLSN  Lsn )

Referenced by LfsForceWrite().

VOID LfsInitializeLogFile (  IN PFILE_OBJECT  LogFile, IN USHORT  MaximumClients, IN ULONG LogPageSize  OPTIONAL, IN LONGLONG  FileSize, OUT PLFS_WRITE_DATA  WriteData )

Definition at line 150 of file lfs/registry.c. References Add2Ptr, CcSetAdditionalCacheAttributes(), _LFCB::ClientArray, _LFCB::ClientArrayOffset, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, _LFCB::FileObject, _LFCB::FirstLogPage, _LFCB::InitialRestartArea, KeQuerySystemTime(), _LFS_DATA::LfcbLinks, _LFCB::LfcbLinks, LFS_DEFAULT_LOG_PAGE_SIZE, LfsAcquireLfcb, LfsAcquireLfsData, LfsAllocateLfcb(), LfsAllocateRestartArea, LfsData, LfsDeallocateLfcb(), LfsDeallocateRestartArea, LfsExceptionFilter(), LfsInitializeLogFile(), LfsInitializeLogFilePriv(), LfsLi0, LfsNormalizeBasicLogFile(), LfsReleaseLfcb, LfsReleaseLfsData, _LFS_WRITE_DATA::LfsStructureSize, LfsUpdateLfcbFromNoRestart(), LfsUpdateLfcbFromPgHeader(), LfsUpdateRestartAreaFromLfcb(), NTSTATUS(), NULL, PAGE_SIZE, PAGED_CODE, _LFCB::RestartArea, _LFCB::RestartDataSize, Status, TRUE, and _LFCB::UserWriteData. Referenced by LfsInitializeLogFile(). : This routine is called to initialize a log file to prepare it for use by log clients. Any previous data in the file will be overwritten. Lfs will partition the file into 2 Lfs restart areas and as many log pages as will fit in the file. The restart area size is determined by computing the amount of space needed for the maximum number Arguments: LogFile - This is the file object for the file to be used as a log file. MaximumClients - This is the maximum number of clients that will be active in the log file at any one time. LogPageSize - If specified (not 0), this is the recommended size of the log page. Lfs will use this as a guide in determining the log page size. FileSize - This is the available size of the log file. WriteData - Pointer to WRITE_DATA in caller's data structure. Return Value: None --*/ { PLFCB Lfcb; LARGE_INTEGER CurrentTime; PLFS_RESTART_AREA RestartArea = NULL; volatile NTSTATUS Status = STATUS_SUCCESS; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsInitializeLogFile: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log File -> %08lx\n", LogFile ); DebugTrace( 0, Dbg, "Maximum Clients -> %04x\n", MaximumClients ); DebugTrace( 0, Dbg, "Log Page Size -> %08lx\n", LogPageSize ); DebugTrace( 0, Dbg, "File Size (Low) -> %08lx\n", FileSize.LowPart ); DebugTrace( 0, Dbg, "File Size (High) -> %08lx\n", FileSize.HighPart ); Lfcb = NULL; // // Protect this entry point with a try-except. // try { // // We grab the global data exclusively. // LfsAcquireLfsData(); // // Use a try-finally to facilitate cleanup. // try { // // We allocate an Lfcb and point it to the log file. // Lfcb = LfsAllocateLfcb(); LfsAcquireLfcb( Lfcb ); Lfcb->FileObject = LogFile; // // Call the Cache Manager to disable read ahead and write behind; // we flush the log file explicitly. // CcSetAdditionalCacheAttributes( LogFile, TRUE, TRUE ); // // Normalize the values passed in with this call. // LfsNormalizeBasicLogFile( &FileSize, &LogPageSize, &MaximumClients, (BOOLEAN) ((PAGE_SIZE >= LFS_DEFAULT_LOG_PAGE_SIZE) && (PAGE_SIZE <= LFS_DEFAULT_LOG_PAGE_SIZE * 2))); // // We can go directly to version 1.1 since we can immediately pack // the log file and use the default system log page size. // LfsUpdateLfcbFromPgHeader( Lfcb, LogPageSize, LogPageSize, 1, 1, TRUE ); KeQuerySystemTime( &CurrentTime ); LfsUpdateLfcbFromNoRestart( Lfcb, FileSize, LfsLi0, MaximumClients, CurrentTime.LowPart, FALSE, FALSE ); LfsAllocateRestartArea( &RestartArea, Lfcb->RestartDataSize ); LfsUpdateRestartAreaFromLfcb( Lfcb, RestartArea ); Lfcb->RestartArea = RestartArea; Lfcb->ClientArray = Add2Ptr( RestartArea, Lfcb->ClientArrayOffset, PLFS_CLIENT_RECORD ); RestartArea = NULL; Lfcb->InitialRestartArea = TRUE; // // Now update the caller's WRITE_DATA structure. // Lfcb->UserWriteData = WriteData; WriteData->LfsStructureSize = LogPageSize; WriteData->Lfcb = Lfcb; // // Force two restart areas to disk and reinitialize the file. // LfsInitializeLogFilePriv( Lfcb, TRUE, Lfcb->RestartDataSize, Lfcb->FirstLogPage, TRUE ); // // Put the Lfcb into the global queue. // InsertHeadList( &LfsData.LfcbLinks, &Lfcb->LfcbLinks ); } finally { DebugUnwind( LfsInitializeLogFile ); // // If the Lfcb has been acquired, we release it now. // if (Lfcb != NULL) { LfsReleaseLfcb( Lfcb ); // // If an error occurred and we allocated an Lfcb. We deallocate // it now. // if (AbnormalTermination()) { LfsDeallocateLfcb( Lfcb, TRUE ); } } // // Deallocate the restart area. // if (RestartArea != NULL) { LfsDeallocateRestartArea( RestartArea ); } // // We release the global data. // LfsReleaseLfsData(); DebugTrace( -1, Dbg, "LfsInitializeLogFile: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return; }

BOOLEAN LfsInitializeLogFileService (   )

Definition at line 40 of file sysinit.c. References _LFS_DATA::Buffer1, _LFS_DATA::Buffer2, _LFS_DATA::BufferLock, _LFS_DATA::BufferNotification, ClearFlag, Dbg, DebugTrace, ExInitializeFastMutex, FALSE, FlagOn, _LFS_DATA::Flags, KeInitializeEvent, KeQuerySystemTime(), _LFS_DATA::LfcbLinks, LFS_BUFFER_SIZE, LFS_DATA, LFS_DATA_INIT_FAILED, LFS_DATA_INITIALIZED, LFS_NTC_DATA, LfsAllocatePoolNoRaise, LfsData, _LFS_DATA::LfsDataLock, LfsFreePool, LfsUsaSeqNumber, _LFS_DATA::NodeByteSize, _LFS_DATA::NodeTypeCode, NULL, PAGED_CODE, PagedPool, SetFlag, TRUE, and USHORT. 00045 : 00046 00047 This routine must be called during system initialization before the 00048 first call to logging service, to allow the Log File Service to initialize 00049 its global data structures. This routine has no dependencies on other 00050 system components being initialized. 00051 00052 This routine will initialize the global structures used by the logging 00053 service and start the Lfs worker thread. 00054 00055 Arguments: 00056 00057 None 00058 00059 Return Value: 00060 00061 TRUE if initialization was successful 00062 00063 --*/ 00064 00065 { 00066 LARGE_INTEGER CurrentTime; 00067 00068 PAGED_CODE(); 00069 00070 DebugTrace( +1, Dbg, "LfsInitializeLogFileService: Enter\n", 0 ); 00071 00072 // 00073 // If the structure has already been initialized then we can return 00074 // immediately. 00075 // 00076 00077 if (LfsData.NodeTypeCode == LFS_NTC_DATA 00078 && LfsData.NodeByteSize == sizeof( LFS_DATA ) 00079 && FlagOn( LfsData.Flags, LFS_DATA_INITIALIZED )) { 00080 00081 DebugTrace( -1, Dbg, "LfsInitializeLogFileService: Exit -> %01x\n", TRUE ); 00082 00083 return TRUE; 00084 } 00085 00086 // 00087 // Zero out the structure initially. 00088 // 00089 00090 RtlZeroMemory( &LfsData, sizeof( LFS_DATA )); 00091 00092 // 00093 // Assume the operation will fail. 00094 // 00095 00096 LfsData.Flags = LFS_DATA_INIT_FAILED; 00097 00098 // 00099 // Initialize the global structure for Lfs. 00100 // 00101 00102 LfsData.NodeTypeCode = LFS_NTC_DATA; 00103 LfsData.NodeByteSize = sizeof( LFS_DATA ); 00104 00105 InitializeListHead( &LfsData.LfcbLinks ); 00106 00107 // 00108 // Initialize the synchronization objects. 00109 // 00110 00111 ExInitializeFastMutex( &LfsData.LfsDataLock ); 00112 00113 // 00114 // Initialize the buffer allocation. System will be robust enough to tolerate 00115 // allocation failures. 00116 // 00117 00118 ExInitializeFastMutex( &LfsData.BufferLock ); 00119 KeInitializeEvent( &LfsData.BufferNotification, NotificationEvent, TRUE ); 00120 LfsData.Buffer1 = LfsAllocatePoolNoRaise( PagedPool, LFS_BUFFER_SIZE ); 00121 00122 if (LfsData.Buffer1 == NULL) { 00123 00124 return FALSE; 00125 } 00126 00127 LfsData.Buffer2 = LfsAllocatePoolNoRaise( PagedPool, LFS_BUFFER_SIZE ); 00128 00129 // 00130 // Make sure we got both. 00131 // 00132 00133 if (LfsData.Buffer2 == NULL) { 00134 00135 LfsFreePool( LfsData.Buffer1 ); 00136 LfsData.Buffer1 = NULL; 00137 return FALSE; 00138 } 00139 00140 // 00141 // Initialization has been successful. 00142 // 00143 00144 ClearFlag( LfsData.Flags, LFS_DATA_INIT_FAILED ); 00145 SetFlag( LfsData.Flags, LFS_DATA_INITIALIZED ); 00146 00147 // 00148 // Get a random number as a seed for the Usa sequence numbers. Use the lower 00149 // bits of the current time. 00150 // 00151 00152 KeQuerySystemTime( &CurrentTime ); 00153 LfsUsaSeqNumber = (USHORT) CurrentTime.LowPart; 00154 00155 DebugTrace( -1, Dbg, "LfsInitializeLogFileService: Exit -> %01x\n", TRUE ); 00156 00157 return TRUE; 00158 } }

ULONG LfsOpenLogFile (  IN PFILE_OBJECT  LogFile, IN UNICODE_STRING  ClientName, IN USHORT  MaximumClients, IN ULONG LogPageSize  OPTIONAL, IN LONGLONG  FileSize, IN OUT PLFS_INFO  LfsInfo, OUT PLFS_LOG_HANDLE  LogHandle, OUT PLFS_WRITE_DATA  WriteData )

Definition at line 366 of file lfs/registry.c. References CcSetAdditionalCacheAttributes(), _LFCB::ClientArray, _LCH::ClientArrayByteOffset, _LFS_RESTART_AREA::ClientFreeList, _LCH::ClientId, _LFS_CLIENT_ID::ClientIndex, _LFS_RESTART_AREA::ClientInUseList, _LFS_CLIENT_RECORD::ClientName, _LFS_CLIENT_RECORD::ClientNameLength, _LFS_CLIENT_RECORD::ClientRestartLsn, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), _LFCB::FileObject, FlagOn, _LFCB::Flags, _LFCB::LchLinks, _LCH::LchLinks, _LCH::Lfcb, LFCB_LOG_FILE_CORRUPT, LFCB_PACK_LOG, _LFS_DATA::LfcbLinks, _LFCB::LfcbLinks, LFS_CLIENT_NAME_MAX, LFS_LOG_HANDLE, LFS_NO_CLIENT, LfsAcquireLfsData, LfsAddClientToList(), LfsAllocateLch, LfsData, LfsDeallocateLch, LfsDeallocateLfcb(), LfsExceptionFilter(), LfsOpenLogFile(), LfsReleaseLfcb, LfsReleaseLfsData, LfsRemoveClientFromList(), LfsRestartLogFile(), LfsZeroLsn, _LFS_CLIENT_RECORD::NextClient, NTSTATUS(), NULL, _LFS_CLIENT_RECORD::OldestLsn, _LFCB::OldestLsn, PAGED_CODE, PtrOffset, _LFCB::RecordHeaderLength, _LFCB::RestartArea, _LFS_CLIENT_ID::SeqNumber, _LFS_CLIENT_RECORD::SeqNumber, Status, _LCH::Sync, _LFCB::Sync, TRUE, _LFCB_SYNC::UserCount, and USHORT. Referenced by LfsOpenLogFile(). : This routine is called when a client wishes to register with logging service. This can be a reregistration (i.e. restart after a crash) or an initial registration. There can be no other active clients with the same name. The Log Handle returned is then used for any subsequent access by this client. If an Lfs restart has not been done on the log file, it will be done at this time. Arguments: LogFile - A file object for a file previously initialized for use as a log file. ClientName - This unicode string is used to uniquely identify clients of the logging service. A case-sensitive comparison is used to check this name against active clients of the log file. MaximumClients - The maximum number of clients if the log file has never been initialized. LogPageSize - This is the recommeded size for the log page. FileSize - This is the size of the log file. LfsInfo - On entry, indicates the log file state the user may know about. On exit, indicates the log file state that Lfs knows about. This is a conduit for Lfs to communicate with its clients. LogHandle - The address to store the identifier the logging service will use to identify this client in all other Lfs calls. WriteData - Pointer to WRITE_DATA in caller's data structure. Return Value: ULONG - Amount to add to reservation value for header for log record. --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLIST_ENTRY Link; PLFCB ThisLfcb = NULL; PLFCB NewLfcb = NULL; USHORT ThisClient; PLFS_CLIENT_RECORD ClientRecord; PLCH Lch = NULL; ULONG ReservedHeader; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsOpenLogFile: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log File -> %08lx\n", LogFile ); DebugTrace( 0, Dbg, "Client Name -> %08lx\n", &ClientName ); DebugTrace( 0, Dbg, "Maximum Clients -> %04x\n", MaximumClients ); DebugTrace( 0, Dbg, "Log Page Size -> %08lx\n", LogPageSize ); DebugTrace( 0, Dbg, "File Size (Low) -> %08lx\n", FileSize.LowPart ); DebugTrace( 0, Dbg, "File Size (High) -> %08lx\n", FileSize.HighPart ); // // Check that the client name length is a legal length. // if (ClientName.Length > LFS_CLIENT_NAME_MAX) { DebugTrace( 0, Dbg, "Illegal name length for client\n", 0 ); DebugTrace( -1, Dbg, "LfsOpenLogFile: Exit\n", 0 ); ExRaiseStatus( STATUS_INVALID_PARAMETER ); } // // Protect this call with a try-except. // try { // // Aqcuire the global data. // LfsAcquireLfsData(); // // Use a try-finally to facilitate cleanup. // try { // // Walk through the list searching for this file object. // Link = LfsData.LfcbLinks.Flink; while (Link != &LfsData.LfcbLinks) { ThisLfcb = CONTAINING_RECORD( Link, LFCB, LfcbLinks ); if (ThisLfcb->FileObject == LogFile) { DebugTrace( 0, Dbg, "Found matching log file\n", 0 ); break; } Link = Link->Flink; } // // If the log file doesn't exist, create an Lfcb and perform an // Lfs restart. // if (Link == &LfsData.LfcbLinks) { // // Call the Cache Manager to disable read ahead and write behind; // we flush the log file explicitly. // CcSetAdditionalCacheAttributes( LogFile, TRUE, TRUE ); // // Perform Lfs restart on this file object. // ThisLfcb = NewLfcb = LfsRestartLogFile( LogFile, MaximumClients, 0, FileSize, LfsInfo, WriteData ); // // Insert this Lfcb into the global list. // InsertHeadList( &LfsData.LfcbLinks, &ThisLfcb->LfcbLinks ); } // // At this point we have the log file control block for the file // object given us. We first check whether the log file is fatally // corrupt. // if (FlagOn( ThisLfcb->Flags, LFCB_LOG_FILE_CORRUPT )) { // // We leave the in-memory data alone and raise an error if // anyone attempts to access this file. // DebugTrace( 0, Dbg, "The Lfcb is corrupt\n", 0 ); ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } // // Search through and look for a client match. // ThisClient = ThisLfcb->RestartArea->ClientInUseList; while (ThisClient != LFS_NO_CLIENT) { ClientRecord = ThisLfcb->ClientArray + ThisClient; if (ClientRecord->ClientNameLength == (ULONG) ClientName.Length && RtlCompareMemory( ClientRecord->ClientName, ClientName.Buffer, ClientName.Length ) == (ULONG) ClientName.Length) { DebugTrace( 0, Dbg, "Matching client name found\n", 0 ); break; } ThisClient = ClientRecord->NextClient; } // // Allocate an Lch structure and link it into the Lfcb. // LfsAllocateLch( &Lch ); InsertTailList( &ThisLfcb->LchLinks, &Lch->LchLinks ); // // Initialize the client handle with the data from the Lfcb. // Lch->Lfcb = ThisLfcb; Lch->Sync = ThisLfcb->Sync; Lch->Sync->UserCount += 1; // // If a match isn't found, take a client block off the free list // if available. // if (ThisClient == LFS_NO_CLIENT) { // // Raise an error status if out of client blocks. // ThisClient = ThisLfcb->RestartArea->ClientFreeList; if (ThisClient == LFS_NO_CLIENT) { DebugTrace( 0, Dbg, "No free client records available\n", 0 ); ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // Initialize the client block. // ClientRecord = ThisLfcb->ClientArray + ThisClient; LfsRemoveClientFromList( ThisLfcb->ClientArray, ClientRecord, &ThisLfcb->RestartArea->ClientFreeList ); ClientRecord->ClientRestartLsn = LfsZeroLsn; ClientRecord->OldestLsn = ThisLfcb->OldestLsn; ClientRecord->ClientNameLength = ClientName.Length; RtlCopyMemory( ClientRecord->ClientName, ClientName.Buffer, ClientName.Length ); // // Add it to the in use list. // LfsAddClientToList( ThisLfcb->ClientArray, ThisClient, &ThisLfcb->RestartArea->ClientInUseList ); } // // Update the client handle with the client block information. // Lch->ClientId.SeqNumber = ClientRecord->SeqNumber; Lch->ClientId.ClientIndex = ThisClient; Lch->ClientArrayByteOffset = PtrOffset( ThisLfcb->ClientArray, ClientRecord ); *LogHandle = (LFS_LOG_HANDLE) Lch; } finally { DebugUnwind( LfsOpenLogFile ); // // If the Lfcb has been acquired, we release it now. // if (ThisLfcb != NULL) { // // Pass information back to our caller for the number // of bytes to add to the reserved amount for a // log header. // ReservedHeader = ThisLfcb->RecordHeaderLength; if (FlagOn( ThisLfcb->Flags, LFCB_PACK_LOG )) { ReservedHeader *= 2; } LfsReleaseLfcb( ThisLfcb ); } // // If there is an error then deallocate the Lch and any new Lfcb. // if (AbnormalTermination()) { if (Lch != NULL) { LfsDeallocateLch( Lch ); ThisLfcb->Sync->UserCount -= 1; } if (NewLfcb != NULL) { LfsDeallocateLfcb( NewLfcb, TRUE ); } } // // Always free the global. // LfsReleaseLfsData(); DebugTrace( 0, Dbg, "Log Handle -> %08ln\n", *LogHandle ); DebugTrace( -1, Dbg, "LfsOpenLogFile: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return ReservedHeader; }

LSN LfsQueryLastLsn (  IN LFS_LOG_HANDLE  LogHandle  )

Definition at line 701 of file querylog.c. References _LFS_RESTART_AREA::CurrentLsn, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FlagOn, _LFCB::Flags, _LCH::Lfcb, LFCB_NO_LAST_LSN, LfsAcquireLch, LfsQueryLastLsn(), LfsReleaseLch, LfsValidateClientId, LfsValidateLch, LfsZeroLsn, LSN, NULL, PAGED_CODE, and _LFCB::RestartArea. Referenced by LfsQueryLastLsn(). : This routine will return the most recent Lsn for this log record. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Return Value: LSN - This is the last Lsn assigned in this log file. --*/ { PLCH Lch; PLFCB Lfcb; LSN LastLsn; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsQueryLastLsn: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Copy the last Lsn out of the Lfcb. If the last Lsn is // does not correspond to a log record, we will return the // zero Lsn. // if (FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN )) { LastLsn = LfsZeroLsn; } else { LastLsn = Lfcb->RestartArea->CurrentLsn; } } finally { DebugUnwind( LfsQueryLastLsn ); // // Release the Lfcb if acquired. // LfsReleaseLch( Lch ); DebugTrace( 0, Dbg, "Last Lsn (Low) -> %08lx\n", LastLsn.LowPart ); DebugTrace( 0, Dbg, "Last Lsn (High) -> %08lx\n", LastLsn.HighPart ); DebugTrace( -1, Dbg, "LfsQueryLastLsn: Exit\n", 0 ); } return LastLsn; }

VOID LfsReadLogFileInformation (  IN LFS_LOG_HANDLE  LogHandle, IN PLOG_FILE_INFORMATION  Buffer, IN OUT PULONG  Length )

Definition at line 1141 of file lfs/registry.c. References Buffer, _LOG_FILE_INFORMATION::ClientUndoCommitment, _LCH::ClientUndoCommitment, _LOG_FILE_INFORMATION::CurrentAvailable, _LFS_RESTART_AREA::CurrentLsn, Dbg, DebugTrace, DebugUnwind, _LOG_FILE_INFORMATION::LastFlushedLsn, _LFCB::LastFlushedLsn, _LOG_FILE_INFORMATION::LastLsn, _LCH::Lfcb, LfsAcquireLch, LfsCurrentAvailSpace(), LfsReadLogFileInformation(), LfsReleaseLch, LfsValidateClientId, LfsValidateLch, NULL, _LOG_FILE_INFORMATION::OldestLsn, _LFCB::OldestLsn, PAGED_CODE, _LFCB::RestartArea, _LOG_FILE_INFORMATION::TotalAvailable, _LFCB::TotalAvailable, _LOG_FILE_INFORMATION::TotalUndoCommitment, _LFCB::TotalUndoCommitment, and try_return. Referenced by LfsReadLogFileInformation(). : This routine returns information about the current state of the log file, primarily to aid the client perform its checkpoint processing. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Buffer - Pointer to buffer to return the log file information. Length - On input this is the length of the user's buffer. On output, it is the amount of data stored by the Lfs in the buffer. Return Value: None --*/ { PLCH Lch; PLFCB Lfcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsReadLogFileInformation: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", Buffer ); DebugTrace( 0, Dbg, "Length -> %08lx\n", *Length ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then return immediately. // if (Lfcb == NULL) { try_return( *Length = 0 ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // The buffer better be large enough. // if (*Length >= sizeof( LOG_FILE_INFORMATION )) { PLOG_FILE_INFORMATION Information; LONGLONG CurrentAvail; ULONG UnusedBytes; LfsCurrentAvailSpace( Lfcb, &CurrentAvail, &UnusedBytes ); // // Cast a pointer to the buffer and fill in the // data. // Information = (PLOG_FILE_INFORMATION) Buffer; Information->TotalAvailable = Lfcb->TotalAvailable; Information->CurrentAvailable = CurrentAvail; Information->TotalUndoCommitment = Lfcb->TotalUndoCommitment; Information->ClientUndoCommitment = Lch->ClientUndoCommitment; Information->OldestLsn = Lfcb->OldestLsn; Information->LastFlushedLsn = Lfcb->LastFlushedLsn; Information->LastLsn = Lfcb->RestartArea->CurrentLsn; *Length = sizeof( LOG_FILE_INFORMATION ); } else { *Length = 0; } try_exit: NOTHING; } finally { DebugUnwind( LfsReadLogFileInformation ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( -1, Dbg, "LfsReadLogFileInformation: Exit\n", 0 ); } return; }

VOID LfsReadLogRecord (  IN LFS_LOG_HANDLE  LogHandle, IN LSN  FirstLsn, IN LFS_CONTEXT_MODE  ContextMode, OUT PLFS_LOG_CONTEXT  Context, OUT PLFS_RECORD_TYPE  RecordType, OUT TRANSACTION_ID *  TransactionId, OUT PLSN  UndoNextLsn, OUT PLSN  PreviousLsn, OUT PULONG  BufferLength, OUT PVOID *  Buffer )

Definition at line 72 of file querylog.c. References Add2Ptr, Buffer, _LFCB::ClientArray, _LCH::ClientArrayByteOffset, _LCH::ClientId, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), _LCH::Lfcb, LfsAcquireLch, LfsAllocateLcb(), LfsContextForward, LfsContextPrevious, LfsContextUndoNext, LfsDeallocateLcb(), LfsExceptionFilter(), LfsFindLogRecord(), LfsInitializeLcb, LfsReadLogRecord(), LfsReleaseLch, LfsValidateClientId, LfsValidateLch, LfsVerifyClientLsnInRange, NTSTATUS(), NULL, PAGED_CODE, and Status. Referenced by LfsReadLogRecord(). : This routine initiates the query operation. It returns the log record in question and a context structure used by the Lfs to return related log records. The caller specifies what mode of query to use. He may walk backwards through the file by Undo records or all records for this client linked through the previous Lsn fields. He may also look forwards through the file for all records for the issuing client. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. FirstLsn - Starting record for this query operation. ContextMode - Method of query. Context - Supplies the address to store a pointer to the Lfs created context structure. RecordType - Supplies the address to store the record type of this log record. TransactionId - Supplies the address to store the transaction Id of this log record. UndoNextLsn - Supplies the address to store the Undo Next Lsn for this log record. PreviousLsn - Supplies the address to store the Previous Lsn for this log record. BufferLength - This is the length of the log data. Buffer - This is a pointer to the start of the log data. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLFS_CLIENT_RECORD ClientRecord; PLCH Lch; PLFCB Lfcb; PLCB Lcb = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsReadLogRecord: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "First Lsn (Low) -> %08lx\n", FirstLsn.LowPart ); DebugTrace( 0, Dbg, "First Lsn (High) -> %08lx\n", FirstLsn.HighPart ); DebugTrace( 0, Dbg, "Context Mode -> %08lx\n", ContextMode ); Lch = (PLCH) LogHandle; // // Check that the context mode is valid. // switch (ContextMode) { case LfsContextUndoNext : case LfsContextPrevious : case LfsContextForward : break; default: DebugTrace( 0, Dbg, "Invalid context mode -> %08x\n", ContextMode ); ExRaiseStatus( STATUS_INVALID_PARAMETER ); } // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Check that the given Lsn is in the legal range for this client. // ClientRecord = Add2Ptr( Lfcb->ClientArray, Lch->ClientArrayByteOffset, PLFS_CLIENT_RECORD ); if (!LfsVerifyClientLsnInRange( Lfcb, ClientRecord, FirstLsn )) { ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } // // We can give up the Lfcb as we know the Lsn is within the file. // LfsReleaseLch( Lch ); // // Allocate and initialize a context structure. // LfsAllocateLcb( Lfcb, &Lcb ); LfsInitializeLcb( Lcb, Lch->ClientId, ContextMode ); // // Find the log record indicated by the given Lsn. // LfsFindLogRecord( Lfcb, Lcb, FirstLsn, RecordType, TransactionId, UndoNextLsn, PreviousLsn, BufferLength, Buffer ); // // Update the client's arguments. // *Context = Lcb; Lcb = NULL; } finally { DebugUnwind( LfsReadLogRecord ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); // // Deallocate the context block if an error occurred. // if (Lcb != NULL) { LfsDeallocateLcb( Lfcb, Lcb ); } DebugTrace( 0, Dbg, "Context -> %08lx\n", *Context ); DebugTrace( 0, Dbg, "Buffer Length -> %08lx\n", *BufferLength ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", *Buffer ); DebugTrace( -1, Dbg, "LfsReadLogRecord: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return; }

BOOLEAN LfsReadNextLogRecord (  IN LFS_LOG_HANDLE  LogHandle, IN OUT LFS_LOG_CONTEXT  Context, OUT PLFS_RECORD_TYPE  RecordType, OUT TRANSACTION_ID *  TransactionId, OUT PLSN  UndoNextLsn, OUT PLSN  PreviousLsn, OUT PLSN  Lsn, OUT PULONG  BufferLength, OUT PVOID *  Buffer )

Definition at line 299 of file querylog.c. References _LCB::AuxilaryBuffer, Buffer, CcUnpinData(), _LCB::CurrentLogRecord, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, _LCH::Lfcb, LfsAcquireLch, LfsExceptionFilter(), LfsFindClientNextLsn(), LfsFindLogRecord(), LfsFreeSpanningBuffer(), LfsReadNextLogRecord(), LfsReleaseLch, LfsReleaseLfcb, LfsValidateClientId, LfsValidateLcb, LfsValidateLch, NTSTATUS(), NULL, PAGED_CODE, _LCB::RecordHeader, _LCB::RecordHeaderBcb, Status, and TRUE. Referenced by LfsReadNextLogRecord(). : This routine is called to continue a query operation. The Lfs uses private information stored in the context structure to determine the next log record to return to the caller. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Context - Supplies the address to store a pointer to the Lfs created context structure. Lsn - Lsn for this log record. RecordType - Supplies the address to store the record type of this log record. TransactionId - Supplies the address to store the transaction Id of this log record. UndoNextLsn - Supplies the address to store the Undo Next Lsn for this log record. PreviousLsn - Supplies the address to store the Previous Lsn for this log record. BufferLength - This is the length of the log data. Buffer - This is a pointer to the start of the log data. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLCH Lch; PLFCB Lfcb; PLCB Lcb; BOOLEAN FoundNextLsn; BOOLEAN UnwindRememberLcbFields; PBCB UnwindRecordHeaderBcb; PLFS_RECORD_HEADER UnwindRecordHeader; PVOID UnwindCurrentLogRecord; BOOLEAN UnwindAuxilaryBuffer; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsReadNextLogRecord: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Context -> %08lx\n", Context ); FoundNextLsn = FALSE; UnwindRememberLcbFields = FALSE; Lch = (PLCH) LogHandle; Lcb = (PLCB) Context; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Check that the context structure is valid. // LfsValidateLcb( Lcb, Lch ); // // Remember any context fields to be overwritten. // UnwindRememberLcbFields = TRUE; UnwindRecordHeaderBcb = Lcb->RecordHeaderBcb; Lcb->RecordHeaderBcb = NULL; UnwindRecordHeader = Lcb->RecordHeader; UnwindCurrentLogRecord = Lcb->CurrentLogRecord; UnwindAuxilaryBuffer = Lcb->AuxilaryBuffer; Lcb->AuxilaryBuffer = FALSE; // // Find the next Lsn number based on the current Lsn number in // the context block. // if (LfsFindClientNextLsn( Lfcb, Lcb, Lsn )) { // // We can give up the Lfcb as we know the Lsn is within the file. // LfsReleaseLfcb( Lfcb ); // // Cleanup the context block so we can do the next search. // Lcb->CurrentLogRecord = NULL; Lcb->AuxilaryBuffer = FALSE; // // Perform the work of getting the log record. // LfsFindLogRecord( Lfcb, Lcb, *Lsn, RecordType, TransactionId, UndoNextLsn, PreviousLsn, BufferLength, Buffer ); FoundNextLsn = TRUE; } } finally { DebugUnwind( LfsReadNextLogRecord ); // // If we exited due to an error, we have to restore the context // block. // if (UnwindRememberLcbFields) { if (AbnormalTermination()) { // // If the record header in the context block is not // the same as we started with. Then we unpin that // data. // if (Lcb->RecordHeaderBcb != NULL) { CcUnpinData( Lcb->RecordHeaderBcb ); } if (Lcb->CurrentLogRecord != NULL && Lcb->AuxilaryBuffer == TRUE) { LfsFreeSpanningBuffer( Lcb->CurrentLogRecord ); } Lcb->RecordHeaderBcb = UnwindRecordHeaderBcb; Lcb->RecordHeader = UnwindRecordHeader; Lcb->CurrentLogRecord = UnwindCurrentLogRecord; Lcb->AuxilaryBuffer = UnwindAuxilaryBuffer; // // Otherwise, if we have successfully found the next Lsn, // we free up any resources being held from the previous search. // } else if (FoundNextLsn ) { if (UnwindRecordHeaderBcb != NULL) { CcUnpinData( UnwindRecordHeaderBcb ); } if (UnwindCurrentLogRecord != NULL && UnwindAuxilaryBuffer == TRUE) { LfsFreeSpanningBuffer( UnwindCurrentLogRecord ); } // // Restore the Bcb and auxilary buffer field for the final // cleanup. // } else { if (UnwindRecordHeaderBcb != NULL) { if (Lcb->RecordHeaderBcb != NULL) { CcUnpinData( UnwindRecordHeaderBcb ); } else { Lcb->RecordHeaderBcb = UnwindRecordHeaderBcb; } } if (UnwindAuxilaryBuffer) { if (Lcb->CurrentLogRecord == UnwindCurrentLogRecord) { Lcb->AuxilaryBuffer = TRUE; } else { LfsFreeSpanningBuffer( UnwindCurrentLogRecord ); } } } } // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( 0, Dbg, "Buffer Length -> %08lx\n", *BufferLength ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", *Buffer ); DebugTrace( -1, Dbg, "LfsReadNextLogRecord: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return FoundNextLsn; }

NTSTATUS LfsReadRestartArea (  IN LFS_LOG_HANDLE  LogHandle, IN OUT PULONG  BufferLength, IN PVOID  Buffer, OUT PLSN  Lsn )

Definition at line 46 of file restart.c. References Add2Ptr, Buffer, CcUnpinData(), _LFCB::ClientArray, _LCH::ClientArrayByteOffset, _LFS_RECORD_HEADER::ClientDataLength, _LFS_CLIENT_RECORD::ClientRestartLsn, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, _LCH::Lfcb, LfsAcquireLch, LfsCopyReadLogRecord(), LfsExceptionFilter(), LfsPinOrMapLogRecordHeader(), LfsReadRestartArea(), LfsReleaseLch, LfsReleaseLfcb, LfsValidateClientId, LfsValidateLch, LfsZeroLsn, NTSTATUS(), NULL, PAGED_CODE, Status, _LFS_RECORD_HEADER::ThisLsn, and try_return. Referenced by LfsReadRestartArea(). : This routine is called by the client when he wishes to read his restart area in the log file. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. BufferLength - On entry it is the length of the user buffer. On exit it is the size of the data stored in the buffer. Buffer - Pointer to the buffer where the client restart data is to be copied. Lsn - This is the Lsn for client restart area. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; BOOLEAN UsaError; PLCH Lch; PLFS_CLIENT_RECORD ClientRecord; PLFS_RECORD_HEADER RecordHeader; PBCB RecordHeaderBcb; PLFCB Lfcb; NTSTATUS RetStatus = STATUS_SUCCESS; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsReadRestartArea: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Buffer Length -> %08lx\n", *BufferLength ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", Buffer ); RecordHeaderBcb = NULL; Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); ClientRecord = Add2Ptr( Lfcb->ClientArray, Lch->ClientArrayByteOffset, PLFS_CLIENT_RECORD ); // // If the client doesn't have a restart area, go ahead and exit // now. // if ( ClientRecord->ClientRestartLsn.QuadPart == 0 ) { //**** xxEqlZero( ClientRecord->ClientRestartLsn ) // // We show there is no restart area by returning a length // of zero. We also set the Lsn value to zero so that // we can catch it if the user tries to use the Lsn. // DebugTrace( 0, Dbg, "No client restart area exists\n", 0 ); *BufferLength = 0; *Lsn = LfsZeroLsn; try_return( NOTHING ); } // // Release the Lfcb as we won't be modifying any fields in it. // LfsReleaseLfcb( Lfcb ); // // Pin the log record for this Lsn. // LfsPinOrMapLogRecordHeader( Lfcb, ClientRecord->ClientRestartLsn, FALSE, FALSE, &UsaError, &RecordHeader, &RecordHeaderBcb ); // // If the Lsn values don't match, then the disk is corrupt. // if ( ClientRecord->ClientRestartLsn.QuadPart != RecordHeader->ThisLsn.QuadPart ) { //**** xxNeq( ClientRecord->ClientRestartLsn, RecordHeader->ThisLsn ) ExRaiseStatus( STATUS_DISK_CORRUPT_ERROR ); } // // Check that the user's buffer is big enough to hold the restart // data. We raise an error status for this error. // if (RecordHeader->ClientDataLength > *BufferLength) { DebugTrace( 0, Dbg, "Client buffer is too small\n", 0 ); *BufferLength = RecordHeader->ClientDataLength; *Lsn = LfsZeroLsn; try_return( RetStatus = STATUS_BUFFER_TOO_SMALL ); } // // Use the cache manager to copy the data into the user's buffer. // LfsCopyReadLogRecord( Lfcb, RecordHeader, Buffer ); // // Pass the length and the Lsn of the restart area back to the // caller. // *BufferLength = RecordHeader->ClientDataLength; *Lsn = RecordHeader->ThisLsn; try_exit: NOTHING; } finally { DebugUnwind( LfsReadRestartArea ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); // // Unpin the log record header for the client restart if pinned. // if (RecordHeaderBcb != NULL) { CcUnpinData( RecordHeaderBcb ); } DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( 0, Dbg, "Buffer Length -> %08lx\n", *BufferLength ); DebugTrace( -1, Dbg, "LfsReadRestartArea: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return RetStatus; }

VOID LfsResetUndoTotal (  IN LFS_LOG_HANDLE  LogHandle, IN ULONG  NumberRecords, IN LONG  ResetTotal )

Definition at line 1361 of file lfs/registry.c. References _LCH::ClientUndoCommitment, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FlagOn, _LFCB::Flags, _LCH::Lfcb, LFCB_PACK_LOG, LfsAcquireLch, LfsReleaseLch, LfsResetUndoTotal(), LfsValidateClientId, LfsValidateLch, NULL, PAGED_CODE, _LFCB::RecordHeaderLength, and _LFCB::TotalUndoCommitment. Referenced by LfsResetUndoTotal(). : This routine is called to adjust the undo commitment for this client. If the reset total is positive, then we absolutely set the reserve value for the client using this as the basis. If the value is negative, we will adjust the current value for the client. To adjust the values in the Lfcb, we first return the Undo commitment in the handle and then adjust by the values passed in. To adjust the value in the client handle, we simply set it if the reset value is positive, adjust it if the value is negative. For a packed log file we just reserve the space requested. We have already taken into account the loss of the tail of each page. For an unpacked log file we double each value. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. NumberRecords - This is the number of records we should assume the reset total covers. We allow an Lfs header for each one. ResetTotal - This is the amount to adjust (or set) the undo commitment. Return Value: None --*/ { PLCH Lch; PLFCB Lfcb; LONGLONG AdjustedUndoTotal; LONG LfsHeaderBytes; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsResetUndoTotal: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Number Records -> %08lx\n", NumberRecords ); DebugTrace( 0, Dbg, "ResetTotal -> %08lx\n", ResetTotal ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Compute the adjusted reset total. Start by computing the // bytes needed for the Lfs log headers. Add (or subtract) this // from the reset total and multiply by 2 (only if not packing the // log). // LfsHeaderBytes = NumberRecords * Lfcb->RecordHeaderLength; LfsHeaderBytes *= 2; if (!FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { ResetTotal *= 2; } // // If the reset total is positive, add the header bytes. // if (ResetTotal > 0) { // // Subtract the client's current value from the TotalUndo // commit if he is setting his value exactly. // Lfcb->TotalUndoCommitment = Lfcb->TotalUndoCommitment - Lch->ClientUndoCommitment; // // We can clear the values in the user's handle at this // time. // Lch->ClientUndoCommitment = 0; ResetTotal += LfsHeaderBytes; // // Otherwise subtract the value for the header bytes. // } else { ResetTotal -= LfsHeaderBytes; } // // Now we adjust the Lfcb and Lch values by the adjustment amount. // AdjustedUndoTotal = ResetTotal; Lfcb->TotalUndoCommitment = Lfcb->TotalUndoCommitment + AdjustedUndoTotal; Lch->ClientUndoCommitment = Lch->ClientUndoCommitment + AdjustedUndoTotal; } finally { DebugUnwind( LfsResetUndoTotal ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( -1, Dbg, "LfsResetUndoTotal: Exit\n", 0 ); } return; }

VOID LfsSetBaseLsn (  IN LFS_LOG_HANDLE  LogHandle, IN LSN  BaseLsn )

Definition at line 447 of file restart.c. References Add2Ptr, _LFCB::ClientArray, _LCH::ClientArrayByteOffset, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, _LCH::Lfcb, LfsAcquireLch, LfsExceptionFilter(), LfsReleaseLch, LfsSetBaseLsn(), LfsSetBaseLsnPriv(), LfsValidateClientId, LfsValidateLch, LfsWriteLfsRestart(), NTSTATUS(), NULL, PAGED_CODE, _LFCB::RestartAreaSize, and Status. Referenced by LfsSetBaseLsn(). : This routine is called by the client to notify the log service of the oldest Lsn he expects to need during restart. The Lfs is allowed to reuse any part of the circular log file which logically precedes this Lsn. A client may only specify a Lsn which follows the previous Lsn specified by this client. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. BaseLsn - This is the oldest Lsn the client may require during a restart. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLCH Lch; PLFCB Lfcb; PLFS_CLIENT_RECORD ClientRecord; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsSetBaseLsn: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Base Lsn (Low) -> %08lx\n", BaseLsn.LowPart ); DebugTrace( 0, Dbg, "Base Lsn (High) -> %08lx\n", BaseLsn.HighPart ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); ClientRecord = Add2Ptr( Lfcb->ClientArray, Lch->ClientArrayByteOffset, PLFS_CLIENT_RECORD ); // // We simply call the worker routine to advance the base lsn. // If we moved forward in the file, we will put our restart area in the // queue. // LfsSetBaseLsnPriv( Lfcb, ClientRecord, BaseLsn ); LfsWriteLfsRestart( Lfcb, Lfcb->RestartAreaSize, FALSE ); } finally { DebugUnwind( LfsSetBaseLsn ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( -1, Dbg, "LfsSetBaseLsn: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return; }

VOID LfsTerminateLogQuery (  IN LFS_LOG_HANDLE  LogHandle, IN LFS_LOG_CONTEXT  Context )

Definition at line 594 of file querylog.c. References Dbg, DebugTrace, DebugUnwind, _LCH::Lfcb, LfsAcquireLch, LfsDeallocateLcb(), LfsReleaseLch, LfsTerminateLogQuery(), LfsValidateClientId, LfsValidateLcb, LfsValidateLch, NULL, PAGED_CODE, and try_return. Referenced by LfsTerminateLogQuery(). : This routine is called when a client has completed his query operation and wishes to deallocate any resources acquired by the Lfs to perform the log file query. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. Context - Supplies the address to store a pointer to the Lfs created context structure. Return Value: None --*/ { PLCH Lch; PLCB Lcb; PLFCB Lfcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsTerminateLogQuery: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Context -> %08lx\n", Context ); Lch = (PLCH) LogHandle; Lcb = (PLCB) Context; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { try_return( NOTHING ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Check that the context structure is valid. // LfsValidateLcb( Lcb, Lch ); // // Deallocate the context block. // LfsDeallocateLcb( Lfcb, Lcb ); try_exit: NOTHING; } finally { DebugUnwind( LfsTerminateLogQuery ); // // Release the Lfcb if acquired. // LfsReleaseLch( Lch ); DebugTrace( -1, Dbg, "LfsTerminateLogQuery: Exit\n", 0 ); } return; }

BOOLEAN LfsVerifyLogFile (  IN LFS_LOG_HANDLE  LogHandle, IN PVOID  LogFileHeader, IN ULONG  Length )

Definition at line 1273 of file lfs/registry.c. References Add2Ptr, _LFCB::CurrentOpenLogCount, FALSE, _LCH::Lfcb, LFS_NTC_LCH, LFS_NTC_LFCB, LFS_SIGNATURE_RESTART_PAGE_ULONG, LfsAcquireLch, LfsReleaseLch, LfsReleaseLfcb, _LCH::NodeTypeCode, _LFCB::NodeTypeCode, NULL, PAGED_CODE, _LFS_RESTART_PAGE_HEADER::RestartOffset, _LFCB::SystemPageSize, and TRUE. : This routine is called by a client to verify that the volume has not been removed from the system and then reattached. We will verify the log file open count on disk matches the value in the user's handle. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. LogFileHeader - Pointer to start of log file. Length - Number bytes returned with the read. Return Value: BOOLEAN - TRUE if the log file has not been altered externally, FALSE if we fail for any reason. --*/ { BOOLEAN ValidLogFile = FALSE; PLCH Lch; PLFCB Lfcb; PLFS_RESTART_PAGE_HEADER RestartPage = LogFileHeader; PAGED_CODE(); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // if ((Lch == NULL) || (Lch->NodeTypeCode != LFS_NTC_LCH) || ((Lch->Lfcb != NULL) && (Lch->Lfcb->NodeTypeCode != LFS_NTC_LFCB))) { return FALSE; } // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then return immediately. // if (Lfcb == NULL) { LfsReleaseLch( Lch ); return FALSE; } // // Check that we have at least one page and that the page is valid. // if ((Length >= (ULONG) Lfcb->SystemPageSize) && (*((PULONG) RestartPage) == LFS_SIGNATURE_RESTART_PAGE_ULONG) && ((RestartPage->RestartOffset + sizeof( LFS_RESTART_AREA )) < (ULONG) Lfcb->SystemPageSize) && ((Add2Ptr( RestartPage, RestartPage->RestartOffset, PLFS_RESTART_AREA ))->RestartOpenLogCount == Lfcb->CurrentOpenLogCount)) { ValidLogFile = TRUE; } LfsReleaseLfcb( Lfcb ); return ValidLogFile; }

BOOLEAN LfsWrite (  IN LFS_LOG_HANDLE  LogHandle, IN ULONG  NumberOfWriteEntries, IN PLFS_WRITE_ENTRY  WriteEntries, IN LFS_RECORD_TYPE  RecordType, IN TRANSACTION_ID *TransactionId  OPTIONAL, IN LSN  UndoNextLsn, IN LSN  PreviousLsn, IN LONG  UndoRequirement, OUT PLSN  Lsn )

Definition at line 39 of file lfs/write.c. References Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), FALSE, _LCH::Lfcb, LfsAcquireLch, LfsExceptionFilter(), LfsReleaseLch, LfsValidateClientId, LfsValidateLch, LfsWrite(), LfsWriteLogRecordIntoLogPage(), NTSTATUS(), NULL, PAGED_CODE, PLFS_WRITE_ENTRY, and Status. Referenced by LfsWrite(). : This routine is called by a client to write a log record to the log file. The log record is lazy written and is not guaranteed to be on the disk until a subsequent LfsForceWrie or LfsWriteRestartArea or until an LfsFlushtoLsn is issued withan Lsn greater-than or equal to the Lsn returned from this service. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. NumberOfWriteEntries - Number of components of the log record. WriteEntries - Pointer to an array of write entries. RecordType - Lfs defined type for this log record. TransactionId - Id value used to group log records by complete transaction. UndoNextLsn - Lsn of a previous log record which needs to be undone in the event of a client restart. PreviousLsn - Lsn of the immediately previous log record for this client. Lsn - Lsn to be associated with this log record. Return Value: BOOLEAN - Advisory, TRUE indicates that less than 1/4 of the log file is available. --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; BOOLEAN LogFileFull = FALSE; PLCH Lch; PLFCB Lfcb; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsWrite: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "NumberOfWriteEntries -> %08lx\n", NumberOfWriteEntries ); DebugTrace( 0, Dbg, "WriteEntries -> %08lx\n", WriteEntries ); DebugTrace( 0, Dbg, "Record Type -> %08lx\n", RecordType ); DebugTrace( 0, Dbg, "Transaction Id -> %08lx\n", TransactionId ); DebugTrace( 0, Dbg, "UndoNextLsn (Low) -> %08lx\n", UndoNextLsn.LowPart ); DebugTrace( 0, Dbg, "UndoNextLsn (High) -> %08lx\n", UndoNextLsn.HighPart ); DebugTrace( 0, Dbg, "PreviousLsn (Low) -> %08lx\n", PreviousLsn.LowPart ); DebugTrace( 0, Dbg, "PreviousLsn (High) -> %08lx\n", PreviousLsn.HighPart ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); // // Write the log record. // LogFileFull = LfsWriteLogRecordIntoLogPage( Lfcb, Lch, NumberOfWriteEntries, WriteEntries, RecordType, TransactionId, UndoNextLsn, PreviousLsn, UndoRequirement, FALSE, Lsn ); } finally { DebugUnwind( LfsWrite ); // // Release the log file control block if held. // LfsReleaseLch( Lch ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( -1, Dbg, "LfsWrite: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return LogFileFull; }

VOID LfsWriteRestartArea (  IN LFS_LOG_HANDLE  LogHandle, IN ULONG  BufferLength, IN PVOID  Buffer, OUT PLSN  Lsn )

Definition at line 270 of file restart.c. References Add2Ptr, Buffer, _LFS_WRITE_ENTRY::Buffer, _LFS_WRITE_ENTRY::ByteLength, _LFCB::ClientArray, _LCH::ClientArrayByteOffset, _LFS_CLIENT_RECORD::ClientRestartLsn, Dbg, DebugTrace, DebugUnwind, ExRaiseStatus(), _LCH::Lfcb, LfsAcquireLch, LfsClientRestart, LfsExceptionFilter(), LfsReleaseLch, LfsSetBaseLsnPriv(), LfsValidateClientId, LfsValidateLch, LfsWriteLfsRestart(), LfsWriteLogRecordIntoLogPage(), LfsWriteRestartArea(), LfsZeroLsn, NTSTATUS(), NULL, PAGED_CODE, _LFCB::RestartAreaSize, Status, and TRUE. Referenced by LfsWriteRestartArea(). : This routine is called by the client to write a restart area to the disk. This routine will not return to the caller until the client restart area and all prior Lsn's have been flushed and the Lfs restart area on the disk has been updated. On return, all log records up to and including 'Lsn' have been flushed to the disk. Arguments: LogHandle - Pointer to private Lfs structure used to identify this client. BufferLength - On entry it is the length of the user buffer. Buffer - Pointer to the buffer where the client restart data resides. Lsn - This is the Lsn for this write operation. On input, this will be the new Base Lsn for this client. **** This was used to prevent adding an interface change to the Beta release. Return Value: None --*/ { volatile NTSTATUS Status = STATUS_SUCCESS; PLCH Lch; PLFCB Lfcb; PLFS_CLIENT_RECORD ClientRecord; LFS_WRITE_ENTRY WriteEntry; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsWriteRestartArea: Entered\n", 0 ); DebugTrace( 0, Dbg, "Log Handle -> %08lx\n", LogHandle ); DebugTrace( 0, Dbg, "Buffer Length -> %08lx\n", BufferLength ); DebugTrace( 0, Dbg, "Buffer -> %08lx\n", Buffer ); Lch = (PLCH) LogHandle; // // Check that the structure is a valid log handle structure. // LfsValidateLch( Lch ); // // Use a try-except to catch errors. // try { // // Use a try-finally to facilitate cleanup. // try { // // Acquire the log file control block for this log file. // LfsAcquireLch( Lch ); Lfcb = Lch->Lfcb; // // If the Log file has been closed then refuse access. // if (Lfcb == NULL) { ExRaiseStatus( STATUS_ACCESS_DENIED ); } // // Check that the client Id is valid. // LfsValidateClientId( Lfcb, Lch ); ClientRecord = Add2Ptr( Lfcb->ClientArray, Lch->ClientArrayByteOffset, PLFS_CLIENT_RECORD ); // // Go ahead and update the Base Lsn in the client area if the value // given is not zero. // if ( Lsn->QuadPart != 0 ) { //**** xxNeqZero( *Lsn ) LfsSetBaseLsnPriv( Lfcb, ClientRecord, *Lsn ); } // // Write this restart area as a log record into a log page. // WriteEntry.Buffer = Buffer; WriteEntry.ByteLength = BufferLength; LfsWriteLogRecordIntoLogPage( Lfcb, Lch, 1, &WriteEntry, LfsClientRestart, NULL, LfsZeroLsn, LfsZeroLsn, 0, TRUE, Lsn ); // // Update the restart area for the client. // ClientRecord->ClientRestartLsn = *Lsn; // // Write the restart area to the disk. // LfsWriteLfsRestart( Lfcb, Lfcb->RestartAreaSize, TRUE ); } finally { DebugUnwind( LfsWriteRestartArea ); // // Release the log file control block if still held. // LfsReleaseLch( Lch ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Log (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( -1, Dbg, "LfsWriteRestartArea: Exit\n", 0 ); } } except (LfsExceptionFilter( GetExceptionInformation() )) { Status = GetExceptionCode(); } if (Status != STATUS_SUCCESS) { ExRaiseStatus( Status ); } return; }

---

Variable Documentation

LSN LfsZeroLsn

Definition at line 147 of file lfs.h. Referenced by LfsCloseLogFile(), LfsOpenLogFile(), LfsQueryLastLsn(), LfsReadRestartArea(), and LfsWriteRestartArea().

---