1024 lines
31 KiB
C
1024 lines
31 KiB
C
/*++
|
|
|
|
Copyright (c) 1989 - 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
exifs.h
|
|
|
|
Abstract:
|
|
|
|
This header exports all symbols and definitions shared between
|
|
user-mode clients of the Exchange IFS driver and the driver itself.
|
|
|
|
Notes:
|
|
|
|
This module has been built and tested only in UNICODE environment
|
|
|
|
Author:
|
|
|
|
Rajeev Rajan [RajeevR] 2-Feb-1998
|
|
|
|
Revision History:
|
|
|
|
Mike Purtell [MikePurt] 21-Jul-1998
|
|
Additions for NSM (Name Space Mapping)
|
|
|
|
Ramesh Chinta [Rameshc] 01-Jan-2000
|
|
Separate version of IFS for Local Store
|
|
|
|
--*/
|
|
|
|
#ifndef _EXIFS_H_
|
|
#define _EXIFS_H_
|
|
|
|
|
|
// These globals define LOCAL STORE version of the strings
|
|
#define LSIFS_DEVICE_NAME_A "LocalStoreIfsDevice"
|
|
// The following constant defines the length of the above name.
|
|
#define LSIFS_DEVICE_NAME_A_LENGTH (20)
|
|
// The following constant defines the path in the ob namespace
|
|
#define DD_LSIFS_FS_DEVICE_NAME_U L"\\Device\\LocalStoreDevice"
|
|
#define DD_LSIFS_USERMODE_SHADOW_DEV_NAME_U L"\\??\\LocalStoreIfs"
|
|
#define DD_LSIFS_USERMODE_DEV_NAME_U L"\\\\.\\LocalStoreIfs"
|
|
#define DD_PUBLIC_MDB_SHARE_LSIFS L"\\??\\WebStorage"
|
|
|
|
|
|
|
|
#ifdef LOCALSTORE
|
|
#define EXIFS_DEVICE_NAME_A LSIFS_DEVICE_NAME_A
|
|
|
|
// The following constant defines the length of the above name.
|
|
#define EXIFS_DEVICE_NAME_A_LENGTH LSIFS_DEVICE_NAME_A_LENGTH
|
|
|
|
// The following constant defines the path in the ob namespace
|
|
#define DD_EXIFS_FS_DEVICE_NAME_U DD_LSIFS_FS_DEVICE_NAME_U
|
|
#else // PLATINUM
|
|
// Device name for this driver
|
|
#define EXIFS_DEVICE_NAME_A "ExchangeIfsDevice"
|
|
|
|
// The following constant defines the length of the above name.
|
|
#define EXIFS_DEVICE_NAME_A_LENGTH (18)
|
|
|
|
// The following constant defines the path in the ob namespace
|
|
#define DD_EXIFS_FS_DEVICE_NAME_U L"\\Device\\ExchangeIfsDevice"
|
|
#endif // PLATINUM
|
|
|
|
#ifndef EXIFS_DEVICE_NAME
|
|
#define EXIFS_DEVICE_NAME
|
|
|
|
//
|
|
// The Devicename string required to access the exchange IFS device
|
|
// from User-Mode. Clients should use DD_EXIFS_USERMODE_DEV_NAME_U.
|
|
//
|
|
// WARNING The next two strings must be kept in sync. Change one and you must
|
|
// change the other. These strings have been chosen such that they are
|
|
// unlikely to coincide with names of other drivers.
|
|
//
|
|
// NOTE: These definitions MUST be synced with <ifsuser.h>
|
|
//
|
|
#ifdef LOCALSTORE
|
|
#define DD_EXIFS_USERMODE_SHADOW_DEV_NAME_U DD_LSIFS_USERMODE_SHADOW_DEV_NAME_U
|
|
#define DD_EXIFS_USERMODE_DEV_NAME_U DD_LSIFS_USERMODE_DEV_NAME_U
|
|
#else // PLATINUM
|
|
#define DD_EXIFS_USERMODE_SHADOW_DEV_NAME_U L"\\??\\ExchangeIfs"
|
|
#define DD_EXIFS_USERMODE_DEV_NAME_U L"\\\\.\\ExchangeIfs"
|
|
#endif // PLATINUM
|
|
#define DD_EXIFS_USERMODE_WIN9X_DRIVER_NAME "M:\EA"
|
|
|
|
//
|
|
// Prefix needed before <store-name>\<root-name>
|
|
//
|
|
#define DD_EXIFS_MINIRDR_PREFIX L"\\;E:"
|
|
#define DD_EXIFS_MINIRDR_PREFIX_LEN (sizeof(DD_EXIFS_MINIRDR_PREFIX)-2)
|
|
|
|
#define DD_EXIFS_MINIRDR_PREFIX_PRIVATE L"\\;F:"
|
|
#define DD_EXIFS_MINIRDR_PREFIX_SPECIAL L"\\;G:"
|
|
|
|
#endif // EXIFS_DEVICE_NAME
|
|
|
|
|
|
|
|
#define RDBSS_DRIVER_LOAD_STRING L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Rdbss"
|
|
#define STRING_MISC_POOLTAG ('Strg')
|
|
|
|
#ifdef LOCALSTORE
|
|
#define DD_PUBLIC_MDB_SHARE DD_PUBLIC_MDB_SHARE_LSIFS
|
|
#else // PLATINUM
|
|
#define DD_PUBLIC_MDB_SHARE L"\\??\\BackOfficeStorage"
|
|
#endif // PLATINUM
|
|
|
|
#define DD_MDB_SHARE_PREFIX L"\\??\\"
|
|
|
|
#define SYSTEM_PARAMETERS L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion"
|
|
|
|
#define IFS_DEFAULT_TEMP_DIR L"\\??\\C:\\temp\\"
|
|
#define IFS_TEMP_DIR_PREFIX L"\\??\\"
|
|
#define IFS_TEMP_DIR_POSTFIX L"\\"
|
|
|
|
|
|
//
|
|
// BEGIN WARNING WARNING WARNING WARNING
|
|
// The following are from the ddk include files and cannot be changed
|
|
|
|
#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014 // from ddk\inc\ntddk.h
|
|
#define METHOD_BUFFERED 0
|
|
#define FILE_ANY_ACCESS 0
|
|
|
|
// END WARNING WARNING WARNING WARNING
|
|
|
|
#define IOCTL_EXIFS_BASE FILE_DEVICE_NETWORK_FILE_SYSTEM
|
|
|
|
//
|
|
// This is a reserved net root name for use by the global UMR.
|
|
//
|
|
#define DD_EXUMR_NETROOT_NAME L"\\UMR\\CONTROL"
|
|
#define DD_EXUMR_ROOT_DIR DD_EXIFS_MINIRDR_PREFIX \
|
|
DD_EXUMR_NETROOT_NAME \
|
|
L"\\$ROOT_DIR"
|
|
|
|
#define _EXIFS_CONTROL_CODE(request, method, access) \
|
|
CTL_CODE(IOCTL_EXIFS_BASE, request, method, access)
|
|
|
|
//
|
|
// Signatures of structs
|
|
//
|
|
|
|
#define SCATTER_LIST_SIGNATURE (ULONG) 'rtcS'
|
|
#define IOCTL_INITROOT_IN_SIGNATURE (ULONG) 'Itri'
|
|
#define IOCTL_SPACEGRANT_IN_SIGNATURE (ULONG) 'Icps'
|
|
#define IOCTL_TERMROOT_IN_SIGNATURE (ULONG) 'Itrt'
|
|
#define IOCTL_QUERYROOT_OUT_SIGNATURE (ULONG) 'Otrq'
|
|
#define IOCTL_QUERYSTATS_IN_SIGNATURE (ULONG) 'IyrQ'
|
|
#define IOCTL_QUERYSTATS_OUT_SIGNATURE (ULONG) 'OyrQ'
|
|
#define IOCTL_SETENDOFFILE_IN_SIGNATURE (ULONG) 'IfoE'
|
|
#define IOCTL_ENABLE_UMR_ROOT_IN_SIGNATURE (ULONG) 'rmUE'
|
|
#define IOCTL_DIR_CHNG_REPORT_IN_SIGNATURE (ULONG) 'CriD'
|
|
#define IOCTL_EXPUNGE_NAME_IN_SIGNATURE (ULONG) 'ExNi'
|
|
#define IOCTL_EXPUNGE_NAME_OUT_SIGNATURE (ULONG) 'ExNo'
|
|
#define IOCTL_EXIFS_UMRX_ENABLE_NET_ROOT_OUT_SIGNATURE (ULONG) 'banE'
|
|
|
|
//
|
|
// Data Str shared between user-mode clients like the exchange store
|
|
// and Exchange IFS driver.
|
|
//
|
|
|
|
#define MAX_FRAGMENTS (ULONG) 8
|
|
|
|
//
|
|
// This limits the size that the scatter list portion of an EA can be.
|
|
// 896 entires will take 896*16=>14336 bytes.
|
|
// In a 16K request buffer, this leaves about 2k for the other portion of
|
|
// the EA of which the filename is the only other variable component.
|
|
//
|
|
|
|
#define MAX_TOTAL_SLIST_FRAGMENTS (ULONG) 896
|
|
|
|
//
|
|
// If MAX_CONSTANT_ALLOCATIONS have been made in a file, IFS will increase
|
|
// the allocation assuming that future constant requests will be made.
|
|
//
|
|
#define MAX_CONSTANT_ALLOCATIONS (1024*4)
|
|
|
|
//
|
|
// A SCATTER_LIST_ENTRY represents a single fragment in a scatter list.
|
|
// All offsets are with respect to the underlying NTFS file for a given
|
|
// root. If this file is opened with FILE_FLAG_NO_BUFFERING, the
|
|
// following assertions must hold:
|
|
//
|
|
// 1. offsets must be integer multiples of the volume's sector size
|
|
// 2. lengths must be integer multiples of the volume's sector size
|
|
//
|
|
// Checked builds of the driver will ASSERT if these do not hold
|
|
//
|
|
// NOTE: Since the Offset is a multiple of the sector size which is
|
|
// typically 512, the least significant 8 bits are unused. These bits
|
|
// can be used for specifying flags on SLE state eg dirty/committed.
|
|
// CAUTION: Any use of these bits should be transparent to IFS clients !
|
|
//
|
|
typedef struct _SCATTER_LIST_ENTRY_
|
|
{
|
|
//
|
|
// 64-bit offset to fragment data
|
|
//
|
|
LARGE_INTEGER Offset;
|
|
|
|
//
|
|
// length of fragment data
|
|
//
|
|
ULONG Length;
|
|
|
|
//
|
|
// reserved
|
|
//
|
|
ULONG ulReserved;
|
|
|
|
} SCATTER_LIST_ENTRY, *PSCATTER_LIST_ENTRY;
|
|
|
|
//
|
|
// Bit masks for SLE properties
|
|
//
|
|
#define RX_SLE_STATE_DIRTY 0x00000001
|
|
|
|
#define RX_SLE_STATE_MASK 0xFFFFFFFFFFFFFF00
|
|
|
|
#define RX_LONGLONG(x) (x).QuadPart
|
|
#define RX_MASKED_LONGLONG(x) ((x).QuadPart & RX_SLE_STATE_MASK)
|
|
|
|
//
|
|
// SCATTER_LIST represents the scatter list. The array of fragments,
|
|
// sle, should in most cases be enough to describe data for a single
|
|
// IFS file. In extreme cases (eg very large messages), the overflow
|
|
// list should be used. This will ensure good page locality in the
|
|
// most common case, since this data is stored in the FCB extension.
|
|
//
|
|
// If NumFragments is <= MAX_FRAGMENTS, overflow should be NULL.
|
|
// If NumFragments is > MAX_FRAGMENTS, overflow should be non-NULL and
|
|
// should "point" to (NumFragments - MAX_FRAGMENTS) number of
|
|
// SCATTER_LIST_ENTRY's.
|
|
//
|
|
// NOTE: Apps need to set OverflowOffset (relative to start
|
|
// of struct) of the overflow fragments. The IFS uses it to point
|
|
// to a list of overflow fragments in kernel space.
|
|
//
|
|
typedef struct _SCATTER_LIST_
|
|
{
|
|
//
|
|
// signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// number of fragments in scatter list
|
|
//
|
|
ULONG NumFragments;
|
|
|
|
//
|
|
// TotalBytes ie. valid byte range
|
|
// NB: used only when scatter-list is available
|
|
// at create time. should *not* be used for GetFileSize()..
|
|
//
|
|
LARGE_INTEGER TotalBytes;
|
|
|
|
//
|
|
// array of scatter-list-entries
|
|
//
|
|
SCATTER_LIST_ENTRY sle[MAX_FRAGMENTS];
|
|
|
|
//
|
|
// ptr to overflow list
|
|
//
|
|
|
|
//
|
|
// ptr to overflow list
|
|
//
|
|
union {
|
|
struct {
|
|
//
|
|
// offset to overflow frags
|
|
//
|
|
ULONG OverflowOffset;
|
|
|
|
//
|
|
// len of overflow data
|
|
//
|
|
ULONG OverflowLen;
|
|
}; // user-mode representation
|
|
|
|
union {
|
|
//
|
|
// list of overflow frags
|
|
//
|
|
LIST_ENTRY OverflowListHead;
|
|
|
|
//
|
|
// pointer to object containing overflow frags
|
|
//
|
|
PVOID OverflowFragments;
|
|
}; // kernel-mode representation
|
|
};
|
|
|
|
//
|
|
// Flags for properties of the scatter-list
|
|
//
|
|
ULONG Flags;
|
|
|
|
} SCATTER_LIST, *PSCATTER_LIST;
|
|
|
|
#define IFS_SLIST_FLAGS_LARGE_BUFFER 0x00000001
|
|
|
|
//
|
|
// Linked list of scatter-list entries
|
|
//
|
|
typedef struct _SCATTER_LIST_NODE {
|
|
//
|
|
// Scatter-List entry
|
|
//
|
|
SCATTER_LIST_ENTRY Block;
|
|
|
|
//
|
|
// Doubly linked list of blocks
|
|
//
|
|
LIST_ENTRY NextBlock;
|
|
|
|
} SCATTER_LIST_NODE, *PSCATTER_LIST_NODE;
|
|
|
|
#define SCATTER_LIST_CONTAINING_RECORD( x ) CONTAINING_RECORD( x, SCATTER_LIST_NODE, NextBlock )
|
|
|
|
//
|
|
// IFS file extended attributes -
|
|
// NtQueryEaFile() will return the extended attributes
|
|
// for an IFS file. Currently, the following extended attributes
|
|
// are supported (in order) -
|
|
//
|
|
// 1. "FileName" - WCHAR : name of IFS file (NULL terminated)
|
|
// 2. "Commit" - NTSTATUS: STATUS_SUCCESS if committed
|
|
// 3. "InstanceID" - ULONG : NET_ROOT ID for validation
|
|
// 4. "Checksum" - ULONG : checksum for FILE_FULL_EA_INFORMATION
|
|
// 5. "OpenDeadline" - ULONG : time for which ScatterList is valid
|
|
// 6. "Properties" - ULONG : persisted message properties
|
|
// 7. "ScatterList" - : scatter list for an IFS file
|
|
//
|
|
// IFS will return values for all attributes in one call.
|
|
// Each of the EA values will be QWORD Aligned.
|
|
// If the Buffer supplied is not big enough, IFS will
|
|
// return STATUS_BUFFER_OVERFLOW.
|
|
//
|
|
// NOTE: The "Commit" EA is not actually stored. Callers of
|
|
// NtQueryEaFile() can ask for this EA in the EaList param.
|
|
// QUERYING FOR THIS EA IS AN IMPLICIT REQUEST TO COMMIT
|
|
// RESERVED BYTES FOR THIS IFS HANDLE.....!
|
|
//
|
|
// NtQueryEa() can (optionally) pass in a value for the "Properties" EA
|
|
//
|
|
// NtCreateFile() notes:
|
|
// This API will use all EAs except the "FileName". Semantics:
|
|
// "Commit" - STATUS_SUCESSS => Bytes are committed, dont reuse on close.
|
|
// "InstanceID" - used to validate handles belonging to a particular
|
|
// instance of a root.
|
|
// "Checksum" - validate checksum on EA list.
|
|
// "OpenDeadline" - validate time deadline on scatter-list. If the
|
|
// time deadline has expired, owner of root may reuse this list.
|
|
// "Properties" - is set in the FCB extension
|
|
// "ScatterList" - describes pages for file being created.
|
|
|
|
#define EXIFS_EA_NAME_COMMIT "Commit"
|
|
#define EXIFS_EA_NAME_INSTANCE_ID "InstanceID"
|
|
#define EXIFS_EA_NAME_CHECKSUM "Checksum"
|
|
#define EXIFS_EA_NAME_OPEN_DEADLINE "OpenDeadline"
|
|
#define EXIFS_EA_NAME_PROPERTIES "Properties"
|
|
#define EXIFS_EA_NAME_FILENAME "FileName"
|
|
#define EXIFS_EA_NAME_SCATTER_LIST "ScatterList"
|
|
#define EXIFS_MAX_EAS 7
|
|
#define EXIFS_CHECKSUM_SEED 0xFEEDFEED
|
|
|
|
#define EXIFS_INVALID_INSTANCE_ID 0xFFFFFFFF
|
|
|
|
#ifndef LongAlign
|
|
#define LongAlign(Ptr) ( \
|
|
((((ULONG_PTR)(Ptr)) + 3) & 0xfffffffc) \
|
|
)
|
|
#endif
|
|
|
|
#define EXIFS_EA_LEN_COMMIT \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_COMMIT) + sizeof(ULONG))
|
|
|
|
#define EXIFS_EA_LEN_INSTANCE_ID \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_INSTANCE_ID) + sizeof(ULONG))
|
|
|
|
#define EXIFS_EA_LEN_CHECKSUM \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_CHECKSUM) + sizeof(ULONG))
|
|
|
|
#define EXIFS_EA_LEN_OPEN_DEADLINE \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_OPEN_DEADLINE) + sizeof(ULONG))
|
|
|
|
#define EXIFS_EA_LEN_PROPERTIES \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_PROPERTIES) + sizeof(ULONG))
|
|
|
|
#define EXIFS_EA_LEN_FILENAME(len) \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_FILENAME) + LongAlign(len))
|
|
|
|
#define EXIFS_EA_LEN_SCATTER_LIST(n) \
|
|
LongAlign(FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_SCATTER_LIST) + \
|
|
LongAlign(sizeof(SCATTER_LIST) + \
|
|
((n)>MAX_FRAGMENTS?(n)-MAX_FRAGMENTS:0)*sizeof(SCATTER_LIST_ENTRY)))
|
|
|
|
#define EXIFS_GET_EA_LEN_COMMIT \
|
|
LongAlign(FIELD_OFFSET( FILE_GET_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_COMMIT))
|
|
|
|
#define EXIFS_GET_EA_LEN_INSTANCE_ID \
|
|
LongAlign(FIELD_OFFSET( FILE_GET_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_INSTANCE_ID))
|
|
|
|
#define EXIFS_GET_EA_LEN_PROPERTIES \
|
|
LongAlign(FIELD_OFFSET( FILE_GET_EA_INFORMATION, EaName[0] ) + \
|
|
sizeof(EXIFS_EA_NAME_PROPERTIES))
|
|
|
|
//
|
|
// IOCTL codes supported by Exchange IFS Device.
|
|
//
|
|
|
|
#define IOCTL_CODE_INITIALIZE_ROOT 100
|
|
#define IOCTL_CODE_SPACEGRANT_ROOT 101
|
|
#define IOCTL_CODE_SPACEREQ_ROOT 102
|
|
#define IOCTL_CODE_TERMINATE_ROOT 103
|
|
#define IOCTL_CODE_QUERYSTATS_ROOT 104
|
|
#define IOCTL_CODE_SETENDOFFILE_ROOT 105
|
|
#define IOCTL_CODE_DIR_CHNG_REPORT 106
|
|
#define IOCTL_CODE_INITDRIVE 107
|
|
#define IOCTL_CODE_EXPUNGE_NAME 108
|
|
#define IOCTL_CODE_SETMAP_ROOT 109
|
|
#define IOCTL_CODE_RESETMAP_ROOT 110
|
|
|
|
//
|
|
// WIN32 IOCTL codes
|
|
//
|
|
#define IOCTL_CODE_UMRX_PACKET 150
|
|
#define IOCTL_CODE_UMRX_TEARDOWN 151
|
|
#define IOCTL_CODE_UMRX_STARTUP 152
|
|
#define IOCTL_CODE_UMRX_ENABLE_NET_ROOT 153
|
|
#define IOCTL_CODE_UMRX_DISABLE_NET_ROOT 154
|
|
|
|
|
|
//suspend and resume IOCTLS
|
|
#define IOCTL_EXIFS_SETMAP_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_SETMAP_ROOT, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#define IOCTL_EXIFS_RESETMAP_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_RESETMAP_ROOT, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// Semantics for using an IFS root:
|
|
// 1. App gets a handle (exclusive) to the root via
|
|
// CreateFile(\Device\ExchangeIfsDevice\{NodeName}\{RootName}).
|
|
// This handle should be opened for overlapped I/O.
|
|
//
|
|
// 2. App calls overlapped DeviceIoControl() with INITIALIZE_ROOT IOCTL.
|
|
//
|
|
// 3. This will succeed or fail synchronously. If DeviceIoControl()
|
|
// returns TRUE, it succeeded. If it returns FALSE, GetLastError() or
|
|
// the NTSTATUS from NtDeviceIoControl() is the error code.
|
|
// NOTE: If this IOCTL has NOT been made on a root successfully,
|
|
// no I/O on this root will succeed.
|
|
//
|
|
// 3. At this point, the IFS root has no space grants.
|
|
// It is expected that the app will make one or more SPACEGRANT_ROOT
|
|
// IOCTLs to grant space on this root. Each of these IOCTLs will finish
|
|
// synchronously and return semantics are similar to INITIALIZE_ROOT.
|
|
//
|
|
// 4. An app should also pend an async SPACEREQ_ROOT IOCTL. Usually, this
|
|
// will return with ERROR_IO_PENDING. If this later completes with
|
|
// NTSTATUS == EXSTATUS_ROOT_NEEDS_SPACE, the app should make a space
|
|
// grant (SPACEGRANT_ROOT) and pend another SPACEREQ_ROOT. This will
|
|
// happen if IFS runs out of free space blocks on this root. If the IOCTL
|
|
// completes with STATUS_SUCCESS, app should NOT pend another IOCTL.
|
|
//
|
|
// 5. App calls overlapped DeviceIoControl() with TERMINATE_ROOT IOCTL.
|
|
// This will complete any async pended IOCTLs. After this call, the root
|
|
// starts shutting down. This IOCTL will complete synchronously.
|
|
// NOTE: Once terminated, a root cannot be initialized again.
|
|
//
|
|
// 6. App closes handle to root. Note: Handle to root needs to be kept
|
|
// open across life of root. Once the root handle is closed, the IFS
|
|
// root has no free space. All of the free space allocated to the
|
|
// root before TERMINATE needs to be reclaimed by the app.
|
|
// The app can now re-create this root starting at step1.
|
|
//
|
|
// 7. If the app with an exclusive handle to a root dies, the root will
|
|
// be marked 'bad' and new I/Os (including IOCTLs) to this root will
|
|
// fail. Over time, outstanding handles on this root will go away and
|
|
// eventually the root will die. At this point, an app can re-create
|
|
// the root starting at step 1.
|
|
//
|
|
|
|
//
|
|
// IOCTL to initialize a net root. This results in creating an entry
|
|
// in the RootMapTable. There is one entry in this table for every
|
|
// secondary NTFS file managed by the IFS driver.
|
|
// NOTE: IFS will attempt to get an exclusive handle to the underlying
|
|
// file. This ensures that all operations on the underlying file are
|
|
// done through IFS.
|
|
//
|
|
// Following is the IOCTL definition and associated structs.
|
|
//
|
|
#define IOCTL_EXIFS_INITIALIZE_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_INITIALIZE_ROOT, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_INITROOT_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Underlying Ntfs filename for this root.
|
|
// Length is the size in bytes of the name.
|
|
// Offset should be from the start of this struct.
|
|
//
|
|
USHORT NtfsFileNameLength;
|
|
USHORT NtfsFileNameOffset;
|
|
|
|
//
|
|
// Flags to control access to Ntfs file
|
|
//
|
|
ULONG NtfsFlags;
|
|
|
|
//
|
|
// Allocation unit for this root. Min is 4K
|
|
//
|
|
ULONG AllocationUnit;
|
|
|
|
//
|
|
// root InstanceID
|
|
//
|
|
ULONG InstanceID;
|
|
|
|
} IOCTL_INITROOT_IN, *PIOCTL_INITROOT_IN;
|
|
|
|
typedef struct _IOCTL_INITROOT_IN_EX
|
|
{
|
|
IOCTL_INITROOT_IN InitRoot;
|
|
WCHAR RootName[MAX_PATH];
|
|
}IOCTL_INITROOT_IN_EX, *PIOCTL_INITROOT_IN_EX;
|
|
|
|
|
|
//
|
|
// IOCTL to grant space to an initialized net root.
|
|
// Following is the IOCTL definition and associated structs.
|
|
//
|
|
#define IOCTL_EXIFS_SPACEGRANT_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_SPACEGRANT_ROOT, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// Free space is granted in chunks. The root owner decides
|
|
// what the maximum chunk size is.
|
|
//
|
|
#define MAX_EXIFS_FREEBLOCK_SIZE 0x100000
|
|
|
|
//
|
|
// Default chunk size
|
|
//
|
|
#define EXIFS_DEFAULT_CHUNK_SIZE 0x40000
|
|
|
|
//
|
|
// MAXIMUM file size allowed by IFS
|
|
//
|
|
#define EXIFS_MAXIMUM_FILESIZE 0x7FFFFFFF
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_SPACEGRANT_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Scatter-list of free space - must be last
|
|
//
|
|
SCATTER_LIST FreeSpaceList;
|
|
|
|
|
|
} IOCTL_SPACEGRANT_IN, *PIOCTL_SPACEGRANT_IN;
|
|
|
|
typedef struct _IOCTL_SPACEGRANT_IN_EX
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
|
|
WCHAR RootName[MAX_PATH];
|
|
|
|
SCATTER_LIST *W9xFreeSpaceList;
|
|
|
|
} IOCTL_SPACEGRANT_IN_EX, *PIOCTL_SPACEGRANT_IN_EX;
|
|
|
|
//
|
|
// IOCTL to allow IFS to request space on an initialized net root.
|
|
// Following is the IOCTL definition and associated structs.
|
|
//
|
|
#define IOCTL_EXIFS_SPACEREQ_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_SPACEREQ_ROOT, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
|
|
typedef struct _IOCTL_SPACEREQ_ROOT_IN
|
|
{
|
|
WCHAR RootName[MAX_PATH];
|
|
}IOCTL_SPACEREQ_ROOT_IN, *PIOCTL_SPACEREQ_ROOT_IN;
|
|
|
|
//
|
|
// IOCTL to terminate a net root. This results in deleting an entry
|
|
// in the RootMapTable. There is one entry in this table for every
|
|
// secondary NTFS file managed by the IFS driver. Following is the IOCTL
|
|
// definition and associated structs.
|
|
//
|
|
#define IOCTL_EXIFS_TERMINATE_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_TERMINATE_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_TERMROOT_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Mode of shutdown
|
|
//
|
|
ULONG Mode;
|
|
|
|
} IOCTL_TERMROOT_IN, *PIOCTL_TERMROOT_IN;
|
|
|
|
typedef struct _IOCTL_TERMROOT_IN_EX
|
|
{
|
|
IOCTL_TERMROOT_IN TermRoot;
|
|
WCHAR RootName[MAX_PATH];
|
|
} IOCTL_TERMROOT_IN_EX, *PIOCTL_TERMROOT_IN_EX;
|
|
|
|
#if 0
|
|
//
|
|
// IOCTL to query a net root for current free space. Currently, NYI.
|
|
// The goal for this is to allow app to retrieve fragmented free lists
|
|
// in order to defrag.
|
|
// Following is the IOCTL definition and associated structs.
|
|
//
|
|
#define IOCTL_EXIFS_QUERY_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_QUERY_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// OutBuffer struct
|
|
//
|
|
typedef struct _IOCTL_QUERYROOT_OUT
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Return code
|
|
//
|
|
NTSTATUS IoctlStatus;
|
|
|
|
//
|
|
// Free space list for this root
|
|
//
|
|
SCATTER_LIST FreeSpaceList;
|
|
|
|
} IOCTL_QUERYROOT_OUT, *PIOCTL_QUERYROOT_OUT;
|
|
#endif
|
|
|
|
//
|
|
// IOCTL to query stats for a net root.
|
|
//
|
|
#define IOCTL_EXIFS_QUERYSTATS_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_QUERYSTATS_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_QUERYSTATS_FILENAME L"\\$PERFMON$"
|
|
|
|
//
|
|
// Statistics for a net root
|
|
//
|
|
typedef struct _EXIFS_NETROOT_STATS {
|
|
//
|
|
// Number of Creates
|
|
//
|
|
ULONG NumberOfCreates;
|
|
|
|
//
|
|
// Number of Opens
|
|
//
|
|
ULONG NumberOfOpens;
|
|
|
|
//
|
|
// Number of Collapsed Opens
|
|
//
|
|
ULONG NumberOfCollapsedOpens;
|
|
|
|
//
|
|
// Number of IRP Reads
|
|
//
|
|
ULONG NumberOfIrpReads;
|
|
|
|
//
|
|
// Number of MDL Reads
|
|
//
|
|
ULONG NumberOfMdlReads;
|
|
|
|
//
|
|
// Number of Writes
|
|
//
|
|
ULONG NumberOfWrites;
|
|
|
|
//
|
|
// Number of Close
|
|
//
|
|
ULONG NumberOfClose;
|
|
|
|
//
|
|
// Number of FCB close
|
|
//
|
|
ULONG NumberOfFCBClose;
|
|
|
|
//
|
|
// Total Bytes Read
|
|
//
|
|
LARGE_INTEGER TotalBytesRead;
|
|
|
|
//
|
|
// Total Bytes Written
|
|
//
|
|
LARGE_INTEGER TotalBytesWritten;
|
|
|
|
//
|
|
// Reserved Bytes ie on primary free list
|
|
//
|
|
LARGE_INTEGER ReservedBytes;
|
|
|
|
//
|
|
// Orphaned Bytes ie on secondary free list
|
|
// Total Available Bytes = ReservedBytes + OrphanedBytes
|
|
//
|
|
LARGE_INTEGER OrphanedBytes;
|
|
|
|
} EXIFS_NETROOT_STATS, *PEXIFS_NETROOT_STATS;
|
|
|
|
//
|
|
// Cheap stats do not cause locks to be acquired.
|
|
// Other modes may need locks.
|
|
//
|
|
#define EXIFS_QUERYSTATS_CHEAP 1
|
|
#define EXIFS_QUERYSTATS_MEDIUM 2
|
|
#define EXIFS_QUERYSTATS_ALL 3
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_QUERYSTATS_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Granularity of stats
|
|
//
|
|
ULONG Granularity;
|
|
|
|
WCHAR RootName[MAX_PATH];
|
|
|
|
} IOCTL_QUERYSTATS_IN, *PIOCTL_QUERYSTATS_IN;
|
|
|
|
//
|
|
// OutBuffer struct
|
|
//
|
|
typedef struct _IOCTL_QUERYSTATS_OUT
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Return code
|
|
//
|
|
NTSTATUS IoctlStatus;
|
|
|
|
//
|
|
// Stats data
|
|
//
|
|
EXIFS_NETROOT_STATS RootStats;
|
|
|
|
|
|
} IOCTL_QUERYSTATS_OUT, *PIOCTL_QUERYSTATS_OUT;
|
|
|
|
//
|
|
// IOCTL to set end of file (truncate or extend) for root underlying file.
|
|
// It is callers responsibility to zero extended length when extending.
|
|
//
|
|
#define IOCTL_EXIFS_SETENDOFFILE_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_SETENDOFFILE_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_SETENDOFFILE_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// New EOF
|
|
//
|
|
LARGE_INTEGER EndOfFile;
|
|
|
|
} IOCTL_SETENDOFFILE_IN, *PIOCTL_SETENDOFFILE_IN;
|
|
|
|
typedef struct _IOCTL_SETENDOFFILE_IN_EX
|
|
{
|
|
|
|
IOCTL_SETENDOFFILE_IN SetEndOfFile;
|
|
WCHAR RootName[MAX_PATH];
|
|
|
|
} IOCTL_SETENDOFFILE_IN_EX, *PIOCTL_SETENDOFFILE_IN_EX;
|
|
|
|
//
|
|
// IOCTL to send down reports about changes in directories that exifs.sys doesn't
|
|
// know about.
|
|
//
|
|
#define IOCTL_EXIFS_DIR_CHNG_REPORT _EXIFS_CONTROL_CODE(IOCTL_CODE_DIR_CHNG_REPORT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_DIR_CHNG_REPORT_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Action
|
|
//
|
|
ULONG ulAction;
|
|
|
|
//
|
|
// FilterMatch
|
|
//
|
|
ULONG ulFilterMatch;
|
|
|
|
//
|
|
// Path length (bytes)
|
|
//
|
|
ULONG cbPath;
|
|
|
|
//
|
|
// Path (unicode)
|
|
//
|
|
WCHAR rgwchPath[1];
|
|
|
|
} IOCTL_DIR_CHNG_REPORT_IN, *PIOCTL_DIR_CHNG_REPORT_IN;
|
|
|
|
//
|
|
// IOCTL to send request to close and unlock namespace
|
|
//
|
|
#define IOCTL_EXIFS_EXPUNGE_NAME _EXIFS_CONTROL_CODE( IOCTL_CODE_EXPUNGE_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS )
|
|
|
|
//
|
|
// InBuffer struct
|
|
//
|
|
typedef struct _IOCTL_EXPUNGE_NAME_IN
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Path length (bytes)
|
|
//
|
|
ULONG cbPath;
|
|
|
|
//
|
|
// Path (unicode)
|
|
//
|
|
WCHAR rgwchPath[ 1 ];
|
|
|
|
} IOCTL_EXPUNGE_NAME_IN, *PIOCTL_EXPUNGE_NAME_IN;
|
|
|
|
//
|
|
// OutBuffer struct
|
|
//
|
|
typedef struct _IOCTL_EXPUNGE_NAME_OUT
|
|
{
|
|
//
|
|
// Signature for this struct
|
|
//
|
|
ULONG Signature;
|
|
|
|
//
|
|
// Status of operation
|
|
//
|
|
NTSTATUS Status;
|
|
|
|
} IOCTL_EXPUNGE_NAME_OUT, *PIOCTL_EXPUNGE_NAME_OUT;
|
|
|
|
//
|
|
// IOCTLs for UMR piece -
|
|
// 1. UMRX_PACKET IOCTLs will be pended for WORK requests/responses. These
|
|
// need to be pended on the Root\WIN32ROOT\$ namespace. The net root
|
|
// needs to have been initialized already.
|
|
//
|
|
// 2. TEARDOWN IOCTL will be sent when the UMR engine on the root needs to
|
|
// be shutdown. This should be done before the root is terminated.
|
|
// NOTE: process shutdown is auto-detected by the UMR engine.
|
|
//
|
|
// 3. STARTUP IOCTL will allow worker threads to queue up on the UMRX's KQUEUE
|
|
// It complements the TEARDOWN IOCTL
|
|
//
|
|
// 4. ENABLE_NET_ROOT IOCTL allows win32 usermode requests to be made from the
|
|
// netroot that this ioctl is being done on.
|
|
//
|
|
// 5. DISABLE_NET_ROOT IOCTL disallows win32 usermode requests to be made form the
|
|
// newroot that this ioctl is done on. Once the call to DeviceIoControl() returns
|
|
// there will be no more user mode requests made on that net root.
|
|
//
|
|
|
|
#define IOCTL_EXIFS_UMRX_PACKET _EXIFS_CONTROL_CODE(IOCTL_CODE_UMRX_PACKET, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_EXIFS_UMRX_TEARDOWN _EXIFS_CONTROL_CODE(IOCTL_CODE_UMRX_TEARDOWN, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define IOCTL_EXIFS_UMRX_STARTUP _EXIFS_CONTROL_CODE(IOCTL_CODE_UMRX_STARTUP, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// When enabling NetRoot's we get the current version number the netroot has squirreled away from when Jet initialized it !
|
|
//
|
|
#define IOCTL_EXIFS_UMRX_ENABLE_NET_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_UMRX_ENABLE_NET_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
typedef struct _IOCTL_EXIFS_UMRX_ENABLE_NET_ROOT_OUT
|
|
{
|
|
//
|
|
// Signature for this structre !
|
|
//
|
|
ULONG Signature ;
|
|
//
|
|
// Version of the netroot that should, be put in future open requests !
|
|
//
|
|
ULONG InstanceId ;
|
|
//
|
|
// Pointer to the netroot that should be put in future open responses !
|
|
//
|
|
ULONG NetRootPointer ;
|
|
//
|
|
// Save jets allocation size
|
|
//
|
|
ULONG AllocationUnit;
|
|
} IOCTL_EXIFS_UMRX_ENABLE_NET_ROOT_OUT, *PIOCTL_EXIFS_UMRX_ENABLE_NET_ROOT_OUT ;
|
|
|
|
|
|
#define IOCTL_EXIFS_UMRX_DISABLE_NET_ROOT _EXIFS_CONTROL_CODE(IOCTL_CODE_UMRX_DISABLE_NET_ROOT, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
//
|
|
// IMPORTANT NOTE :
|
|
//
|
|
// IOCTL_WIN32_FILENAME is EXACTLY 8 characters long because we will OVERWRITE
|
|
// it in the filenames that we put in the FCB. We will replace the 'IN32ROOT'
|
|
// portion with the hexadecimal version id coming off of the netroot for the
|
|
// particular file.
|
|
// Why ? Because this will cause dead FCB's to not hurt users across MDB Start/Stops
|
|
//
|
|
#define IOCTL_WIN32_FILENAME_START L"\\W"
|
|
#define IOCTL_WIN32_FILENAME L"\\WIN32ROOT"
|
|
#define WIN32_PREFIX_LEN (sizeof(IOCTL_WIN32_FILENAME)-sizeof(WCHAR))
|
|
#define WIN32_DIGIT_LEN (sizeof(IOCTL_WIN32_FILENAME) - sizeof(IOCTL_WIN32_FILENAME_START))
|
|
#define IOCTL_WIN32_UMRX_NAME L"\\WIN32ROOT\\$"
|
|
#define UMRX_PREFIX_LEN (sizeof(IOCTL_WIN32_UMRX_NAME)-2)
|
|
|
|
#define IFSWIN32SIGNATURE 'WIN3'
|
|
#define IFSJETSIGNATURE 'AJET'
|
|
|
|
typedef struct _IFS_CREATE_RESPONSE_
|
|
{
|
|
DWORD Signature;
|
|
NTSTATUS Status;
|
|
ULONG EaLength;
|
|
HANDLE hResponseContext;
|
|
PWSTR pEaSysBuffer;
|
|
PWSTR Win32Name;
|
|
}IFS_CREATE_RESPONSE, *PIFS_CREATE_RESPONSE;
|
|
|
|
#define IOCTL_EXIFS_REGISTER_UMR 200
|
|
|
|
typedef struct _SETEA_INFORMATION_
|
|
{
|
|
PVOID EaBuffer;
|
|
ULONG EaLength;
|
|
WCHAR FcbName[MAX_PATH * sizeof(WCHAR)];
|
|
}IOCTL_SETEA_INFORMATION_IN, *PIOCTL_SETEA_INFORMATION_IN;
|
|
|
|
#define IOCTL_CODE_SET_EA 900
|
|
#define IOCTL_EXIFS_SET_EA _EXIFS_CONTROL_CODE(IOCTL_CODE_SET_EA, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
typedef struct _GETEA_INFORMATION_
|
|
{
|
|
PVOID EaBuffer;
|
|
ULONG EaLength;
|
|
WCHAR FcbName[MAX_PATH];
|
|
}IOCTL_GETEA_INFORMATION_IN, *PIOCTL_GETEA_INFORMATION_IN;
|
|
|
|
#define IOCTL_CODE_QUERY_EA 1000
|
|
#define IOCTL_EXIFS_QUERY_EA _EXIFS_CONTROL_CODE(IOCTL_CODE_QUERY_EA, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
|
|
#endif // _EXIFS_H_
|
|
|