From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/inc/srvfsctl.h | 629 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 629 insertions(+) create mode 100644 private/inc/srvfsctl.h (limited to 'private/inc/srvfsctl.h') diff --git a/private/inc/srvfsctl.h b/private/inc/srvfsctl.h new file mode 100644 index 000000000..6144a6cd1 --- /dev/null +++ b/private/inc/srvfsctl.h @@ -0,0 +1,629 @@ +/*++ BUILD Version: 0001 // Increment this if a change has global effects + +Copyright (c) 1990 Microsoft Corporation + +Module Name: + + srvfsctl.h + +Abstract: + + This module defines I/O control codes and structures for the File + System Driver of the LAN Manager server. + +Author: + + David Treadwell (davidtr) 22-May-1990 + +Revision History: + +--*/ + +#ifndef _SRVFSCTL_ +#define _SRVFSCTL_ + + +// +// The name of the server device. +// + +#define SERVER_DEVICE_NAME TEXT("\\Device\\LanmanServer") + +// +// IRP control codes used to send requests to the server. These are +// used as parameters to NtFsControlFile, and may be found in +// Irp->Parameters.FsControl.FsControlCode in the server dispatch +// routine. +// +// Note that the low two bits of this code indicate the "method" in +// which the IO system uses the buffers passed by the user to +// NtFsControlFile. We use method 0--normal, buffered output (not +// DMA)--for non-API requests, and method 3--"neither" IO--for API +// requests that get processed in the server FSD. For the APIs +// that are processed in the server FSP, use method 0. +// +// !!! Add more as necessary. + +#define FSCTL_SRV_BASE FILE_DEVICE_NETWORK +#define FSCTL_SRV_API 1 << 11 + +#define _SRV_CONTROL_CODE(request,method) \ + ((FSCTL_SRV_BASE)<<12 | (request<<2) | method) + +#define _SRV_API_CONTROL_CODE(request) \ + ((FSCTL_SRV_BASE)<<12 | FSCTL_SRV_API | (request<<2) | METHOD_NEITHER ) + +#define SRV_API_INDEX(code) \ + ((code & ~(0xFFFFF000 | FSCTL_SRV_API)) >> 2) + +// +// Standard FSCTLs. +// + +#define FSCTL_SRV_STARTUP _SRV_CONTROL_CODE( 0, METHOD_NEITHER ) +#define FSCTL_SRV_SHUTDOWN _SRV_CONTROL_CODE( 1, METHOD_NEITHER ) +#define FSCTL_SRV_CLEAR_STATISTICS _SRV_CONTROL_CODE( 2, METHOD_BUFFERED ) +#define FSCTL_SRV_GET_STATISTICS _SRV_CONTROL_CODE( 3, METHOD_BUFFERED ) +#define FSCTL_SRV_SET_DEBUG _SRV_CONTROL_CODE( 4, METHOD_BUFFERED ) +#define FSCTL_SRV_XACTSRV_CONNECT _SRV_CONTROL_CODE( 5, METHOD_BUFFERED ) +#define FSCTL_SRV_SEND_DATAGRAM _SRV_CONTROL_CODE( 6, METHOD_NEITHER ) +#define FSCTL_SRV_SET_PASSWORD_SERVER _SRV_CONTROL_CODE( 7, METHOD_BUFFERED ) +#define FSCTL_SRV_START_SMBTRACE _SRV_CONTROL_CODE( 8, METHOD_BUFFERED ) +#define FSCTL_SRV_SMBTRACE_FREE_SMB _SRV_CONTROL_CODE( 9, METHOD_BUFFERED ) +#define FSCTL_SRV_END_SMBTRACE _SRV_CONTROL_CODE( 10, METHOD_BUFFERED ) +#define FSCTL_SRV_QUERY_CONNECTIONS _SRV_CONTROL_CODE( 11, METHOD_BUFFERED ) +#define FSCTL_SRV_PAUSE _SRV_CONTROL_CODE( 12, METHOD_NEITHER ) +#define FSCTL_SRV_CONTINUE _SRV_CONTROL_CODE( 13, METHOD_NEITHER ) +#define FSCTL_SRV_GET_CHALLENGE _SRV_CONTROL_CODE( 14, METHOD_BUFFERED ) +#define FSCTL_SRV_GET_DEBUG_STATISTICS _SRV_CONTROL_CODE( 15, METHOD_BUFFERED ) +#define FSCTL_SRV_XACTSRV_DISCONNECT _SRV_CONTROL_CODE( 16, METHOD_BUFFERED ) +#define FSCTL_SRV_REGISTRY_CHANGE _SRV_CONTROL_CODE( 17, METHOD_NEITHER ) +#define FSCTL_SRV_GET_QUEUE_STATISTICS _SRV_CONTROL_CODE( 18, METHOD_BUFFERED ) +#define FSCTL_SRV_SHARE_STATE_CHANGE _SRV_CONTROL_CODE( 19, METHOD_BUFFERED ) +#define FSCTL_SRV_BEGIN_PNP_NOTIFICATIONS _SRV_CONTROL_CODE(20, METHOD_BUFFERED ) + +// +// The following FSCTL can be issued by a kernel driver to hook into the server +// for accelerated direct host IPX performance. A pointer to an SRV_IPX_SMART_CARD +// structure is given for the START fsctl as the InputBuffer. + +#define FSCTL_SRV_IPX_SMART_CARD_START _SRV_CONTROL_CODE( 21, METHOD_NEITHER ) + +// +// API FSCTLs. +// +// *** The order of these must match the order of API processors in +// the SrvApiDispatchTable jump table defined in ntos\srv\srvdata.c! + +#define FSCTL_SRV_NET_CHARDEV_CONTROL _SRV_API_CONTROL_CODE( 0 ) +#define FSCTL_SRV_NET_CHARDEV_ENUM _SRV_API_CONTROL_CODE( 1 ) +#define FSCTL_SRV_NET_CHARDEVQ_ENUM _SRV_API_CONTROL_CODE( 2 ) +#define FSCTL_SRV_NET_CHARDEVQ_PURGE _SRV_API_CONTROL_CODE( 3 ) +#define FSCTL_SRV_NET_CHARDEVQ_SET_INFO _SRV_API_CONTROL_CODE( 4 ) +#define FSCTL_SRV_NET_CONNECTION_ENUM _SRV_API_CONTROL_CODE( 5 ) +#define FSCTL_SRV_NET_FILE_CLOSE _SRV_API_CONTROL_CODE( 6 ) +#define FSCTL_SRV_NET_FILE_ENUM _SRV_API_CONTROL_CODE( 7 ) +#define FSCTL_SRV_NET_SERVER_DISK_ENUM _SRV_API_CONTROL_CODE( 8 ) +#define FSCTL_SRV_NET_SERVER_SET_INFO _SRV_API_CONTROL_CODE( 9 ) +#define FSCTL_SRV_NET_SERVER_XPORT_ADD _SRV_API_CONTROL_CODE( 10 ) +#define FSCTL_SRV_NET_SERVER_XPORT_DEL _SRV_API_CONTROL_CODE( 11 ) +#define FSCTL_SRV_NET_SERVER_XPORT_ENUM _SRV_API_CONTROL_CODE( 12 ) +#define FSCTL_SRV_NET_SESSION_DEL _SRV_API_CONTROL_CODE( 13 ) +#define FSCTL_SRV_NET_SESSION_ENUM _SRV_API_CONTROL_CODE( 14 ) +#define FSCTL_SRV_NET_SHARE_ADD _SRV_API_CONTROL_CODE( 15 ) +#define FSCTL_SRV_NET_SHARE_DEL _SRV_API_CONTROL_CODE( 16 ) +#define FSCTL_SRV_NET_SHARE_ENUM _SRV_API_CONTROL_CODE( 17 ) +#define FSCTL_SRV_NET_SHARE_SET_INFO _SRV_API_CONTROL_CODE( 18 ) +#define FSCTL_SRV_NET_STATISTICS_GET _SRV_API_CONTROL_CODE( 19 ) +#define FSCTL_SRV_MAX_API_CODE FSCTL_SRV_NET_STATISTICS_GET + +// +// Startup information level +// + +#define SS_STARTUP_LEVEL -1L + +#ifdef INCLUDE_SRV_IPX_SMART_CARD_INTERFACE + +// +// Structure passed to the srv via the FSCTL_SRV_IPX_SMART_CARD_START call by an +// intelligent direct host IPX card. The Smart card fills in its own +// Open, Close, Read, and DeRegister entry points - which the server +// calls at the appropriate times. The server fills in its own +// ReadComplete entry point which the smart card calls when it is done +// transferring the data to the client. +// +typedef struct { + // + // This routine is called by the server when it is opening a file on + // behalf of a direct host IPX client. It gives the smart card a chance + // to decide it it wants to help with file access. If the smart card is + // interested, it should return TRUE and set SmartCardContext to a + // non-zero value of its choice. + // + BOOLEAN (* Open)( + IN PVOID SmbHeader, // Points to request PNT_SMB_HEADER + IN PFILE_OBJECT FileObject, // FileObject opened by the client + IN PUNICODE_STRING FileName, // Name of the file opened by the client + IN PTDI_ADDRESS_IPX IpxAddress, // Address of the client + IN ULONG Flags, // FO_CACHE_SUPPORTED (for now) + OUT PVOID *SmartCardContext // Context value returned by this routine + ); + + // + // This is called by the server when the file is being closed. The context + // value received at Open time is passed to this routine. + // + VOID ( * Close )( + IN PVOID SmartCardContext // Same context returned by Open() above + ); + + // + // This is called by the server to see if the smart card wishes to handle the + // client's read request. If the card is handling the read, it should return + // TRUE and the server will discontinue processing the read. When the card is + // finished handling the read, it must call ReadComplete (below) to inform the + // server. If Read returns FALSE, the server handles the read as usual. + // + BOOLEAN ( * Read )( + IN PVOID SmbHeader, // Points to request PNT_SMB_HEADER + IN PVOID SmartCardContext, // Same context returned by Open() above + IN ULONG Key, // Key value needed to read through locks + IN PVOID SrvContext // Opaque value provided by the server + ); + + // + // This is the server's entry point which the smart card must call when it is + // finished handling the Read request (above). + // + VOID ( * ReadComplete )( + IN PVOID SrvContext, // Same as SrvContext in Read() above + IN PFILE_OBJECT FileObject, // Client FileObject to which this applies + IN PMDL Mdl OPTIONAL, // Mdl smart card is now finished with + IN ULONG Length // Length of data indicated by the MDL + ); + + // + // This is called by the server when the server wishes to disconnect from the + // card. Once this returns, the card should not call back into the server. + // + VOID ( *DeRegister )( + VOID + ); + + +} SRV_IPX_SMART_CARD, *PSRV_IPX_SMART_CARD; + +#endif + +// +// SMB_STATISTICS holds the count of SMBs and total turn around for a +// class of SMBs. For example, a single SMB_STATISTIC structure could +// hold information about all read SMBs: Read, ReadAndX, ReadRaw, +// and ReadMultiplexed. +// + +typedef struct _SMB_STATISTICS { + LARGE_INTEGER TotalTurnaroundTime; + ULONG SmbCount; +} SMB_STATISTICS, *PSMB_STATISTICS; + +// +// Used to record the number of times something happened and some +// pertinent time measure. +// + +typedef struct _SRV_TIMED_COUNTER { + LARGE_INTEGER Time; + ULONG Count; +} SRV_TIMED_COUNTER, *PSRV_TIMED_COUNTER; + +// +// SRV_POOL_STATISTICS is used for tracking server pool usage, paged and +// nonpaged. It is only enabled with SRVDBG2 and is controlled in the +// server module heapmgr.c. +// + +typedef struct _SRV_POOL_STATISTICS { + ULONG TotalBlocksAllocated; + ULONG TotalBytesAllocated; + ULONG TotalBlocksFreed; + ULONG TotalBytesFreed; + ULONG BlocksInUse; + ULONG BytesInUse; + ULONG MaxBlocksInUse; + ULONG MaxBytesInUse; +} SRV_POOL_STATISTICS, *PSRV_POOL_STATISTICS; + +// +// BLOCK_COUNTS is used to maintain statistics on server block types +// + +typedef struct _BLOCK_COUNTS { + ULONG Allocations; + ULONG Closes; + ULONG Frees; +} BLOCK_COUNTS, *PBLOCK_COUNTS; + +#define MAX_NON_TRANS_SMB 0x84 + +#ifndef TRANS2_MAX_FUNCTION +#define TRANS2_MAX_FUNCTION 0x11 +#endif + +#define MAX_STATISTICS_SMB MAX_NON_TRANS_SMB + TRANS2_MAX_FUNCTION + 1 + +// +// SRV_STATISTICS is the structure returned to the FSCTL_GET_STATISTICS +// fsctl. +// + +typedef struct _SRV_STATISTICS { + + // + // The time at which statistics gathering began (or stats were last + // cleared). + // + + TIME StatisticsStartTime; + + // + // Large integer counts of bytes received and sent + // + + LARGE_INTEGER TotalBytesReceived; + LARGE_INTEGER TotalBytesSent; + + // + // Causes of session termination + // + + ULONG SessionLogonAttempts; + ULONG SessionsTimedOut; + ULONG SessionsErroredOut; + ULONG SessionsLoggedOff; + ULONG SessionsForcedLogOff; + + // + // Misc. Errors + // + + ULONG LogonErrors; + ULONG AccessPermissionErrors; + ULONG GrantedAccessErrors; + ULONG SystemErrors; + ULONG BlockingSmbsRejected; + ULONG WorkItemShortages; + + // + // Cumulative counts of various statistics. Note that when stats are + // cleared, those "Total" fields which have a "Current" equivalent + // are set to the "Current" value to avoid situations where the + // current count is greater than the total. + // + + ULONG TotalFilesOpened; + + ULONG CurrentNumberOfOpenFiles; + ULONG CurrentNumberOfSessions; + ULONG CurrentNumberOfOpenSearches; + + // + // Memory usage stats we want to xport + // + + ULONG CurrentNonPagedPoolUsage; + ULONG NonPagedPoolFailures; + ULONG PeakNonPagedPoolUsage; + + ULONG CurrentPagedPoolUsage; + ULONG PagedPoolFailures; + ULONG PeakPagedPoolUsage; + + + // + // Used to record the number of times work context blocks were placed + // on the server's FSP queue and the total amount of time they spent + // there. + // + + SRV_TIMED_COUNTER TotalWorkContextBlocksQueued; + + +} SRV_STATISTICS, *PSRV_STATISTICS; + +// +// Per work-queue statistics for the server. There is a workqueue for each +// processor in the system for nonblocking work, and a single workqueue for +// blocking work. +// +// These statistics are retrieved via FSCTL_SRV_GET_QUEUE_STATISTICS to the +// server driver. For an N-processor system, the first N structs are per-processor, +// the N+1'th struct is for the blocking work queue. +// +typedef struct _SRV_QUEUE_STATISTICS { + ULONG QueueLength; // current length of the workitem queue + ULONG ActiveThreads; // # of threads currently servicing requests + ULONG AvailableThreads; // # of threads waiting for work + ULONG FreeWorkItems; // # of free work items + ULONG StolenWorkItems; // # of work items taken from this free list + // by another queue + ULONG NeedWorkItem; // # of work items we are currently short for this queue + ULONG CurrentClients; // # of clients being serviced by this queue + LARGE_INTEGER BytesReceived; // # of bytes in from the network to clients on this queue + LARGE_INTEGER BytesSent; // # of bytes sent to the network from clients on this queue + LARGE_INTEGER ReadOperations; // # file read operations by clients on this queue + LARGE_INTEGER BytesRead; // # of data bytes read from files by clients on this queue + LARGE_INTEGER WriteOperations; // # of file write ops by clients on this queue + LARGE_INTEGER BytesWritten; // # of data bytes written to files by clients on this queue + SRV_TIMED_COUNTER TotalWorkContextBlocksQueued; // as above, but per-queue + +} SRV_QUEUE_STATISTICS, *PSRV_QUEUE_STATISTICS; + +// +// SRV_STATISTICS_DEBUG is the structure used for the +// FSCTL_SRV_GET_DEBUG_STATISTICS fsctl. This structure is valid +// only when SRVDBG3 is set. +// + +typedef struct _SRV_STATISTICS_DEBUG { + + // + // Large integer counts of bytes read and written. + // + + LARGE_INTEGER TotalBytesRead; + LARGE_INTEGER TotalBytesWritten; + + // + // Raw reads and writes statistics + // + + ULONG RawWritesAttempted; + ULONG RawWritesRejected; + ULONG RawReadsAttempted; + ULONG RawReadsRejected; + + // + // Cumulative count of time spent opening files and closing handles. + // + + LARGE_INTEGER TotalIoCreateFileTime; + LARGE_INTEGER TotalNtCloseTime; + + ULONG TotalHandlesClosed; + ULONG TotalOpenAttempts; + ULONG TotalOpensForPathOperations; + ULONG TotalOplocksGranted; + ULONG TotalOplocksDenied; + ULONG TotalOplocksBroken; + ULONG OpensSatisfiedWithCachedRfcb; + + ULONG FastLocksAttempted; + ULONG FastLocksFailed; + ULONG FastReadsAttempted; + ULONG FastReadsFailed; + ULONG FastUnlocksAttempted; + ULONG FastUnlocksFailed; + ULONG FastWritesAttempted; + ULONG FastWritesFailed; + + ULONG DirectSendsAttempted; + + ULONG LockViolations; + ULONG LockDelays; + + ULONG CoreSearches; + ULONG CompleteCoreSearches; + + // + // information about block types + // + + BLOCK_COUNTS ConnectionInfo; + BLOCK_COUNTS EndpointInfo; + BLOCK_COUNTS LfcbInfo; + BLOCK_COUNTS MfcbInfo; + BLOCK_COUNTS RfcbInfo; + BLOCK_COUNTS SearchInfo; + BLOCK_COUNTS SessionInfo; + BLOCK_COUNTS ShareInfo; + BLOCK_COUNTS TransactionInfo; + BLOCK_COUNTS TreeConnectInfo; + BLOCK_COUNTS WorkContextInfo; + BLOCK_COUNTS WaitForOplockBreakInfo; + + // + // Statistics for different read and write sizes. Each element of + // the array corresponds to a range of IO sizes; see srv\smbsupp.c + // for exact correspondences. + // + + SMB_STATISTICS ReadSize[17]; + SMB_STATISTICS WriteSize[17]; + + // + // Statistics for each SMB type by command code. + // + + SMB_STATISTICS Smb[MAX_STATISTICS_SMB+2+TRANS2_MAX_FUNCTION+1]; + + struct { + ULONG Depth; + ULONG Threads; + ULONG ItemsQueued; + ULONG MaximumDepth; + } QueueStatistics[3]; + +} SRV_STATISTICS_DEBUG, *PSRV_STATISTICS_DEBUG; + +// +// SET DEBUG input and output structure. Contains off/on masks for SrvDebug +// and SmbDebug. The off mask is applied first, then the on mask is +// applied. To set the entire mask to a specific value, set the off +// mask to all ones, and set the on mask to the desired value. To leave +// a mask unchanged, set both masks to 0. SET DEBUG is also used +// to modify other server heuristics. HeuristicsChangeMask is used to +// indicate which heuristics are being changed. +// +// On output, the structure is presented in such a way as to allow the +// original values to be restored easily. The output data is simply +// passed back as input data. +// + +typedef struct _FSCTL_SRV_SET_DEBUG_IN_OUT { + ULONG SrvDebugOff; + ULONG SrvDebugOn; + ULONG SmbDebugOff; + ULONG SmbDebugOn; + ULONG CcDebugOff; + ULONG CcDebugOn; + ULONG PbDebugOff; + ULONG PbDebugOn; + ULONG FatDebugOff; + ULONG FatDebugOn; + ULONG HeuristicsChangeMask; + ULONG MaxCopyReadLength; + ULONG MaxCopyWriteLength; + ULONG DumpVerbosity; + ULONG DumpRawLength; + BOOLEAN EnableOplocks; + BOOLEAN EnableFcbOpens; + BOOLEAN EnableSoftCompatibility; + BOOLEAN EnableRawMode; + BOOLEAN EnableDpcLevelProcessing; + BOOLEAN EnableMdlIo; + BOOLEAN EnableFastIo; + BOOLEAN DumpRequests; + BOOLEAN DumpResponses; +} FSCTL_SRV_SET_DEBUG_IN_OUT, *PFSCTL_SRV_SET_DEBUG_IN_OUT; + +// +// Bit assignments for server heuristics change mask. The first group +// contains those that are values, while the second group contains those +// that are booleans. +// + +#define SRV_HEUR_MAX_COPY_READ 0x00000001 +#define SRV_HEUR_MAX_COPY_WRITE 0x00000002 +#define SRV_HEUR_DUMP_VERBOSITY 0x00000004 +#define SRV_HEUR_DUMP_RAW_LENGTH 0x00000008 + +#define SRV_HEUR_OPLOCKS 0x00010000 +#define SRV_HEUR_FCB_OPENS 0x00020000 +#define SRV_HEUR_SOFT_COMPATIBILITY 0x00040000 +#define SRV_HEUR_RAW_MODE 0x00080000 +#define SRV_HEUR_DPC_LEVEL_PROCESSING 0x00100000 +#define SRV_HEUR_MDL_IO 0x00200000 +#define SRV_HEUR_FAST_IO 0x00400000 +#define SRV_HEUR_DUMP_REQUESTS 0x00800000 +#define SRV_HEUR_DUMP_RESPONSES 0x01000000 + +// +// Structure returned in response to FSCTL_SRV_QUERY_CONNECTIONS. +// + +typedef struct _BLOCK_INFORMATION { + PVOID Block; + ULONG BlockType; + ULONG BlockState; + ULONG ReferenceCount; +} BLOCK_INFORMATION, *PBLOCK_INFORMATION; + +// +// Structure for communication between the file server and the server +// service. +// + +typedef struct _SERVER_REQUEST_PACKET { + + UNICODE_STRING Name1; + UNICODE_STRING Name2; + ULONG Level; + ULONG ErrorCode; + ULONG Flags; + + union { + + struct { + + ULONG EntriesRead; + ULONG TotalEntries; + ULONG TotalBytesNeeded; + ULONG ResumeHandle; + + } Get; + + struct { + + ULONG ErrorParameter; + + union { + + struct { + ULONG MaxUses; + } ShareInfo; + + } Api; + + } Set; + + } Parameters; + +} SERVER_REQUEST_PACKET, *PSERVER_REQUEST_PACKET; + +// +// Flags for the Flags field of the server request packet. +// + +#define SRP_RETURN_SINGLE_ENTRY 0x01 +#define SRP_CLEAR_STATISTICS 0x02 +#define SRP_SET_SHARE_IN_DFS 0x04 +#define SRP_CLEAR_SHARE_IN_DFS 0x08 + +// +// Flag used in the XPORT_ADD function +// + +#define SRP_XADD_PRIMARY_MACHINE 0x1 // this is the primary machine name + +// +// #defines for the share GENERIC_MAPPING structure, which must be available +// to both the server and the server service. +// + +#define SRVSVC_SHARE_CONNECT 0x0001 +#define SRVSVC_PAUSED_SHARE_CONNECT 0x0002 + +#define SRVSVC_SHARE_CONNECT_ALL_ACCESS ( STANDARD_RIGHTS_REQUIRED | \ + SRVSVC_SHARE_CONNECT | \ + SRVSVC_PAUSED_SHARE_CONNECT ) + +#define GENERIC_SHARE_CONNECT_MAPPING { \ + STANDARD_RIGHTS_READ | \ + SRVSVC_SHARE_CONNECT, \ + STANDARD_RIGHTS_WRITE | \ + SRVSVC_PAUSED_SHARE_CONNECT, \ + STANDARD_RIGHTS_EXECUTE, \ + SRVSVC_SHARE_CONNECT_ALL_ACCESS } + +// +// #defines for the file GENERIC_MAPPING structure, which must be available +// to both the server and the server service. This structure is identical +// to the io file generic mapping "IopFileMapping" defined in io\ioinit.c +// + +#define GENERIC_SHARE_FILE_ACCESS_MAPPING { \ + FILE_GENERIC_READ, \ + FILE_GENERIC_WRITE, \ + FILE_GENERIC_EXECUTE, \ + FILE_ALL_ACCESS } + +// +// Special cases of STYPE_DISKTREE +// + +#define STYPE_CDROM 104 +#define STYPE_REMOVABLE 105 + +#endif // ndef _SRVFSCTL_ -- cgit v1.2.3