/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    RxStruc.h

Abstract:

    This module defines the data structures that make up the major internal
    part of the Rx file system.

Author:

    Gary Kimura     [GaryKi]    28-Dec-1989

Revision History:

    Joe Linn        [joelinn]   aug-1994 moved over to rdbss

--*/

#ifndef _RDBSSSTRUC_
#define _RDBSSSTRUC_

#include "prefix.h"
#include "lowio.h"
#include "scavengr.h"      // scavenger related definitions.
#include "RxContx.h"
#include "mrx.h"
#include "Fcb.h"

//define our byte offsets to be the full 64 bits
typedef LONGLONG RXVBO;

#if 0
//
//  Define who many freed structures we are willing to keep around
//

#define FREE_FOBX_SIZE                   (8)
#define FREE_FCB_SIZE                    (8)
#define FREE_NON_PAGED_FCB_SIZE          (8)

#define FREE_128_BYTE_SIZE               (16)
#define FREE_256_BYTE_SIZE               (16)
#define FREE_512_BYTE_SIZE               (16)
#endif //0


//
//  We will use both a common and private dispatch tables on a per FCB basis to (a) get
//  some encapsulation and (b) [less important] go a little faster. The driver table then gets
//  optimized for the most common case. Right now we just use the common dispatch...later and
//  Eventually, all the FCBs will have pointers to optimized dispatch tables.
//

//  used to synchronize access to  rxcontxs and structures

extern RX_SPIN_LOCK RxStrucSupSpinLock;


typedef struct _RDBSS_EXPORTS {
    RX_SPIN_LOCK             *pRxStrucSupSpinLock;
    PLONG                    pRxDebugTraceIndent;
} RDBSS_EXPORTS, *PRDBSS_EXPORTS;

extern RDBSS_EXPORTS RxExports;

// this type is used with table locks to track whether or not the lock
// should be released

typedef enum _LOCK_HOLDING_STATE {
    LHS_LockNotHeld,
    LHS_SharedLockHeld,
    LHS_ExclusiveLockHeld
} LOCK_HOLDING_STATE;

//
//  The RDBSS_DATA record is the top record in the Rx file system in-memory
//  data structure.  This structure must be allocated from non-paged pool.
//

typedef struct _RDBSS_DATA {

    //
    //  The type and size of this record (must be RDBSS_NTC_DATA_HEADER)
    //

    NODE_TYPE_CODE NodeTypeCode;
    NODE_BYTE_SIZE NodeByteSize;

    //  The Driver object we were initialized with

    PDRIVER_OBJECT DriverObject;

    //
    // Mini Rdr registration related fields
    //

    LONG      NumberOfMinirdrsStarted;

    FAST_MUTEX MinirdrRegistrationMutex;
    LIST_ENTRY RegisteredMiniRdrs;          //protected by the mutex
    LONG       NumberOfMinirdrsRegistered;  //protected by the mutex

    //
    //  A pointer to our EPROCESS struct, which is a required input to the
    //  Cache Management subsystem.
    //

    PEPROCESS OurProcess;

#if 0
    //
    //  This is the ExWorkerItem that does both kinds of deferred closes.
    //

    RX_WORK_QUEUE_ITEM RxCloseItem;
#endif //0

    //
    //  Cache manager call back structures, which must be passed on each call
    //  to CcInitializeCacheMap.
    //

    CACHE_MANAGER_CALLBACKS CacheManagerCallbacks;
    CACHE_MANAGER_CALLBACKS CacheManagerNoOpCallbacks;

    //  To control access to the global Rx data record

    ERESOURCE Resource;

} RDBSS_DATA;
typedef RDBSS_DATA *PRDBSS_DATA;

extern RDBSS_DATA RxData;

extern PEPROCESS
RxGetRDBSSProcess();

//
// Note: A Strategy needs to be in place to deal with requests for stopping the
// RDBSS when requests are active.
//

typedef enum _RX_RDBSS_STATE_ {
   RDBSS_STARTABLE = 0,  //RDBSS_START_IN_PROGRESS,
   RDBSS_STARTED,
   RDBSS_STOP_IN_PROGRESS
   //this state deleted with cause! RDBSS_STOPPED
} RX_RDBSS_STATE, *PRX_RDBSS_STATE;

typedef struct _RDBSS_STARTSTOP_CONTEXT_ {
   RX_RDBSS_STATE State;
   ULONG          Version;
   PRX_CONTEXT    pStopContext;
} RDBSS_STARTSTOP_CONTEXT, *PRDBSS_STARTSTOP_CONTEXT;

typedef struct _MRX_CALLDOWN_COMPLETION_CONTEXT_ {
   LONG     WaitCount;
   KEVENT   Event;
} MRX_CALLDOWN_COMPLETION_CONTEXT,
  *PMRX_CALLDOWN_COMPLETION_CONTEXT;

typedef
NTSTATUS
(NTAPI *PMRX_CALLDOWN_ROUTINE) (
    IN OUT PVOID pCalldownParameter);


typedef struct _MRX_CALLDOWN_CONTEXT_ {
   RX_WORK_QUEUE_ITEM               WorkQueueItem;
   PRDBSS_DEVICE_OBJECT             pMRxDeviceObject;
   PMRX_CALLDOWN_COMPLETION_CONTEXT pCompletionContext;
   PMRX_CALLDOWN_ROUTINE            pRoutine;
   NTSTATUS                         CompletionStatus;
   PVOID                            pParameter;
} MRX_CALLDOWN_CONTEXT, *PMRX_CALLDOWN_CONTEXT;

typedef struct _RX_DISPATCHER_CONTEXT_ {
   LONG     NumberOfWorkerThreads;
   PKEVENT  pTearDownEvent;
} RX_DISPATCHER_CONTEXT, *PRX_DISPATCHER_CONTEXT;

#define RxSetRdbssState(RxDeviceObject,NewState)                \
        {                                                       \
           KIRQL SavedIrql;                                     \
           KeAcquireSpinLock(&RxStrucSupSpinLock,&SavedIrql);   \
           RxDeviceObject->StartStopContext.State = (NewState); \
           KeReleaseSpinLock(&RxStrucSupSpinLock,SavedIrql);    \
        }

#define RxGetRdbssState(RxDeviceObject)         \
        (RxDeviceObject)->StartStopContext.State

extern BOOLEAN
RxIsOperationCompatibleWithRdbssState(PIRP pIrp);

//
//  The RDBSS Device Object is an I/O system device object with additions for
//  the various structures needed by each minirdr: the dispatch, export-to-minirdr
//  structure, MUP call characteristics, list of active operations, etc.
//

typedef struct _RDBSS_DEVICE_OBJECT {

    union {
        DEVICE_OBJECT DeviceObject;
#ifndef __cplusplus
        DEVICE_OBJECT;
#endif // __cplusplus
    };

    ULONG RegistrationControls;
    PRDBSS_EXPORTS    RdbssExports;      //stuff that the minirdr needs to know
    PDEVICE_OBJECT    RDBSSDeviceObject; // set to NULL if monolithic
    PMINIRDR_DISPATCH Dispatch; // the mini rdr dispatch vector
    UNICODE_STRING    DeviceName;

    ULONG             NetworkProviderPriority;

    HANDLE            MupHandle;

    BOOLEAN           RegisterUncProvider;
    BOOLEAN           RegisterMailSlotProvider;
    BOOLEAN           RegisteredAsFileSystem;
    BOOLEAN           Unused;

    LIST_ENTRY        MiniRdrListLinks;

    ULONG             NumberOfActiveFcbs;
    ULONG             NumberOfActiveContexts;

    struct {
        LARGE_INTEGER   PagingReadBytesRequested;
        LARGE_INTEGER   NonPagingReadBytesRequested;
        LARGE_INTEGER   CacheReadBytesRequested;
        LARGE_INTEGER   FastReadBytesRequested;
        LARGE_INTEGER   NetworkReadBytesRequested;
        ULONG           ReadOperations;
        ULONG           FastReadOperations;
        ULONG           RandomReadOperations;

        LARGE_INTEGER   PagingWriteBytesRequested;
        LARGE_INTEGER   NonPagingWriteBytesRequested;
        LARGE_INTEGER   CacheWriteBytesRequested;
        LARGE_INTEGER   FastWriteBytesRequested;
        LARGE_INTEGER   NetworkWriteBytesRequested;
        ULONG           WriteOperations;
        ULONG           FastWriteOperations;
        ULONG           RandomWriteOperations;
    };

    //
    //  The following field tells how many requests for this volume have
    //  either been enqueued to ExWorker threads or are currently being
    //  serviced by ExWorker threads.  If the number goes above
    //  a certain threshold, put the request on the overflow queue to be
    //  executed later.
    //

    LONG PostedRequestCount[MaximumWorkQueue];

    //
    //  The following field indicates the number of IRP's waiting
    //  to be serviced in the overflow queue.
    //

    LONG OverflowQueueCount[MaximumWorkQueue];

    //
    //  The following field contains the queue header of the overflow queue.
    //  The Overflow queue is a list of IRP's linked via the IRP's ListEntry
    //  field.
    //

    LIST_ENTRY OverflowQueue[MaximumWorkQueue];

    //
    //  The following spinlock protects access to all the above fields.
    //

    RX_SPIN_LOCK OverflowQueueSpinLock;

    //
    // The following fields are required for synchronization with async.
    // requests issued by the RDBSS on behalf of this mini redirector on
    // on shutdown.
    //

    LONG    AsynchronousRequestsPending;

    PKEVENT pAsynchronousRequestsCompletionEvent;

    RDBSS_STARTSTOP_CONTEXT StartStopContext;

    RX_DISPATCHER_CONTEXT   DispatcherContext;

    struct _RX_PREFIX_TABLE  *pRxNetNameTable; //some guys may want to share
    struct _RX_PREFIX_TABLE  RxNetNameTableInDeviceObject;

    PRDBSS_SCAVENGER pRdbssScavenger; //for sharing
    RDBSS_SCAVENGER RdbssScavengerInDeviceObject;

} RDBSS_DEVICE_OBJECT;

typedef RDBSS_DEVICE_OBJECT *PRDBSS_DEVICE_OBJECT;

INLINE VOID
NTAPI
RxUnregisterMinirdr(
    IN PRDBSS_DEVICE_OBJECT RxDeviceObject
)
{
    PDEVICE_OBJECT RDBSSDeviceObject;

    RDBSSDeviceObject = RxDeviceObject->RDBSSDeviceObject;

    RxpUnregisterMinirdr(RxDeviceObject);

    if (RDBSSDeviceObject != NULL) {
        ObDereferenceObject(RDBSSDeviceObject);
    }
}

extern FAST_MUTEX RxMinirdrRegistrationMutex;
extern LIST_ENTRY RxRegisteredMiniRdrs;
extern ULONG RxNumberOfMinirdrs;

#endif // _RDBSSSTRUC_
