Windows2000/private/ntos/lfs/lfsstruc.h

/*++ 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_