Windows2000/private/ntos/lfs/lfsstruc.h
2020-09-30 17:12:32 +02:00

676 lines
16 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++ BUILD Version: 0000 // Increment this if a change has global effects
Copyright (c) 1989 Microsoft Corporation
Module Name:
LfsStruc.h
Abstract:
This module defines the data structures that make up the major internal
part of the Log File Service.
Author:
Brian Andrew [BrianAn] 13-June-1991
Revision History:
*/
#ifndef _LFSSTRUC_
#define _LFSSTRUC_
typedef PVOID PBCB; //**** Bcb's are now part of the cache module
// Log Context Block. A pointer to this structure is returned to the user
// when a client is reading a particular set of log records from the log
// file.
typedef struct _LCB {
// The type and size of this record (must be LFS_NTC_LCB)
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
// Log record header. This is the mapped log record header and bcb
// for the record header of the current Lsn.
struct _LFS_RECORD_HEADER *RecordHeader;
PBCB RecordHeaderBcb;
// Context Mode. This is the mode governing the log record lookup. We
// can look backwards via the ClientUndoNextLsn or ClientPreviousLsn.
// We can also look forwards by walking through all the log records and
// comparing ClientId fields.
LFS_CONTEXT_MODE ContextMode;
// Client Id. This is the client ID for the log records being returned.
LFS_CLIENT_ID ClientId;
// Log record pointer. This is the address returned to the user as the
// log record referred to by CurrentLsn. If we allocated a buffer to
// hold the record, we need to deallocate it as necessary.
// This field is either the actual mapped log record or a pointer to
// an auxilary buffer allocated by the Lfs.
PVOID CurrentLogRecord;
BOOLEAN AuxilaryBuffer;
} LCB, *PLCB;
// Lfcb synchronization. This is the synchronization structure used by the Lfcb.
typedef struct _LFCB_SYNC {
// Principal Lfcb Resource.
ERESOURCE Resource;
// Notification Event. This event is set to the Signalled state when
// pages are flushed to the cache file. Any waiters will then check
// to see if the Lsn they're waiting for made it to disk.
KEVENT Event;
// User Count. Number of clients using this structure. We will deallocate
// when all clients are gone.
ULONG UserCount;
// Mutant to guard Lcb spare list
FAST_MUTEX SpareListMutex;
} LFCB_SYNC, *PLFCB_SYNC;
// Log Client Structure. The Lfs allocates one of these for each active
// client. The address of this structure will be returned to the user
// as a log handle.
typedef struct _LCH {
// The type and size of this record (must be LFS_NTC_LCH)
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
// Links for all the client handles on an Lfcb.
LIST_ENTRY LchLinks;
// Log File Control Block. This is the log file for this log handle.
struct _LFCB *Lfcb;
// Client Id. This refers to the client record for this client in the
// Lfs restart area.
LFS_CLIENT_ID ClientId;
// The following is the number of bytes this client has asked to
// have reserved in the log file. It includes the space
// for the log record headers.
LONGLONG ClientUndoCommitment;
// Byte offset in the client array.
ULONG ClientArrayByteOffset;
// Pointer to the resource in the Lfcb. We access the resource with
// this pointer for the times when the lfcb has been deleted.
PLFCB_SYNC Sync;
} LCH, *PLCH;
// Log Buffer Control Block. A buffer control block is associated with
// each of the log buffers. They are used to serialize access to the
// log file.
typedef struct _LBCB {
// The type and size of this record (must be LFS_NTC_LBCB)
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
// Buffer Block Links. These fields are used to link the buffer blocks
// together.
LIST_ENTRY WorkqueLinks;
LIST_ENTRY ActiveLinks;
// Log file position and length. This is the location in the log file to write
// out this buffer.
LONGLONG FileOffset;
LONGLONG Length;
// Sequence number. This is the sequence number for log records which
// begin on this page.
LONGLONG SeqNumber;
// Next Offset. This is the next offset to write a log record in the
// this log page. Stored as a large integer to facilitate large
// integer operations.
LONGLONG BufferOffset;
// Buffer. This field points to the buffer containing the log page
// for this block. For a log record page this is a pointer to
// a pinned cache buffer, for a log restart page, this is a pointer
// to an auxilary buffer.
PVOID PageHeader;
// Bcb for Log Page Block. This is the Bcb for the pinned data.
// If this buffer block describes an Lfs restart area, this field is NULL.
PBCB LogPageBcb;
// Last Lsn. This is the Lsn for the last log record on this page. We delay
// writing it until the page is flushed, storing it here instead.
LSN LastLsn;
// Last complete Lsn. This is the Lsn for the last log record which ends
// on this page.
LSN LastEndLsn;
// Page Flags. These are the flags associated with this log page.
// We store them in the Lbcb until the page is written. They flags
// to use are the same as in the log record page header.
// LOG_PAGE_LOG_RECORD_END - Page contains the end of a log record
// LOG_PAGE_PACKED - Page contains packed log records
// LOG_PAGE_TAIL_COPY - Page is a copy of the log file end
ULONG Flags;
// Lbcb flags. These are flags used to describe this Lbcb.
// LBCB_LOG_WRAPPED - Lbcb has wrapped the log file
// LBCB_ON_ACTIVE_QUEUE - Lbcb is on the active queue
// LBCB_NOT_EMPTY - Page has existing log record
// LBCB_FLUSH_COPY - Write copy of this page first
// LBCB_RESTART_LBCB - This Lbcb contains a restart page
ULONG LbcbFlags;
// This is the thread which has locked the log page.
ERESOURCE_THREAD ResourceThread;
} LBCB, *PLBCB;
#define LBCB_LOG_WRAPPED (0x00000001)
#define LBCB_ON_ACTIVE_QUEUE (0x00000002)
#define LBCB_NOT_EMPTY (0x00000004)
#define LBCB_FLUSH_COPY (0x00000008)
#define LBCB_RESTART_LBCB (0x00000020)
// Log file data. This data structure is used on a per-log file basis.
typedef enum _LFS_IO_STATE {
LfsNoIoInProgress = 0,
LfsClientThreadIo
} LFS_IO_STATE;
typedef struct _LFCB {
// The type and size of this record (must be LFS_NTC_LFCB)
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
// Lfcb Links. The following links the file control blocks to the
// global data structure.
LIST_ENTRY LfcbLinks;
// Lch Links. The following links all of the handles for the Lfcb.
LIST_ENTRY LchLinks;
// File Object. This is the file object for the log file.
PFILE_OBJECT FileObject;
// Log File Size. This is the size of the log file.
// The second value is the size proposed by this open.
LONGLONG FileSize;
// System page size and masks.
LONGLONG SystemPageSize;
ULONG SystemPageMask;
LONG SystemPageInverseMask;
// Log page size, masks and shift count to do multiplication and division
// of log pages.
LONGLONG LogPageSize;
ULONG LogPageMask;
LONG LogPageInverseMask;
ULONG LogPageShift;
// First log page. This is the offset in the file of the first
// log page with log records.
LONGLONG FirstLogPage;
// Next log page offset. This is the offset of the next log page to use.
// If we are reusing this page we store the offset to begin with.
LONGLONG NextLogPage;
ULONG ReusePageOffset;
// Data Offset. This is the offset within a log page of the data that
// appears on that page. This will be the actual restart data for
// an Lfs restart page, or the beginning of log record data for a log
// record page.
ULONG RestartDataOffset;
LONGLONG LogPageDataOffset;
// Data Size. This is the amount of data that may be stored on a
// log page. It is included here because it is frequently used. It
// is simply the log page size minus the data offset.
ULONG RestartDataSize;
LONGLONG LogPageDataSize;
// Record header size. This is the size to use for the record headers
// when reading the log file.
USHORT RecordHeaderLength;
// Sequence number. This is the number of times we have cycled through
// the log file. The wrap sequence number is used to confirm that we
// have gone through the entire file at least once. When we write a
// log record page for an Lsn with this sequence number, then we have
// cycled through the file.
LONGLONG SeqNumber;
LONGLONG SeqNumberForWrap;
ULONG SeqNumberBits;
ULONG FileDataBits;
// Buffer Block Links. The following links the buffer blocks for this
// log file.
LIST_ENTRY LbcbWorkque;
LIST_ENTRY LbcbActive;
PLBCB ActiveTail;
PLBCB PrevTail;
// The enumerated type indicates if there is an active write for
// this log file and whether it is being done by an Lfs or
// client thread.
LFS_IO_STATE LfsIoState;
// Current Restart Area. The following is the in-memory image of the
// next restart area. We also store a pointer to the client data
// array in the restart area. The client array offset is from the start of
// the restart area.
PLFS_RESTART_AREA RestartArea;
PLFS_CLIENT_RECORD ClientArray;
USHORT ClientArrayOffset;
USHORT ClientNameOffset;
// Restart Area size. This is the usable size of the restart area.
ULONG RestartAreaSize;
USHORT LogClients;
// Initial Restart area. If true, then the in-memory restart area is to
// be written to the first position on the disk.
BOOLEAN InitialRestartArea;
// The following pseudo Lsn's are used to track when restart areas
// are flushed to the disk.
LSN NextRestartLsn;
LSN LastFlushedRestartLsn;
// The following is the earliest Lsn we will guarantee is still in the
// log file.
LSN OldestLsn;
// The following is the file offset of the oldest Lsn in the system.
// We redundantly store it in this form since we will be constantly
// checking if a new log record will write over part of the file
// we are trying to maintain.
LONGLONG OldestLsnOffset;
// Last Flushed Lsn. The following is the last Lsn guaranteed to
// be flushed to the disk.
LSN LastFlushedLsn;
// The following fields are used to track current usage in the log file.
// TotalAvailable - is the total number of bytes available for
// log records. It is the number of log pages times the
// data size of each page.
// TotalAvailInPages - is the total number of bytes in the log
// pages for log records. This is TotalAvailable without
// subtracting the size of the page headers.
// TotalUndoCommitment - is the number of bytes reserved for
// possible abort operations. This includes space for
// log record headers as well.
// MaxCurrentAvail - is the maximum available in all pages
// subtracting the page header and any reserved tail.
// CurrentAvailable - is the total number of bytes available in
// unused pages in the log file.
// ReservedLogPageSize - is the number of bytes on a page available
// for reservation.
LONGLONG TotalAvailable;
LONGLONG TotalAvailInPages;
LONGLONG TotalUndoCommitment;
LONGLONG MaxCurrentAvail;
LONGLONG CurrentAvailable;
LONGLONG ReservedLogPageSize;
// The following fields are used to store information about the
// update sequence arrays.
USHORT RestartUsaOffset;
USHORT RestartUsaArraySize;
USHORT LogRecordUsaOffset;
USHORT LogRecordUsaArraySize;
// Major and minor version numbers.
SHORT MajorVersion;
SHORT MinorVersion;
// Log File Flags.
// LFCB_LOG_WRAPPED - We found an Lbcb which wraps the log file
// LFCB_MULTIPLE_PAGE_IO - Write multiple pages if possible
// LFCB_NO_LAST_LSN - There are no log records to return
// LFCB_PACK_LOG - Pack the records into the pages
// LFCB_REUSE_TAIL - We will be reusing the tail of the log file after restart
// LFCB_NO_OLDEST_LSN - There is no oldest page being reserved
ULONG Flags;
// The following are the spare Lbcb's for the volume and a field with
// the count for these.
ULONG SpareLbcbCount;
LIST_ENTRY SpareLbcbList;
// The following are sparse LCB's to be used rather than having to allocate
// then when reading log records
ULONG SpareLcbCount;
LIST_ENTRY SpareLcbList;
// The following structure synchronizes access to this structure.
PLFCB_SYNC Sync;
// Count of waiters wanting access to flush the Lfcb.
ULONG Waiters;
// On-disk value for OpenLogCount. This is the value we will stuff into
// the client handles.
ULONG CurrentOpenLogCount;
// Maintain the flush range for this file.
PLFS_WRITE_DATA UserWriteData;
PLBCB PageToDirty;
#ifdef BRIANDBG
ERESOURCE_THREAD LfsIoThread;
#endif
} LFCB, *PLFCB;
#define LFCB_LOG_WRAPPED (0x00000001)
#define LFCB_MULTIPLE_PAGE_IO (0x00000002)
#define LFCB_NO_LAST_LSN (0x00000004)
#define LFCB_PACK_LOG (0x00000008)
#define LFCB_REUSE_TAIL (0x00000010)
#define LFCB_NO_OLDEST_LSN (0x00000020)
#define LFCB_LOG_FILE_CORRUPT (0x00000040)
#define LFCB_FINAL_SHUTDOWN (0x00000080)
#define LFCB_READ_FIRST_RESTART (0x00000100)
#define LFCB_READ_SECOND_RESTART (0x00000200)
#define LFCB_RESERVE_LBCB_COUNT (5)
#define LFCB_MAX_LBCB_COUNT (25)
#define LFCB_RESERVE_LCB_COUNT (5)
#define LFCB_MAX_LCB_COUNT (25)
// Global Log Data. The following structure has only one instance and
// maintains global information for the entire logging service.
typedef struct _LFS_DATA {
// The type and size of this record (must be LFS_NTC_DATA)
NODE_TYPE_CODE NodeTypeCode;
NODE_BYTE_SIZE NodeByteSize;
// The following field links all of the Log File Control Blocks for
// the logging system.
LIST_ENTRY LfcbLinks;
// Flag field.
ULONG Flags;
// The following mutex controls access to this structure.
FAST_MUTEX LfsDataLock;
// Allocated buffers for reading spanning log records in low memory case.
// Flags indicate which buffers owned.
// LFS_BUFFER1_OWNED
// LFS_BUFFER2_OWNED
PVOID Buffer1;
PVOID Buffer2;
ERESOURCE_THREAD BufferOwner;
ULONG BufferFlags;
FAST_MUTEX BufferLock;
KEVENT BufferNotification;
} LFS_DATA, *PLFS_DATA;
#define LFS_DATA_INIT_FAILED (0x00000001)
#define LFS_DATA_INITIALIZED (0x00000002)
#define LFS_BUFFER1_OWNED (0x00000001)
#define LFS_BUFFER2_OWNED (0x00000002)
#define LFS_BUFFER_SIZE (0x10000)
#endif // _LFSSTRUC_