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