src/WINNT/afsrdr/common/AFSRedirCommonStructs.h

   1 /*
   2  * Copyright (c) 2008-2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009-2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the name of Kernel Drivers, LLC nor the names of its
  18  *   contributors may be
  19  *   used to endorse or promote products derived from this software without
  20  *   specific prior written permission from Kernel Drivers, LLC
  21  *   and Your File System, Inc.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  26  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  27  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  28  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  29  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #ifndef _AFS_REDIR_COMMON_STRUCTS_H
  37 #define _AFS_REDIR_COMMON_STRUCTS_H
  38
  39 //
  40 // BTree Entry
  41 //
  42
  43 typedef struct AFS_BTREE_ENTRY
  44 {
  45
  46     void    *parentLink;
  47
  48     void    *leftLink;
  49
  50     void    *rightLink;
  51
  52     ULONGLONG HashIndex;
  53
  54 } AFSBTreeEntry, *PAFSBTreeEntry;
  55
  56 typedef struct AFS_LIST_ENTRY
  57 {
  58
  59     void    *fLink;
  60
  61     void    *bLink;
  62
  63 } AFSListEntry;
  64
  65 typedef struct _AFS_TREE_HDR
  66 {
  67
  68     AFSBTreeEntry *TreeHead;
  69
  70     ERESOURCE     *TreeLock;
  71
  72 } AFSTreeHdr;
  73
  74 //
  75 // Sys Name Information CB
  76 //
  77
  78 typedef struct _AFS_SYS_NAME_CB
  79 {
  80
  81     struct _AFS_SYS_NAME_CB     *fLink;
  82
  83     UNICODE_STRING      SysName;
  84
  85 } AFSSysNameCB;
  86
  87 //
  88 // Communication service control structures
  89 //
  90
  91 typedef struct _AFSFSD_SRVC_CONTROL_BLOCK
  92 {
  93
  94     ULONG                       IrpPoolRequestIndex;
  95
  96     struct _POOL_ENTRY          *RequestPoolHead;
  97
  98     struct _POOL_ENTRY          *RequestPoolTail;
  99
 100     ERESOURCE                   IrpPoolLock;
 101
 102     struct _POOL_ENTRY          *ResultPoolHead;
 103
 104     struct _POOL_ENTRY          *ResultPoolTail;
 105
 106     ERESOURCE                   ResultPoolLock;
 107
 108     KEVENT                      IrpPoolHasEntries;
 109
 110     KEVENT                      IrpPoolHasReleaseEntries;
 111
 112     ULONG                       IrpPoolControlFlag;
 113
 114     LONG                        QueueCount;
 115
 116 } AFSCommSrvcCB, *PAFSCommSrvcCB;
 117
 118 //
 119 // Irp Pool entry
 120 //
 121
 122 typedef struct _POOL_ENTRY
 123 {
 124
 125     struct _POOL_ENTRY    *fLink;
 126
 127     struct _POOL_ENTRY    *bLink;
 128
 129     KEVENT      Event;
 130
 131     GUID        AuthGroup;
 132
 133     AFSFileID    FileId;
 134
 135     UNICODE_STRING  FileName;
 136
 137     ULONG       RequestType;
 138
 139     ULONG       RequestIndex;
 140
 141     ULONG       RequestFlags;
 142
 143     ULONG       DataLength;
 144
 145     void       *Data;
 146
 147     ULONG       ResultStatus;
 148
 149     void       *ResultBuffer;
 150
 151     ULONG      *ResultBufferLength;
 152
 153 } AFSPoolEntry;
 154
 155 //
 156 // The first portion is the non-paged section of the Fcb
 157 //
 158
 159 typedef struct _AFS_NONPAGED_FCB
 160 {
 161
 162     USHORT          Size;
 163     USHORT          Type;
 164
 165     //
 166     // Ranking - File Resource, Paging Resource,
 167     //           then SectionObject Resource
 168     //
 169
 170     ERESOURCE       Resource;
 171
 172     ERESOURCE       PagingResource;
 173
 174     ERESOURCE       SectionObjectResource;
 175
 176     //
 177     // The section object pointer
 178     //
 179
 180     SECTION_OBJECT_POINTERS        SectionObjectPointers;
 181
 182     FAST_MUTEX      AdvancedHdrMutex;
 183
 184     ERESOURCE       CcbListLock;
 185
 186     union
 187     {
 188
 189         struct
 190         {
 191
 192             ERESOURCE       ExtentsResource;
 193
 194             //
 195             // This is set when an Extents Request completes.  Do not wait for this
 196             // with the Extents resource held!
 197             //
 198             KEVENT          ExtentsRequestComplete;
 199
 200             NTSTATUS        ExtentsRequestStatus;
 201
 202             GUID            ExtentsRequestAuthGroup;
 203
 204             struct _AFS_FSD_EXTENT  *DirtyListHead;
 205
 206             struct _AFS_FSD_EXTENT  *DirtyListTail;
 207
 208             ERESOURCE       DirtyExtentsListLock;
 209
 210             KEVENT          FlushEvent;
 211
 212             //
 213             // Queued Flush event. This event is set when the queued flush count
 214             // is zero, cleared otherwise.
 215
 216             KEVENT          QueuedFlushEvent;
 217
 218         } File;
 219
 220         struct
 221         {
 222
 223             LONG            DirectoryEnumCount;
 224
 225         } Directory;
 226
 227     } Specific;
 228
 229 } AFSNonPagedFcb, *PAFSNonPagedFcb;
 230
 231 typedef struct _AFS_FSD_EXTENT
 232 {
 233     //
 234     // Linked list first - the extents and then the skip list
 235     //
 236
 237     LIST_ENTRY          Lists[AFS_NUM_EXTENT_LISTS];
 238
 239     AFSListEntry        DirtyList;
 240
 241     //
 242     // And the extent itself
 243     //
 244
 245     LARGE_INTEGER       FileOffset;
 246
 247     LARGE_INTEGER       CacheOffset;
 248
 249     ULONG               Size;
 250
 251     ULONG               Flags;
 252
 253     LONG                ActiveCount;
 254
 255 #if GEN_MD5
 256     UCHAR               MD5[16];
 257 #endif
 258
 259 } AFSExtent, *PAFSExtent;
 260
 261 typedef struct AFS_FCB
 262 {
 263
 264     FSRTL_ADVANCED_FCB_HEADER Header;
 265
 266     //
 267     // This is the linked list of nodes processed asynchronously by the respective worker thread
 268     //
 269
 270     AFSListEntry        ListEntry;
 271
 272     //
 273     // The NP portion of the Fcb
 274     //
 275
 276     AFSNonPagedFcb    *NPFcb;
 277
 278     //
 279     // Fcb flags
 280     //
 281
 282     ULONG               Flags;
 283
 284     //
 285     // Share access mapping
 286     //
 287
 288     SHARE_ACCESS        ShareAccess;
 289
 290     //
 291     // Open pointer count on this file
 292     //
 293
 294     LONG                OpenReferenceCount;
 295
 296     //
 297     // Open handle count on this file
 298     //
 299
 300     LONG                OpenHandleCount;
 301
 302     //
 303     // Object info block
 304     //
 305
 306     struct _AFS_OBJECT_INFORMATION_CB   *ObjectInformation;
 307
 308     //
 309     // Ccb list pointers
 310     //
 311
 312     struct _AFS_CCB    *CcbListHead;
 313
 314     struct _AFS_CCB    *CcbListTail;
 315
 316     //
 317     // Union for node type specific information
 318     //
 319
 320     union
 321     {
 322
 323         struct
 324         {
 325             //
 326             // We set this when a flush has been sent to the
 327             // server sucessfully.  We use this to influence when we
 328             // write the flush.
 329             //
 330             LARGE_INTEGER       LastServerFlush;
 331
 332             //
 333             // We set this when the extent ref count goes to zero.
 334             // we use this to influence which files to purge
 335             //
 336             LARGE_INTEGER       LastExtentAccess;
 337
 338             //
 339             // If there has been a RELEASE_FILE_EXTENTS - this is
 340             // where we stopped last time this stops us from
 341             // constantly refreeing the same extents and then grabbing
 342             // them again.
 343             //
 344             LARGE_INTEGER       LastPurgePoint;
 345
 346             //
 347             // File lock
 348             //
 349
 350             FILE_LOCK           FileLock;
 351
 352             //
 353             // The extents
 354             //
 355
 356             LIST_ENTRY          ExtentsLists[AFS_NUM_EXTENT_LISTS];
 357
 358             //
 359             // There is only ever one request active, so we embed it
 360             //
 361
 362             AFSRequestExtentsCB ExtentsRequest;
 363
 364             //
 365             // Last PID that requested extents, NOT the system process
 366             //
 367
 368             ULONGLONG           ExtentRequestProcessId;
 369
 370             //
 371             // Dirty extent count
 372             //
 373
 374             LONG                ExtentsDirtyCount;
 375
 376             //
 377             // Extent count for this file
 378             //
 379
 380             LONG                ExtentCount;
 381
 382             //
 383             // Current count of queued flush items for the file
 384             //
 385
 386             LONG                QueuedFlushCount;
 387
 388             //
 389             // Cache space currently held by extents for the file
 390             //
 391
 392             LONG                ExtentLength; // in KBs
 393
 394         } File;
 395
 396         struct
 397         {
 398
 399             ULONG       Reserved;
 400
 401         } Directory;
 402
 403     } Specific;
 404
 405 } AFSFcb, *PAFSFcb;
 406
 407 typedef struct _AFS_DEVICE_EXTENSION
 408 {
 409
 410     //
 411     // Self pointer
 412     //
 413
 414     PDEVICE_OBJECT  Self;
 415
 416     //
 417     // List of device isntances
 418     //
 419
 420     struct _AFS_DEVICE_EXTENSION *DeviceLink;
 421
 422     //
 423     // Device flags
 424     //
 425
 426     ULONG           DeviceFlags;
 427
 428     AFSFcb*         Fcb;
 429
 430     union
 431     {
 432
 433         struct
 434         {
 435
 436             //
 437             // Volume worker tracking information
 438             //
 439
 440             KEVENT           VolumeWorkerCloseEvent;
 441
 442             LONG             VolumeWorkerThreadCount;
 443
 444             //
 445             // Fcb lifetime & flush time tickcount. This is calculated
 446             // in DriverEntry() for the control device.
 447             //
 448
 449             LARGE_INTEGER           ObjectLifeTimeCount;
 450             LARGE_INTEGER           FcbFlushTimeCount;
 451             LARGE_INTEGER           FcbPurgeTimeCount;
 452             LARGE_INTEGER           ExtentRequestTimeCount;
 453
 454             //
 455             // Comm interface
 456             //
 457
 458             AFSCommSrvcCB    CommServiceCB;
 459
 460             //
 461             // Extent Release Interface
 462             //
 463
 464             ERESOURCE        ExtentReleaseResource;
 465
 466             KEVENT           ExtentReleaseEvent;
 467
 468             ULONG            ExtentReleaseSequence;
 469
 470             PKPROCESS        ServiceProcess;
 471
 472             //
 473             // SysName information control block
 474             //
 475
 476             ERESOURCE       SysName32ListLock;
 477
 478             AFSSysNameCB    *SysName32ListHead;
 479
 480             AFSSysNameCB    *SysName32ListTail;
 481
 482             ERESOURCE       SysName64ListLock;
 483
 484             AFSSysNameCB    *SysName64ListHead;
 485
 486             AFSSysNameCB    *SysName64ListTail;
 487
 488             //
 489             // Our process tree information
 490             //
 491
 492             AFSTreeHdr          ProcessTree;
 493
 494             ERESOURCE           ProcessTreeLock;
 495
 496             //
 497             // SID Entry tree
 498             //
 499
 500             AFSTreeHdr          AuthGroupTree;
 501
 502             ERESOURCE           AuthGroupTreeLock;
 503
 504             //
 505             // Notificaiton information. This is used for change notification
 506             //
 507
 508             LIST_ENTRY          DirNotifyList;
 509
 510             PNOTIFY_SYNC        NotifySync;
 511
 512             //
 513             // Library load information
 514             //
 515
 516             KEVENT              LoadLibraryEvent;
 517
 518             ULONG               LibraryState;
 519
 520             ERESOURCE           LibraryStateLock;
 521
 522             LONG                InflightLibraryRequests;
 523
 524             KEVENT              InflightLibraryEvent;
 525
 526             ERESOURCE           LibraryQueueLock;
 527
 528             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueHead;
 529
 530             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueTail;
 531
 532             UNICODE_STRING      LibraryServicePath;
 533
 534             DEVICE_OBJECT      *LibraryDeviceObject;
 535
 536             FILE_OBJECT        *LibraryFileObject;
 537
 538             //
 539             // Extent processing information within the library
 540             //
 541
 542             LONG                ExtentCount;
 543
 544             LONG                ExtentsHeldLength;
 545
 546             KEVENT              ExtentsHeldEvent;
 547
 548             //
 549             // Outstanding service request information
 550             //
 551
 552             LONG                OutstandingServiceRequestCount;
 553
 554             KEVENT              OutstandingServiceRequestEvent;
 555
 556             //
 557             // Out of memory signalling
 558             //
 559
 560             LONG                WaitingForMemoryCount;
 561
 562             KEVENT              MemoryAvailableEvent;
 563
 564             //
 565             // Worker Pool Queues
 566             //
 567
 568             ERESOURCE           QueueLock;
 569
 570             struct _AFS_WORK_ITEM     *QueueHead;
 571
 572             struct _AFS_WORK_ITEM     *QueueTail;
 573
 574             KEVENT              WorkerQueueHasItems;
 575
 576             LONG                QueueItemCount;
 577
 578             ERESOURCE           IOQueueLock;
 579
 580             struct _AFS_WORK_ITEM     *IOQueueHead;
 581
 582             struct _AFS_WORK_ITEM     *IOQueueTail;
 583
 584             KEVENT              IOWorkerQueueHasItems;
 585
 586             LONG                IOQueueItemCount;
 587
 588
 589
 590         } Control;
 591
 592         struct
 593         {
 594
 595             //
 596             // Cache file information
 597             //
 598
 599             HANDLE              CacheFileHandle;
 600
 601             PFILE_OBJECT        CacheFileObject;
 602
 603             ULONG               CacheBlockSize;
 604
 605             UNICODE_STRING      CacheFile;
 606
 607             LARGE_INTEGER       CacheBlockCount; // Total number of cache blocks in the cache file
 608
 609             void               *CacheBaseAddress;
 610
 611             LARGE_INTEGER       CacheLength;
 612
 613             PMDL                CacheMdl;
 614
 615             //
 616             // Throttles on behavior
 617             //
 618             LARGE_INTEGER       MaxIo;
 619
 620             LARGE_INTEGER       MaxDirty;
 621
 622             //
 623             // Maximum RPC length that is issued by the service. We should limit our
 624             // data requests such as for extents to this length
 625             //
 626
 627             ULONG               MaximumRPCLength;
 628
 629             //
 630             // Volume tree
 631             //
 632
 633             AFSTreeHdr          VolumeTree;
 634
 635             ERESOURCE           VolumeTreeLock;
 636
 637             struct _AFS_VOLUME_CB        *VolumeListHead;
 638
 639             struct _AFS_VOLUME_CB        *VolumeListTail;
 640
 641             ERESOURCE           VolumeListLock;
 642
 643             //
 644             // Queued extent release count and event
 645             //
 646
 647             LONG                QueuedReleaseExtentCount;
 648
 649             KEVENT              QueuedReleaseExtentEvent;
 650
 651             //
 652             // Name array related information
 653             //
 654
 655             ULONG               NameArrayLength;
 656
 657             ULONG               MaxLinkCount;
 658
 659             //
 660             // Our root cell tree
 661             //
 662
 663             AFSTreeHdr          RootCellTree;
 664
 665             ERESOURCE           RootCellTreeLock;
 666
 667             //
 668             // Cache file object access
 669             //
 670
 671             ERESOURCE           CacheFileLock;
 672
 673             //
 674             // NP Connection list information
 675             //
 676
 677             ERESOURCE                 ProviderListLock;
 678
 679             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderConnectionList;
 680
 681             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderEnumerationList;
 682
 683         } RDR;
 684
 685         struct
 686         {
 687
 688             //
 689             // Worker pool information
 690             //
 691
 692             ULONG            WorkerCount;
 693
 694             struct _AFS_WORKER_QUEUE_HDR *PoolHead;
 695
 696             //
 697             // IO Worker queue
 698             //
 699
 700             ULONG            IOWorkerCount;
 701
 702             struct _AFS_WORKER_QUEUE_HDR *IOPoolHead;
 703
 704         } Library;
 705
 706     } Specific;
 707
 708 } AFSDeviceExt, *PAFSDeviceExt;
 709
 710 //
 711 // Network provider connection cb
 712 //
 713 #pragma pack(push, 1)
 714 typedef struct _AFSFSD_PROVIDER_CONNECTION_CB
 715 {
 716
 717     struct _AFSFSD_PROVIDER_CONNECTION_CB *fLink;
 718
 719     struct _AFSFSD_PROVIDER_CONNECTION_CB *EnumerationList;
 720
 721     ULONG       Flags;
 722
 723     ULONG       Type;
 724
 725     ULONG       Scope;
 726
 727     ULONG       DisplayType;
 728
 729     ULONG       Usage;
 730
 731     LARGE_INTEGER AuthenticationId;
 732
 733     WCHAR       LocalName;
 734
 735     UNICODE_STRING RemoteName;
 736
 737     UNICODE_STRING ComponentName;
 738
 739     UNICODE_STRING Comment;
 740
 741 } AFSProviderConnectionCB;
 742 #pragma pack(pop)
 743
 744 //
 745 // Callbacks defined in the framework
 746 //
 747
 748 typedef
 749 NTSTATUS
 750 (*PAFSProcessRequest)( IN ULONG RequestType,
 751                        IN ULONG RequestFlags,
 752                        IN GUID *AuthGroup,
 753                        IN PUNICODE_STRING FileName,
 754                        IN AFSFileID *FileId,
 755                        IN WCHAR * Cell,
 756                        IN ULONG   CellLength,
 757                        IN void  *Data,
 758                        IN ULONG DataLength,
 759                        IN OUT void *ResultBuffer,
 760                        IN OUT PULONG ResultBufferLength);
 761
 762 typedef
 763 NTSTATUS
 764 (*PAFSDbgLogMsg)( IN ULONG Subsystem,
 765                   IN ULONG Level,
 766                   IN PCCH Format,
 767                   ...);
 768
 769 typedef
 770 NTSTATUS
 771 (*PAFSAddConnectionEx)( IN UNICODE_STRING *RemoteName,
 772                         IN ULONG DisplayType,
 773                         IN ULONG Flags);
 774
 775 typedef
 776 void *
 777 (*PAFSExAllocatePoolWithTag)( IN POOL_TYPE  PoolType,
 778                               IN SIZE_T  NumberOfBytes,
 779                               IN ULONG  Tag);
 780
 781 typedef
 782 void
 783 (*PAFSExFreePoolWithTag)( IN void *Pointer, IN ULONG Tag);
 784
 785 typedef
 786 void
 787 (*PAFSRetrieveAuthGroup)( IN ULONGLONG ProcessId,
 788                           IN ULONGLONG ThreadId,
 789                           OUT GUID *AuthGroup);
 790
 791 typedef struct _AFS_LIBRARY_INIT_CB
 792 {
 793
 794     PDEVICE_OBJECT      AFSControlDeviceObject;
 795
 796     PDEVICE_OBJECT      AFSRDRDeviceObject;
 797
 798     UNICODE_STRING      AFSServerName;
 799
 800     UNICODE_STRING      AFSMountRootName;
 801
 802     ULONG               AFSDebugFlags;
 803
 804     AFSFileID           GlobalRootFid;
 805
 806     CACHE_MANAGER_CALLBACKS *AFSCacheManagerCallbacks;
 807
 808     void               *AFSCacheBaseAddress;
 809
 810     LARGE_INTEGER       AFSCacheLength;
 811
 812     //
 813     // Callbacks in the framework
 814     //
 815
 816     PAFSProcessRequest  AFSProcessRequest;
 817
 818     PAFSDbgLogMsg       AFSDbgLogMsg;
 819
 820     PAFSAddConnectionEx AFSAddConnectionEx;
 821
 822     PAFSExAllocatePoolWithTag   AFSExAllocatePoolWithTag;
 823
 824     PAFSExFreePoolWithTag      AFSExFreePoolWithTag;
 825
 826     PAFSDumpTraceFiles  AFSDumpTraceFiles;
 827
 828     PAFSRetrieveAuthGroup AFSRetrieveAuthGroup;
 829
 830 } AFSLibraryInitCB;
 831
 832 typedef struct _AFS_TRACE_CONFIG_CB
 833 {
 834
 835     PAFSDbgLogMsg       AFSDbgLogMsg;
 836
 837 } AFSDebugTraceConfigCB;
 838
 839 #endif
 840