UMSKT
/
xpmgr
mirror of https://github.com/UMSKT/xpmgr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xpmgr/BuildTools/Include/clfs.h

1295 lines
38 KiB
C
Raw Blame History

/*=============================================================================
Copyright (c) 1998 Microsoft Corporation
Module Name:
clfs.h
Abstract:
Header file containing all publicly defined data structures for the
common log file system.
Author:
Dexter Bradshaw [DexterB] 09-Dec-1998
Revision History:
=============================================================================*/
// begin_wdm
#ifndef _CLFS_PUBLIC_H_
#define _CLFS_PUBLIC_H_
// end_wdm
#ifdef CLFS_KERNEL_MODE
// begin_wdm
#define CLFSUSER_API
// end_wdm
#else
#include <stdio.h>
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// PFILE
//
// Define PFILE to be a pointer to _iobuf *
//
typedef FILE *PFILE, **PPFILE;
typedef DWORD CLFSSTATUS;
# ifdef __CLFSUSER_EXPORTS__
# define CLFSUSER_API
# else
# define CLFSUSER_API __declspec(dllimport)
# endif /* __CLFSUSER_EXPORTS__ */
# define ClfsLsnEqual LsnEqual
# define ClfsLsnLess LsnLess
# define ClfsLsnGreater LsnGreater
# define ClfsLsnNull LsnNull
# define ClfsLsnCreate LsnCreate
# define ClfsLsnContainer LsnContainer
# define ClfsLsnBlockOffset LsnBlockOffset
# define ClfsLsnRecordSequence LsnRecordSequence
# define ClfsLsnInvalid LsnInvalid
# define ClfsLsnIncrement LsnIncrement
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* CLFS_KERNEL_MODE */
// begin_wdm
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// FILE_ATTRIBUTE_DEDICATED is defined as FILE_ATTRIBUTE_TEMPORARY.
//
#define FILE_ATTRIBUTE_DEDICATED FILE_ATTRIBUTE_TEMPORARY
//
// Container name and container size extended attribute entry names.
//
#define EA_CONTAINER_NAME "ContainerName"
#define EA_CONTAINER_SIZE "ContainerSize"
//
// Base log file name 3-letter extension.
//
#define CLFS_BASELOG_EXTENSION L".blf"
//
// Common log file system public flags and constants.
//
#define CLFS_FLAG_NO_FLAGS 0x00000000 // No flags.
#define CLFS_FLAG_FORCE_APPEND 0x00000001 // Flag to force an append to log queue
#define CLFS_FLAG_FORCE_FLUSH 0x00000002 // Flag to force a log flush
#define CLFS_FLAG_USE_RESERVATION 0x00000004 // Flag to charge a data append to reservation
#define CLFS_FLAG_REENTRANT_FILE_SYSTEM 0x00000008 // Kernel mode create flag indicating a re-entrant file system.
#define CLFS_FLAG_NON_REENTRANT_FILTER 0x00000010 // Kernel mode create flag indicating non-reentrant filter.
#define CLFS_FLAG_REENTRANT_FILTER 0x00000020 // Kernel mode create flag indicating reentrant filter.
#define CLFS_FLAG_IGNORE_SHARE_ACCESS 0x00000040 // Kernel mode create flag indicating IO_IGNORE_SHARE_ACCESS_CHECK semantics.
#define CLFS_FLAG_READ_IN_PROGRESS 0x00000080 // Flag indicating read in progress and not completed.
#define CLFS_FLAG_MINIFILTER_LEVEL 0x00000100 // Kernel mode create flag indicating mini-filter target.
#define CLFS_FLAG_HIDDEN_SYSTEM_LOG 0x00000200 // Kernel mode create flag indicating the log and containers should be marked hidden & system.
//
// Flag indicating all CLFS I/O will be targeted to an intermediate level of the I/O stack
//
#define CLFS_FLAG_FILTER_INTERMEDIATE_LEVEL CLFS_FLAG_NON_REENTRANT_FILTER
//
// Flag indicating all CLFS I/O will be targeted to the top level of the I/O stack
//
#define CLFS_FLAG_FILTER_TOP_LEVEL CLFS_FLAG_REENTRANT_FILTER
//
// CLFS_CONTAINER_INDEX
//
// Index into the container table.
//
typedef ULONG CLFS_CONTAINER_ID;
typedef CLFS_CONTAINER_ID *PCLFS_CONTAINER_ID;
typedef CLFS_CONTAINER_ID **PPCLFS_CONTAINER_ID;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#ifdef __CLFS_PRIVATE_LSN__
#include <clfslsn.h>
#else
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_LSN
//
typedef struct _CLS_LSN
{
ULONGLONG Internal;
} CLS_LSN, *PCLS_LSN, **PPCLS_LSN;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* __CLFS_PRIVATE_LSN__ */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias CLS prefixed types with CLFS prefixes.
//
typedef CLS_LSN CLFS_LSN;
typedef CLFS_LSN *PCLFS_LSN, **PPCLFS_LSN;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
// end_wdm
//
// Definition of special LSN's: CLFS_LSN_INVALID and CLFS_LSN_NULL. Note that
// [CLFS_LSN_NULL, CLFS_LSN_INVALID) define the only valid LSN range. LSN values
// are strictly monotonic increasing.
//
#ifdef CLFS_KERNEL_MODE
#if defined __CLFS_SUPPORT_LIBRARY__
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
extern const CLFS_LSN CLFS_LSN_INVALID;
extern const CLFS_LSN CLFS_LSN_NULL;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#elif defined __CLFSUSER_EXPORTS__
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
extern __declspec(dllexport) const CLFS_LSN CLFS_LSN_INVALID;
extern __declspec(dllexport) const CLFS_LSN CLFS_LSN_NULL;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
# else
// begin_wdm
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
extern __declspec(dllimport) const CLFS_LSN CLFS_LSN_INVALID;
extern __declspec(dllimport) const CLFS_LSN CLFS_LSN_NULL;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
// end_wdm
# endif /* __CLFSUSER_EXPORTS__ */
#else
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
extern CLFSUSER_API const CLFS_LSN CLFS_LSN_INVALID;
extern CLFSUSER_API const CLFS_LSN CLFS_LSN_NULL;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* CLFS_KERNEL_MODE */
// begin_wdm
#ifdef __cplusplus
}
#endif /* __cplusplus */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_RECORD_TYPE
//
// Definition of record types.
//
#ifdef __cplusplus
const UCHAR ClfsNullRecord = 0x00; // Null record type.
const UCHAR ClfsDataRecord = 0x01; // Client data record.
const UCHAR ClfsRestartRecord = 0x02; // Restart record.
// Valid client records are restart and data records.
const UCHAR ClfsClientRecord = 0x03;
#else
#define ClfsNullRecord 0x00 // Null record type.
#define ClfsDataRecord 0x01 // Client data record.
#define ClfsRestartRecord 0x02 // Restart record.
// Valid client records are restart and data records.
#define ClfsClientRecord (ClfsDataRecord|ClfsRestartRecord)
#endif /* _cplusplus */
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Log container path prefix indicating the log container's location is
// actually a stream inside of the BLF.
//
#ifdef _cplusplus
const LPCWSTR CLFS_CONTAINER_STREAM_PREFIX = L"%BLF%:"
#else
#define CLFS_CONTAINER_STREAM_PREFIX L"%BLF%:"
#endif /* _cplusplus */
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Log container path prefix indicating the log container's location is
// relative to the base log file (BLF) and not an absolute path.
// Paths which do not being with said prefix are absolute paths.
//
#ifdef _cplusplus
const LPCWSTR CLFS_CONTAINER_RELATIVE_PREFIX = L"%BLF%\\"
#else
#define CLFS_CONTAINER_RELATIVE_PREFIX L"%BLF%\\"
#endif /* _cplusplus */
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias CLS prefix with CLFS prefixes.
//
typedef UCHAR CLS_RECORD_TYPE, *PCLS_RECORD_TYPE, **PPCLS_RECORD_TYPE;
typedef CLS_RECORD_TYPE CLFS_RECORD_TYPE, *PCLFS_RECORD_TYPE, **PPCLFS_RECORD_TYPE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_CONTEXT_MODE
//
// The context mode specifies the dirction and access methods used to scan the
// log file.
//
typedef enum _CLS_CONTEXT_MODE
{
ClsContextNone = 0x00,
ClsContextUndoNext,
ClsContextPrevious,
ClsContextForward
} CLS_CONTEXT_MODE, *PCLS_CONTEXT_MODE, **PPCLS_CONTEXT_MODE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef enum _CLFS_CONTEXT_MODE
{
ClfsContextNone = 0x00,
ClfsContextUndoNext,
ClfsContextPrevious,
ClfsContextForward
} CLFS_CONTEXT_MODE, *PCLFS_CONTEXT_MODE, **PPCLFS_CONTEXT_MODE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFSD_NODE_ID
//
// Common log file system node identifier. Every CLFS file system
// structure has a node identity and type. The node type is a signature
// field while the size is used in for consistency checking.
//
typedef struct _CLFS_NODE_ID
{
ULONG cType; // CLFS node type.
ULONG cbNode; // CLFS node size.
} CLFS_NODE_ID, *PCLFS_NODE_ID;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_WRITE_ENTRY
//
// Write entry specifying the contents of a user buffer and length that are
// marshalled in the space reservation and append interface of the CLS API.
//
typedef struct _CLS_WRITE_ENTRY
{
PVOID Buffer;
ULONG ByteLength;
} CLS_WRITE_ENTRY, *PCLS_WRITE_ENTRY, **PPCLS_WRITE_ENTRY;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_WRITE_ENTRY CLFS_WRITE_ENTRY;
typedef CLFS_WRITE_ENTRY *PCLFS_WRITE_ENTRY, **PPCLFS_WRITE_ENTRY;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_LOG_ID
//
// A log identifier is a GUID that describes uniquely a physical log file.
//
typedef GUID CLFS_LOG_ID;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_INFORMATION
//
// Logical log file information structure describing either virtual or physical log
// file data, depending on the type of information queried.
//
typedef struct _CLS_INFORMATION
{
LONGLONG TotalAvailable; // Total log data space available.
LONGLONG CurrentAvailable; // Useable space in the log file.
LONGLONG TotalReservation; // Space reserved for UNDO's (aggregate for physical log)
ULONGLONG BaseFileSize; // Size of the base log file.
ULONGLONG ContainerSize; // Uniform size of log containers.
ULONG TotalContainers; // Total number of containers.
ULONG FreeContainers; // Number of containers not in active log.
ULONG TotalClients; // Total number of clients.
ULONG Attributes; // Log file attributes.
ULONG FlushThreshold; // Log file flush threshold.
ULONG SectorSize; // Underlying container sector size.
CLS_LSN MinArchiveTailLsn; // Marks the global archive tail.
CLS_LSN BaseLsn; // Start of the active log region.
CLS_LSN LastFlushedLsn; // Last flushed LSN in active log.
CLS_LSN LastLsn; // End of active log region.
CLS_LSN RestartLsn; // Location of restart record.
GUID Identity; // Unique identifier for the log.
} CLS_INFORMATION, *PCLS_INFORMATION, *PPCLS_INFORMATION;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias CLS prefixes with CLS prefixes.
//
typedef CLS_INFORMATION CLFS_INFORMATION;
typedef CLFS_INFORMATION *PCLFS_INFORMATION, *PPCLFS_INFORMATION;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
/*
//
// CLFS_CLIENT_INFORMATION
//
// The client information structure maintains client-based log metadata.
//
typedef struct _CLS_CLIENT_INFORMATION
{
CLS_INFORMATION ClfsInfo; // Contains base log file information.
ULONG ClientAttributes; // Virtual log file attributes.
LONGLONG ClientUndoCommitment; // Max. undo commitment for client.
CLS_LSN ClientArchiveTailLsn; // Marks the client archive tail.
CLS_LSN ClientBaseLsn; // Min. client LSN in active log region.
CLS_LSN ClientLastLsn; // Max. client LSN in active log region.
CLS_LSN ClientRestartLsn; // Location of restart record.
} CLS_CLIENT_INFORMATION, *PCLS_CLIENT_INFORMATION, **PPCLS_CLIENT_INFORMATION;
//
// Alias CLS prefixes with CLS prefixes.
//
typedef CLS_CLIENT_INFORMATION CLFS_CLIENT_INFORMATION;
typedef CLFS_CLIENT_INFORMATION *PCLFS_CLIENT_INFORMATION, *PPCLFS_CLIENT_INFORMATION;
*/
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_LOG_NAME_INFORMATION
//
// The client information structure stores the name of a log. It is used
// to communicate ClfsLogNameInformation and ClfsLogPhysicalNameInformation.
//
typedef struct _CLFS_LOG_NAME_INFORMATION
{
USHORT NameLengthInBytes;
WCHAR Name[1];
} CLFS_LOG_NAME_INFORMATION, *PCLFS_LOG_NAME_INFORMATION, **PPCLFS_LOG_NAME_INFORMATION;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_STREAM_ID_INFORMATION
//
// The client information structure provides a permanent identifier unique
// to the log for the stream in question.
//
typedef struct _CLFS_STREAM_ID_INFORMATION
{
UCHAR StreamIdentifier;
} CLFS_STREAM_ID_INFORMATION, *PCLFS_STREAM_ID_INFORMATION, **PPCLFS_STREAM_ID_INFORMATION;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_VISTA) || (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN)
//
// CLFS_PHYSICAL_LSN_INFORMATION
//
// An information structure that describes a virtual:physical LSN pairing
// for the stream identified in the structure.
//
#pragma pack(push,8)
typedef struct _CLFS_PHYSICAL_LSN_INFORMATION
{
UCHAR StreamIdentifier;
CLFS_LSN VirtualLsn;
CLFS_LSN PhysicalLsn;
} CLFS_PHYSICAL_LSN_INFORMATION, *PCLFS_PHYSICAL_LSN_INFORMATION;
#pragma pack(pop)
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_CONTAINER_STATE
//
// At any point in time a container could be inactive or unitialized, active,
// pending deletion from the list of free containers, pending archival, or
// pending deletion while waiting to be archived.
//
typedef UINT32 CLS_CONTAINER_STATE, *PCLS_CONTAINER_STATE, *PPCLS_CONTAINER_STATE;
typedef CLS_CONTAINER_STATE CLFS_CONTAINER_STATE, *PCLFS_CONTAINER_STATE, *PPCLFS_CONTAINER_STATE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#ifdef __cplusplus
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
const CLFS_CONTAINER_STATE ClsContainerInitializing = 0x01;
const CLFS_CONTAINER_STATE ClsContainerInactive = 0x02;
const CLFS_CONTAINER_STATE ClsContainerActive = 0x04;
const CLFS_CONTAINER_STATE ClsContainerActivePendingDelete = 0x08;
const CLFS_CONTAINER_STATE ClsContainerPendingArchive = 0x10;
const CLFS_CONTAINER_STATE ClsContainerPendingArchiveAndDelete = 0x20;
const CLFS_CONTAINER_STATE ClfsContainerInitializing = 0x01;
const CLFS_CONTAINER_STATE ClfsContainerInactive = 0x02;
const CLFS_CONTAINER_STATE ClfsContainerActive = 0x04;
const CLFS_CONTAINER_STATE ClfsContainerActivePendingDelete = 0x08;
const CLFS_CONTAINER_STATE ClfsContainerPendingArchive = 0x10;
const CLFS_CONTAINER_STATE ClfsContainerPendingArchiveAndDelete= 0x20;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#else
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
#define ClsContainerInitializing 0x01
#define ClsContainerInactive 0x02
#define ClsContainerActive 0x04
#define ClsContainerActivePendingDelete 0x08
#define ClsContainerPendingArchive 0x10
#define ClsContainerPendingArchiveAndDelete 0x20
#define ClfsContainerInitializing 0x01
#define ClfsContainerInactive 0x02
#define ClfsContainerActive 0x04
#define ClfsContainerActivePendingDelete 0x08
#define ClfsContainerPendingArchive 0x10
#define ClfsContainerPendingArchiveAndDelete 0x20
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* __cplusplus */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_MAX_CONTAINER_INFO
//
// The maximum length, in bytes, of the FileName field in the CLFS
// container information structure.
//
#ifdef __cplusplus
const ULONG CLFS_MAX_CONTAINER_INFO = (256);
#else
#define CLFS_MAX_CONTAINER_INFO (256)
#endif /* __cplusplus */
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_CONTAINER_INFORMATION
//
// This structure defines a container descriptor. The descriptor specifies the
// container's creation and access times, size, file system name, file system
// attributes, state, minimum, and maximum LSNs.
//
typedef struct _CLS_CONTAINER_INFORMATION
{
ULONG FileAttributes; // File system attribute flag.
ULONGLONG CreationTime; // File creation time.
ULONGLONG LastAccessTime; // Last time container was read/written.
ULONGLONG LastWriteTime; // Last time container was written.
LONGLONG ContainerSize; // Size of container in bytes.
ULONG FileNameActualLength; // Length of the actual file name.
ULONG FileNameLength; // Length of file name in buffer
WCHAR FileName [CLFS_MAX_CONTAINER_INFO];// File system name for container.
CLFS_CONTAINER_STATE State; // Current state of the container.
CLFS_CONTAINER_ID PhysicalContainerId; // Physical container identifier.
CLFS_CONTAINER_ID LogicalContainerId; // Logical container identifier.
} CLS_CONTAINER_INFORMATION, *PCLS_CONTAINER_INFORMATION, **PPCLS_CONTAINER_INFORMATION;
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_CONTAINER_INFORMATION CLFS_CONTAINER_INFORMATION;
typedef CLFS_CONTAINER_INFORMATION *PCLFS_CONTAINER_INFORMATION, **PPCLFS_CONTAINER_INFORMATION;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_LOG_INFORMATION_CLASS
//
// The information class specifies the kind of information a caller
// wishes to query or set on a log file.
//
typedef enum _CLS_LOG_INFORMATION_CLASS
{
ClfsLogBasicInformation = 0x00, // For virtual or physical logs, indicates the respective basic information.
ClfsLogBasicInformationPhysical, // Always indicates physical log basic information.
ClfsLogPhysicalNameInformation, // Always indicates physical name information.
ClfsLogStreamIdentifierInformation, // Virtual/physical log agnostic.
#if (NTDDI_VERSION >= NTDDI_VISTA) || (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN)
ClfsLogSystemMarkingInformation, // Count of system marking references.
ClfsLogPhysicalLsnInformation // Maps virtual LSNs to physical LSNs; only valid for physical logs.
#endif /* NTDDI_VERSION || _WIN32_WINNT */
} CLS_LOG_INFORMATION_CLASS, *PCLS_LOG_INFORMATION_CLASS, **PPCLS_LOG_INFORMATION_CLASS;
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_LOG_INFORMATION_CLASS CLFS_LOG_INFORMATION_CLASS;
typedef CLFS_LOG_INFORMATION_CLASS *PCLFS_LOG_INFORMATION_CLASS, **PPCLFS_LOG_INFORMATION_CLASS;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_IOSTATS_CLASS
//
// Enumerated type defining the class of I/O statistics.
//
typedef enum _CLS_IOSTATS_CLASS
{
ClsIoStatsDefault = 0x0000,
ClsIoStatsMax = 0xFFFF
} CLS_IOSTATS_CLASS, *PCLS_IOSTATS_CLASS, **PPCLS_IOSTATS_CLASS;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_IOSTATS_CLASS
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef enum _CLFS_IOSTATS_CLASS
{
ClfsIoStatsDefault = 0x0000,
ClfsIoStatsMax = 0xFFFF
} CLFS_IOSTATS_CLASS, *PCLFS_IOSTATS_CLASS, **PPCLFS_IOSTATS_CLASS;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLS_IO_STATISTICS
//
// This structure defines I/O performance counters particular to a log file. It consists
// of a header followed by the I/O statistics counters. The header is being ignored for
// now.
//
typedef struct _CLS_IO_STATISTICS_HEADER
{
UCHAR ubMajorVersion; // Major version of the statistics buffer.
UCHAR ubMinorVersion; // Minor version of the statistics buffer.
CLFS_IOSTATS_CLASS eStatsClass; // I/O statistics class.
USHORT cbLength; // Length of the statistics buffer.
ULONG coffData; // Offset of statistics counters.
} CLS_IO_STATISTICS_HEADER, *PCLS_IO_STATISTICS_HEADER, **PPCLS_IO_STATISTICS_HEADER;
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_IO_STATISTICS_HEADER CLFS_IO_STATISTICS_HEADER;
typedef CLFS_IO_STATISTICS_HEADER *PCLFS_IO_STATISTICS_HEADER, **PPCLFS_IO_STATISTICS_HEADER;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
typedef struct _CLS_IO_STATISTICS
{
CLS_IO_STATISTICS_HEADER hdrIoStats; // Statistics buffer header.
ULONGLONG cFlush; // Flush count.
ULONGLONG cbFlush; // Cumulative number of bytes flushed.
ULONGLONG cMetaFlush; // Metadata flush count.
ULONGLONG cbMetaFlush; // Cumulative number of metadata bytes flushed.
} CLS_IO_STATISTICS, *PCLS_IO_STATISTICS, **PPCLS_IO_STATISTICS;
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_IO_STATISTICS CLFS_IO_STATISTICS;
typedef CLFS_IO_STATISTICS *PCLFS_IO_STATISTICS, **PPCLFS_IO_STATISTICS;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_SCAN_MODE
//
// Container scan mode flags.
//
#ifdef __cplusplus
const UCHAR CLFS_SCAN_INIT = 0x01;
const UCHAR CLFS_SCAN_FORWARD = 0x02;
const UCHAR CLFS_SCAN_BACKWARD = 0x04;
const UCHAR CLFS_SCAN_CLOSE = 0x08;
const UCHAR CLFS_SCAN_INITIALIZED = 0x10;
const UCHAR CLFS_SCAN_BUFFERED = 0x20;
#else
#define CLFS_SCAN_INIT 0x01
#define CLFS_SCAN_FORWARD 0x02
#define CLFS_SCAN_BACKWARD 0x04
#define CLFS_SCAN_CLOSE 0x08
#define CLFS_SCAN_INITIALIZED 0x10
#define CLFS_SCAN_BUFFERED 0x20
#endif
typedef UCHAR CLFS_SCAN_MODE, *PCLFS_SCAN_MODE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
// end_wdm
#ifdef CLFS_KERNEL_MODE
// begin_wdm
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_SCAN_CONTEXT
//
// Container scan context for scanning all containers in a given physical log
// file.
//
//
// The log file object wraps an NT file object and the size of the structure.
// The log file object may be modified in the near future and there should be no
// dependencies on the size of the structure itself.
//
typedef FILE_OBJECT LOG_FILE_OBJECT, *PLOG_FILE_OBJECT, **PPLOG_FILE_OBJECT;
#if defined(_MSC_VER)
#if (_MSC_VER >= 1200)
#pragma warning(push)
#pragma warning(disable:4324) // structure padded due to __declspec(align())
#endif
#endif
typedef struct _CLS_SCAN_CONTEXT
{
CLFS_NODE_ID cidNode;
PLOG_FILE_OBJECT plfoLog;
__declspec(align(8)) ULONG cIndex;
__declspec(align(8)) ULONG cContainers;
__declspec(align(8)) ULONG cContainersReturned;
__declspec(align(8)) CLFS_SCAN_MODE eScanMode;
__declspec(align(8)) PCLS_CONTAINER_INFORMATION pinfoContainer;
} CLS_SCAN_CONTEXT, *PCLS_SCAN_CONTEXT, **PPCLS_SCAN_CONTEXT;
#if defined(_MSC_VER)
#if (_MSC_VER >= 1200)
#pragma warning(pop)
#endif
#endif
#endif /* NTDDI_VERSION || _WIN32_WINNT */
// end_wdm
#else
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
typedef struct _CLS_SCAN_CONTEXT
{
CLFS_NODE_ID cidNode;
HANDLE hLog;
__declspec(align(8)) ULONG cIndex;
__declspec(align(8)) ULONG cContainers;
__declspec(align(8)) ULONG cContainersReturned;
__declspec(align(8)) CLFS_SCAN_MODE eScanMode;
__declspec(align(8)) PCLS_CONTAINER_INFORMATION pinfoContainer;
} CLS_SCAN_CONTEXT, *PCLS_SCAN_CONTEXT, **PPCLS_SCAN_CONTEXT;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* CLFS_KERNEL_MODE */
// begin_wdm
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// Alias all CLS prefixes with CLFS prefixes.
//
typedef CLS_SCAN_CONTEXT CLFS_SCAN_CONTEXT;
typedef CLFS_SCAN_CONTEXT *PCLFS_SCAN_CONTEXT, **PPCLFS_SCAN_CONTEXT;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_ARCHIVE_DESCRIPTOR
//
// Log archive descriptors describe the set of discrete but logically
// contiguous disk extents comprising a snapshot of the active log when
// preparing for archival. Log archive descriptors specify enough information
// for log archive clients directly access the relevant contents of containers
// for archiving and restoring a snapshot of the log.
//
typedef struct _CLS_ARCHIVE_DESCRIPTOR
{
ULONGLONG coffLow;
ULONGLONG coffHigh;
CLS_CONTAINER_INFORMATION infoContainer;
} CLS_ARCHIVE_DESCRIPTOR, *PCLS_ARCHIVE_DESCRIPTOR, **PPCLS_ARCHIVE_DESCRIPTOR;
//
// Alias CLS prefixes with CLFS prefixes.
//
typedef CLS_ARCHIVE_DESCRIPTOR CLFS_ARCHIVE_DESCRIPTOR;
typedef CLFS_ARCHIVE_DESCRIPTOR *PCLFS_ARCHIVE_DESCRIPTOR, **PPCLFS_ARCHIVE_DESCRIPTOR;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_ALLOCATION_ROUTINE
//
// Allocate a blocks for marshalled reads or writes
//
typedef PVOID (* CLFS_BLOCK_ALLOCATION) (ULONG cbBufferLength, PVOID pvUserContext);
//
// CLFS_DEALLOCATION_ROUTINE
//
// Deallocate buffers allocated by the CLFS_ALLOCATION_ROUTINE.
//
typedef void (* CLFS_BLOCK_DEALLOCATION) (PVOID pvBuffer, PVOID pvUserContext);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// CLFS_LOG_ARCHIVE_MODE
//
// Describes the archive support behavior for the log.
//
typedef enum _CLFS_LOG_ARCHIVE_MODE
{
ClfsLogArchiveEnabled = 0x01,
ClfsLogArchiveDisabled = 0x02
} CLFS_LOG_ARCHIVE_MODE, *PCLFS_LOG_ARCHIVE_MODE;
#endif /* NTDDI_VERSION || _WIN32_WINNT */
//-----------------------------------------------------------------------------
// LSN OPERATORS
//-----------------------------------------------------------------------------
#ifdef __cplusplus
extern "C"
{
#endif
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnEqual
//
// Method Description:
//
// Check for the equivalence of LSNs.
//
// Arguments:
//
// plsn1 -- first LSN comparator
// plsn2 -- second LSN comparator
//
//
// Return Value:
//
// TRUE if LSN values are equivalent and FALSE otherwise.
//
//-----------------------------------------------------------------------------
CLFSUSER_API BOOLEAN NTAPI
ClfsLsnEqual
(
__in const CLFS_LSN* plsn1,
__in const CLFS_LSN* plsn2
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnLess
//
// Method Description:
//
// Check if LSN1 is less than LSN2.
//
// Arguments:
//
// plsn1 -- first LSN comparator
// plsn2 -- second LSN comparator
//
//
// Return Value:
//
// TRUE if LSN1 is less than LSN2 and FALSE otherwise.
//
//-----------------------------------------------------------------------------
CLFSUSER_API BOOLEAN NTAPI
ClfsLsnLess
(
__in const CLFS_LSN* plsn1,
__in const CLFS_LSN* plsn2
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnGreater
//
// Method Description:
//
// Check if LSN1 is greater than LSN2.
//
// Arguments:
//
// plsn1 -- first LSN comparator
// plsn2 -- second LSN comparator
//
//
// Return Value:
//
// TRUE if LSN1 is greater than LSN2 and FALSE otherwise.
//
//-----------------------------------------------------------------------------
CLFSUSER_API BOOLEAN NTAPI
ClfsLsnGreater
(
__in const CLFS_LSN* plsn1,
__in const CLFS_LSN* plsn2
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnNull (Inline)
//
// Method Description:
//
// Check whether or not an LSN is CLFS_LSN_NULL.
//
// Arguments:
//
// plsn -- reference to LSN tested against the NULL value.
//
//
// Return Value:
//
// TRUE if and only if an LSN is equivalent to CLFS_LSN_NULL.
// LSNs with the value CLFS_LSN_INVALID will return FALSE.
//
//-----------------------------------------------------------------------------
CLFSUSER_API BOOLEAN NTAPI
ClfsLsnNull
(
__in const CLFS_LSN* plsn
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnContainer (Inline)
//
// Routine Description:
//
// Extract the container identifier from the LSN.
//
// Arguments:
//
// plsn -- get block offset from this LSN
//
// Return Value:
//
// Returns the container identifier for the LSN.
//
//-----------------------------------------------------------------------------
CLFSUSER_API CLFS_CONTAINER_ID NTAPI
ClfsLsnContainer
(
__in const CLFS_LSN* plsn
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnCreate (Inline)
//
// Routine Description:
//
// Create an LSN given a log identifier, a container identifier, a block
// offset and a bucket identifier. Caller must test for invalid LSN after
// making this call.
//
// Arguments:
//
// cidContainer -- container identifier
// offBlock -- block offset
// cRecord -- ordinal number of the record in block
//
// Return Value:
//
// Returns a valid LSN if successful, otherwise it returns
// CLFS_LSN_INVALID
//
//-----------------------------------------------------------------------------
CLFSUSER_API CLFS_LSN NTAPI
ClfsLsnCreate
(
__in CLFS_CONTAINER_ID cidContainer,
__in ULONG offBlock,
__in ULONG cRecord
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnBlockOffset (Inline)
//
// Routine Description:
//
// Extract the block offset from the LSN.
//
// Arguments:
//
// plsn -- get block offset from this LSN
//
// Return Value:
//
// Returns the block offset for the LSN.
//
//-----------------------------------------------------------------------------
CLFSUSER_API ULONG NTAPI
ClfsLsnBlockOffset
(
__in const CLFS_LSN* plsn
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnRecordSequence (Inline)
//
// Routine Description:
//
// Extract the bucket identifier from the LSN.
//
// Arguments:
//
// plsn -- get block offset from this LSN
//
// Return Value:
//
// Returns the bucket identifier for the LSN.
//
//-----------------------------------------------------------------------------
CLFSUSER_API ULONG NTAPI
ClfsLsnRecordSequence
(
__in const CLFS_LSN* plsn
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnInvalid
//
// Method Description:
//
// Check whether or not an LSN is CLFS_LSN_INVALID.
//
// Arguments:
//
// plsn -- reference to LSN tested against CLFS_LSN_INVALID.
//
//
// Return Value:
//
// TRUE if and only if an LSN is equivalent to CLFS_LSN_INVALID.
// LSNs with the value CLFS_LSN_NULL will return FALSE.
//
//-----------------------------------------------------------------------------
CLFSUSER_API BOOLEAN NTAPI
ClfsLsnInvalid
(
__in const CLFS_LSN* plsn
);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//-----------------------------------------------------------------------------
// ClfsLsnIncrement
//
// Method Description:
//
// Increment and LSN by 1
//
// Arguments:
//
// plsn -- LSN to be incremented.
//
//
// Return Value:
//
// A valid LSN next in sequence to the input LSN, if successful.
// Otherwise, this function returns CLFS_LSN_INVALID.
//
//-----------------------------------------------------------------------------
CLFSUSER_API CLFS_LSN NTAPI
ClfsLsnIncrement (__in PCLFS_LSN plsn);
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
#ifdef CLFS_OPERATORS
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// LSN arithmetic increment operator.
//
inline CLFS_LSN
operator++
(
__inout CLFS_LSN& refLsn
)
{
//
// Prefix increment operator.
//
refLsn = ClfsLsnIncrement (&refLsn);
return refLsn;
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
//
// BOOLEAN LSN operators.
//
inline BOOLEAN
operator<
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (ClfsLsnLess ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
inline BOOLEAN
operator>
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (ClfsLsnGreater ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
inline BOOLEAN
operator==
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (ClfsLsnEqual ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
inline BOOLEAN
operator!=
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (!ClfsLsnEqual ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
inline BOOLEAN
operator<=
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (!ClfsLsnGreater ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
inline BOOLEAN
operator>=
(
__in const CLFS_LSN& refLsn1,
__in const CLFS_LSN& refLsn2
)
{
return (!ClfsLsnLess ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2));
}
#endif /* NTDDI_VERSION || _WIN32_WINNT */
#endif /* CLFS_OPERATORS */
#endif /* __cplusplus */
#endif /* _CLFS_PUBLIC_H_ */
// end_wdm
//-----------------------------------------------------------------------------
// END OF FILE
//-----------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink