You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
598 lines
14 KiB
598 lines
14 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
msstruc.h
|
|
|
|
Abstract:
|
|
|
|
This module defines the data structures that make up the major internal
|
|
part of the mailslot file system.
|
|
|
|
Author:
|
|
|
|
Manny Weiser (mannyw) 7-Jan-1991
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef _MSSTRUC_
|
|
#define _MSSTRUC_
|
|
|
|
|
|
//
|
|
// The VCB record is the top record in the mailslot file system in-memory
|
|
// data structure. This structure must be allocated from non-paged pool
|
|
// and immediately follows (in memory) the Device object for the mailslot
|
|
// Structurally the layout of the data structure is as follows
|
|
//
|
|
// +------------+
|
|
// |MSDO |
|
|
// | |
|
|
// +------------+
|
|
// |Vcb |
|
|
// | |
|
|
// | |
|
|
// +------------+
|
|
// | ^
|
|
// | |
|
|
// | |
|
|
// v |
|
|
// +-------------+
|
|
// |RootDcb |
|
|
// | |<-+
|
|
// +-------------+ |
|
|
// : |
|
|
// : |
|
|
// : |
|
|
// v |
|
|
// +----------------+ +-------------------+
|
|
// |Fcb | |Ccb |
|
|
// | |<---| |
|
|
// | | | |
|
|
// +----------------+ +-------------------+
|
|
// ^ ^
|
|
// | |
|
|
// +---------+ +---------+
|
|
// |Server FO| |Client FO|
|
|
// | | | |
|
|
// +---------+ +---------+
|
|
//
|
|
//
|
|
// Where there is only one VCB for the entire mailslot file system, and
|
|
// it contains a single pointer to the root DCB for the file system. Off
|
|
// of the DCB is a queue of FCB's. There is one FCB for every mailslot.
|
|
// There are also two additional CCB types for the VCB and the root DCB,
|
|
// and notify records for the notify change operations.
|
|
//
|
|
// A newly initialized mailslot file system only contains the VCB and
|
|
// the root DCB. A new FCB is created when a new mailslot is created
|
|
// The file object for the creater (i.e., server end) points to the FCB
|
|
// and indicates that it is the server end. When a user does an open on
|
|
// the mailslot its file object is set to point to a CCB which belongs
|
|
// to the FCB.
|
|
//
|
|
// A file object with a null pointer to the FsContext field is a closed or
|
|
// disconnected mailslot.
|
|
//
|
|
|
|
|
|
//
|
|
// Each Fcb has a data queues for holding the outstanding
|
|
// read/write requests. The following type is used to determine
|
|
// if the data queue contains read requests, write requests, or is empty.
|
|
//
|
|
|
|
typedef enum _QUEUE_STATE {
|
|
ReadEntries,
|
|
WriteEntries,
|
|
Empty
|
|
} QUEUE_STATE;
|
|
|
|
//
|
|
// The node state.
|
|
//
|
|
// Currently only 2 states are defined. When a node is created it's state
|
|
// is NodeStateActive. When a cleanup IRP is processed, it set the node
|
|
// state of the corresponding node to NodeStateClosing. Only the close
|
|
// IRP can get processed on this node.
|
|
//
|
|
|
|
typedef enum _NODE_STATE {
|
|
NodeStateActive,
|
|
NodeStateClosing
|
|
} NODE_STATE;
|
|
|
|
//
|
|
// The types of data entry there are. Each corresponds to an IRP
|
|
// that can be added to a data queue.
|
|
//
|
|
|
|
typedef enum _ENTRY_TYPE {
|
|
Read,
|
|
ReadMailslot,
|
|
Write,
|
|
WriteMailslot,
|
|
Peek
|
|
} ENTRY_TYPE;
|
|
|
|
//
|
|
// The data queue is a structure that contains the queue state, quota
|
|
// information, and the list head. The quota information is used to
|
|
// maintain mailslot quota.
|
|
//
|
|
|
|
typedef struct _DATA_QUEUE {
|
|
|
|
//
|
|
// The current state of what is contained in this data queue,
|
|
// how many bytes of read/write data there are, and how many individual
|
|
// requests there are in the queue that contain data (includes
|
|
// close or flush requests).
|
|
//
|
|
|
|
QUEUE_STATE QueueState;
|
|
ULONG BytesInQueue;
|
|
ULONG EntriesInQueue;
|
|
|
|
//
|
|
// The following two fields denote who much quota was reserved for
|
|
// this mailslot and how much we've used up. This is only
|
|
// the creator quota and not the user quota.
|
|
//
|
|
|
|
ULONG Quota;
|
|
ULONG QuotaUsed;
|
|
|
|
|
|
//
|
|
// The size of the largest message that can be written to
|
|
// this data queue.
|
|
//
|
|
|
|
ULONG MaximumMessageSize;
|
|
|
|
//
|
|
// The queue of data entries.
|
|
//
|
|
|
|
LIST_ENTRY DataEntryList;
|
|
|
|
|
|
} DATA_QUEUE, *PDATA_QUEUE;
|
|
|
|
//
|
|
// The following type is used to denote where we got the memory for the
|
|
// data entry and possibly the data buffer. We either got the memory
|
|
// from the mailslot quota, the user quota, or it is part of the next IRP
|
|
// stack location.
|
|
//
|
|
|
|
typedef enum _FROM {
|
|
MailslotQuota,
|
|
UserQuota,
|
|
InIrp
|
|
} FROM;
|
|
|
|
//
|
|
// Each entry in the data queue is a data entry. Processing an IRP
|
|
// has the potential of creating and inserting a new data entry. If the
|
|
// memory for the entry is taken from the IRP we use the current stack
|
|
// location.
|
|
//
|
|
|
|
typedef struct _DATA_ENTRY {
|
|
|
|
//
|
|
// Where the data buffer came from
|
|
//
|
|
|
|
UCHAR From;
|
|
CHAR Spare1;
|
|
USHORT Spare2;
|
|
|
|
//
|
|
// The following field is how we connect into the queue of data entries
|
|
//
|
|
|
|
LIST_ENTRY ListEntry;
|
|
|
|
//
|
|
// The following field indicates if we still have an IRP associated
|
|
// with this data entry that need to be completed when the remove
|
|
// the data entry. Note that if From is InIrp that this IRP field
|
|
// must not be null.
|
|
//
|
|
|
|
PIRP Irp;
|
|
|
|
//
|
|
// The following two fields describe the size and location of the data
|
|
// buffer described by this entry. These fields are only used if the
|
|
// type is buffered, and are ignored otherwise.
|
|
//
|
|
|
|
ULONG DataSize;
|
|
PVOID DataPointer;
|
|
|
|
//
|
|
// Used for read data entries only. A pointer to the work context
|
|
// of the time out.
|
|
//
|
|
|
|
struct _WORK_CONTEXT *TimeoutWorkContext;
|
|
|
|
} DATA_ENTRY, *PDATA_ENTRY;
|
|
|
|
|
|
|
|
//
|
|
// The node header is used to manage standard nodes within MSFS.
|
|
//
|
|
|
|
typedef struct _NODE_HEADER {
|
|
|
|
NODE_TYPE_CODE NodeTypeCode; // The node type
|
|
NODE_BYTE_SIZE NodeByteSize; // The size of the node
|
|
NODE_STATE NodeState; // The current node state
|
|
ULONG ReferenceCount; // Number of active references to the node
|
|
|
|
} NODE_HEADER, *PNODE_HEADER;
|
|
|
|
typedef struct _VCB {
|
|
|
|
NODE_HEADER Header;
|
|
|
|
//
|
|
// The filesystem name
|
|
//
|
|
|
|
UNICODE_STRING FileSystemName;
|
|
|
|
//
|
|
// The time we created the volume
|
|
//
|
|
LARGE_INTEGER CreationTime;
|
|
|
|
//
|
|
// A pointer to the root DCB for this volume
|
|
//
|
|
|
|
struct _FCB *RootDcb;
|
|
|
|
//
|
|
// A prefix table that is used for quick, prefix directed, lookup of
|
|
// FCBs/DCBs that are part of this volume
|
|
//
|
|
|
|
UNICODE_PREFIX_TABLE PrefixTable;
|
|
|
|
//
|
|
// A resource variable to control access to the volume specific data
|
|
// structures
|
|
//
|
|
|
|
ERESOURCE Resource;
|
|
|
|
//
|
|
// The following field is used to check share access people who want
|
|
// to open the mailslot driver
|
|
//
|
|
|
|
SHARE_ACCESS ShareAccess;
|
|
|
|
} VCB, *PVCB;
|
|
|
|
|
|
//
|
|
// The Mailslot Device Object is an I/O system device object with
|
|
// additional workqueue parameters appended to the end. There is only
|
|
// one of these records created for the entire system during system
|
|
// initialization. The workqueue is used by the FSD to post requests to
|
|
// the filesystem.
|
|
//
|
|
|
|
typedef struct _MSFS_DEVICE_OBJECT {
|
|
|
|
DEVICE_OBJECT DeviceObject;
|
|
|
|
//
|
|
// This is the file system specific volume control block.
|
|
//
|
|
|
|
VCB Vcb;
|
|
|
|
} MSFS_DEVICE_OBJECT, *PMSFS_DEVICE_OBJECT;
|
|
|
|
|
|
//
|
|
// The Fcb/Dcb record corresponds to every opened mailslot and directory,
|
|
// and to every directory on an opened path.
|
|
//
|
|
|
|
typedef struct _FCB {
|
|
|
|
//
|
|
// Header.NodeTypeCode of this record (must be MSFS_NTC_FCB, or
|
|
// MSFS_NTC_ROOT_DCB)
|
|
//
|
|
|
|
NODE_HEADER Header;
|
|
|
|
//
|
|
// The links for the queue of all fcbs for a specific DCB off of
|
|
// Dcb.ParentDcbQueue. For the root directory this queue is empty.
|
|
//
|
|
|
|
LIST_ENTRY ParentDcbLinks;
|
|
|
|
//
|
|
// A pointer to the Dcb that is the parent directory containing
|
|
// this FCB. If this record itself is the root dcb then this field
|
|
// is null.
|
|
//
|
|
|
|
struct _FCB *ParentDcb;
|
|
|
|
//
|
|
// A pointer to the VCB containing this FCB.
|
|
//
|
|
|
|
PVCB Vcb;
|
|
|
|
//
|
|
// Back pointer to the server's file object.
|
|
//
|
|
|
|
PFILE_OBJECT FileObject;
|
|
|
|
//
|
|
// A pointer to the security descriptor for this mailslot.
|
|
//
|
|
|
|
PSECURITY_DESCRIPTOR SecurityDescriptor;
|
|
|
|
//
|
|
// The following union is cased off of the node type code for the FCB.
|
|
// is a seperate case for the directory versus file FCBs.
|
|
//
|
|
|
|
union {
|
|
|
|
//
|
|
// A Directory Control Block (DCB)
|
|
//
|
|
|
|
struct {
|
|
|
|
//
|
|
// A queue of the notify IRPs that will be completed when any
|
|
// change is made to a file in the directory. Queued using
|
|
// the Tail.Overlay.ListEntry of the IRP.
|
|
//
|
|
|
|
LIST_ENTRY NotifyFullQueue;
|
|
|
|
//
|
|
// A queue of the notify IRPs that will be completed only if a
|
|
// file is added, deleted, or renamed in the directory. Queued
|
|
// using the Tail.Overlay.ListEntry of the IRP.
|
|
//
|
|
|
|
LIST_ENTRY NotifyPartialQueue;
|
|
|
|
//
|
|
// A queue of all the FCBs/DCBs that are opened under this
|
|
// DCB.
|
|
//
|
|
|
|
LIST_ENTRY ParentDcbQueue;
|
|
|
|
|
|
//
|
|
// Spinlock to protect the queues above that contain cancelable IRPs. We can't
|
|
// synchronize with a resource because IoCancelIrp can be called at DISPATCH_LEVEL.
|
|
//
|
|
|
|
KSPIN_LOCK SpinLock;
|
|
} Dcb;
|
|
|
|
//
|
|
// A File Control Block (FCB)
|
|
//
|
|
|
|
struct {
|
|
|
|
//
|
|
// The following field is a queue head for a list of CCBs
|
|
// that are opened under us.
|
|
//
|
|
|
|
LIST_ENTRY CcbQueue;
|
|
|
|
//
|
|
// The default read timeout. This is always a relative value.
|
|
//
|
|
|
|
LARGE_INTEGER ReadTimeout;
|
|
|
|
//
|
|
// File timestamps.
|
|
//
|
|
|
|
LARGE_INTEGER CreationTime;
|
|
LARGE_INTEGER LastModificationTime;
|
|
LARGE_INTEGER LastAccessTime;
|
|
LARGE_INTEGER LastChangeTime;
|
|
|
|
} Fcb;
|
|
|
|
} Specific;
|
|
|
|
//
|
|
// The following field is used to check share access for
|
|
// clients that want to open the file/directory.
|
|
//
|
|
|
|
SHARE_ACCESS ShareAccess;
|
|
|
|
//
|
|
// The following field is the fully qualified file name for this FCB/DCB
|
|
// starting from the root of the volume, and last file name in the
|
|
// fully qualified name.
|
|
//
|
|
|
|
UNICODE_STRING FullFileName;
|
|
UNICODE_STRING LastFileName;
|
|
|
|
//
|
|
// The following field contains a prefix table entry that is used when
|
|
// searching a volume for a name (or longest matching prefix)
|
|
//
|
|
|
|
UNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry;
|
|
|
|
|
|
//
|
|
// The following field is used to remember the process that created this
|
|
// mailslot. It is needed to allocate quota and return quota.
|
|
//
|
|
|
|
PEPROCESS CreatorProcess;
|
|
|
|
//
|
|
// The following data queue is used to contain the buffered information
|
|
// for the mailslot.
|
|
//
|
|
|
|
DATA_QUEUE DataQueue;
|
|
|
|
//
|
|
// A resource variable to control access to the File specific data
|
|
// structures
|
|
//
|
|
|
|
ERESOURCE Resource;
|
|
|
|
} FCB, DCB, ROOT_DCB, *PFCB, *PDCB, *PROOT_DCB;
|
|
|
|
|
|
|
|
//
|
|
// The CCB record is allocated for every cliennt side open of a mailslot.
|
|
//
|
|
|
|
typedef struct _CCB {
|
|
|
|
//
|
|
// Header.NodeTypeCode of this record (must be MSFS_NTC_CCB).
|
|
//
|
|
|
|
NODE_HEADER Header;
|
|
|
|
//
|
|
// The following field is a list entry for the list of ccb that we
|
|
// are a member of.
|
|
//
|
|
|
|
LIST_ENTRY CcbLinks;
|
|
|
|
//
|
|
// A pointer to the FCB, or VCB that we are tied to
|
|
//
|
|
|
|
PFCB Fcb;
|
|
|
|
//
|
|
// Pointers to the file object of the client has opened this file.
|
|
//
|
|
|
|
PFILE_OBJECT FileObject;
|
|
|
|
//
|
|
// A resource to control access to the CCB.
|
|
//
|
|
|
|
ERESOURCE Resource;
|
|
|
|
} CCB, *PCCB;
|
|
|
|
|
|
//
|
|
// The root DCB CCB record is allocated for every opened instance of the
|
|
// root dcb. This record is pointed at by FsContext2.
|
|
//
|
|
|
|
typedef struct _ROOT_DCB_CCB {
|
|
|
|
//
|
|
// Header.NodeTypeCode of this record (must be MSFS_NTC_ROOT_DCB_CCB).
|
|
//
|
|
|
|
NODE_HEADER Header;
|
|
|
|
//
|
|
// A pointer to the VCB containing this CCB.
|
|
//
|
|
|
|
PVCB Vcb;
|
|
|
|
//
|
|
// Pointer to the DCB for this CCB
|
|
//
|
|
PROOT_DCB Dcb;
|
|
|
|
//
|
|
// The following field is a count of the last index returned
|
|
// by query directory.
|
|
//
|
|
|
|
ULONG IndexOfLastCcbReturned;
|
|
|
|
//
|
|
// The following string is used as a query template for directory
|
|
// query operations
|
|
//
|
|
|
|
PUNICODE_STRING QueryTemplate;
|
|
|
|
} ROOT_DCB_CCB, *PROOT_DCB_CCB;
|
|
|
|
//
|
|
// A work context contains the information needed to do read timeouts.
|
|
//
|
|
|
|
typedef struct _WORK_CONTEXT {
|
|
|
|
//
|
|
// Pointer to unload safe work item.
|
|
//
|
|
|
|
PIO_WORKITEM WorkItem;
|
|
|
|
//
|
|
// A pointer to the IRP for this operation.
|
|
//
|
|
|
|
PIRP Irp;
|
|
|
|
//
|
|
// A referenced pointer to the FCB that will process this operation.
|
|
//
|
|
|
|
PFCB Fcb;
|
|
|
|
//
|
|
// A timer and dpc tourine to accomplish the timeout.
|
|
//
|
|
|
|
KTIMER Timer;
|
|
|
|
KDPC Dpc;
|
|
|
|
} WORK_CONTEXT, *PWORK_CONTEXT;
|
|
|
|
#endif // _MSSTRUC_
|