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 first, then Paging Resource
 167     //
 168
 169     ERESOURCE       Resource;
 170
 171     ERESOURCE       PagingResource;
 172
 173     //
 174     // The section object pointer
 175     //
 176
 177     SECTION_OBJECT_POINTERS        SectionObjectPointers;
 178
 179     FAST_MUTEX      AdvancedHdrMutex;
 180
 181     ERESOURCE       CcbListLock;
 182
 183     union
 184     {
 185
 186         struct
 187         {
 188
 189             ERESOURCE       ExtentsResource;
 190
 191             //
 192             // This is set when an Extents Request completes.  Do not wait for this
 193             // with the Extents resource held!
 194             //
 195             KEVENT          ExtentsRequestComplete;
 196
 197             NTSTATUS        ExtentsRequestStatus;
 198
 199             GUID            ExtentsRequestAuthGroup;
 200
 201             struct _AFS_FSD_EXTENT  *DirtyListHead;
 202
 203             struct _AFS_FSD_EXTENT  *DirtyListTail;
 204
 205             ERESOURCE       DirtyExtentsListLock;
 206
 207             KEVENT          FlushEvent;
 208
 209             //
 210             // Queued Flush event. This event is set when the queued flush count
 211             // is zero, cleared otherwise.
 212
 213             KEVENT          QueuedFlushEvent;
 214
 215         } File;
 216
 217         struct
 218         {
 219
 220             LONG            DirectoryEnumCount;
 221
 222         } Directory;
 223
 224     } Specific;
 225
 226 } AFSNonPagedFcb, *PAFSNonPagedFcb;
 227
 228 typedef struct _AFS_FSD_EXTENT
 229 {
 230     //
 231     // Linked list first - the extents and then the skip list
 232     //
 233
 234     LIST_ENTRY          Lists[AFS_NUM_EXTENT_LISTS];
 235
 236     AFSListEntry        DirtyList;
 237
 238     //
 239     // And the extent itself
 240     //
 241
 242     LARGE_INTEGER       FileOffset;
 243
 244     LARGE_INTEGER       CacheOffset;
 245
 246     ULONG               Size;
 247
 248     ULONG               Flags;
 249
 250     LONG                ActiveCount;
 251
 252 #if GEN_MD5
 253     UCHAR               MD5[16];
 254 #endif
 255
 256 } AFSExtent, *PAFSExtent;
 257
 258 typedef struct AFS_FCB
 259 {
 260
 261     FSRTL_ADVANCED_FCB_HEADER Header;
 262
 263     //
 264     // This is the linked list of nodes processed asynchronously by the respective worker thread
 265     //
 266
 267     AFSListEntry        ListEntry;
 268
 269     //
 270     // The NP portion of the Fcb
 271     //
 272
 273     AFSNonPagedFcb    *NPFcb;
 274
 275     //
 276     // Fcb flags
 277     //
 278
 279     ULONG               Flags;
 280
 281     //
 282     // Share access mapping
 283     //
 284
 285     SHARE_ACCESS        ShareAccess;
 286
 287     //
 288     // Open pointer count on this file
 289     //
 290
 291     LONG                OpenReferenceCount;
 292
 293     //
 294     // Open handle count on this file
 295     //
 296
 297     LONG                OpenHandleCount;
 298
 299     //
 300     // Object info block
 301     //
 302
 303     struct _AFS_OBJECT_INFORMATION_CB   *ObjectInformation;
 304
 305     //
 306     // Ccb list pointers
 307     //
 308
 309     struct _AFS_CCB    *CcbListHead;
 310
 311     struct _AFS_CCB    *CcbListTail;
 312
 313     //
 314     // Union for node type specific information
 315     //
 316
 317     union
 318     {
 319
 320         struct
 321         {
 322             //
 323             // We set this when a flush has been sent to the
 324             // server sucessfully.  We use this to influence when we
 325             // write the flush.
 326             //
 327             LARGE_INTEGER       LastServerFlush;
 328
 329             //
 330             // We set this when the extent ref count goes to zero.
 331             // we use this to influence which files to purge
 332             //
 333             LARGE_INTEGER       LastExtentAccess;
 334
 335             //
 336             // If there has been a RELEASE_FILE_EXTENTS - this is
 337             // where we stopped last time this stops us from
 338             // constantly refreeing the same extents and then grabbing
 339             // them again.
 340             //
 341             LARGE_INTEGER       LastPurgePoint;
 342
 343             //
 344             // File lock
 345             //
 346
 347             FILE_LOCK           FileLock;
 348
 349             //
 350             // The extents
 351             //
 352
 353             LIST_ENTRY          ExtentsLists[AFS_NUM_EXTENT_LISTS];
 354
 355             //
 356             // There is only ever one request active, so we embed it
 357             //
 358
 359             AFSRequestExtentsCB ExtentsRequest;
 360
 361             //
 362             // Last PID that requested extents, NOT the system process
 363             //
 364
 365             ULONGLONG           ExtentRequestProcessId;
 366
 367             //
 368             // Dirty extent count
 369             //
 370
 371             LONG                ExtentsDirtyCount;
 372
 373             //
 374             // Extent count for this file
 375             //
 376
 377             LONG                ExtentCount;
 378
 379             //
 380             // The Lazy writer thread
 381             //
 382
 383             PETHREAD            LazyWriterThread;
 384
 385             //
 386             // Current count of queued flush items for the file
 387             //
 388
 389             LONG                QueuedFlushCount;
 390
 391             //
 392             // Cache space currently held by extents for the file
 393             //
 394
 395             LONG                ExtentLength; // in KBs
 396
 397         } File;
 398
 399         struct
 400         {
 401
 402             ULONG       Reserved;
 403
 404         } Directory;
 405
 406     } Specific;
 407
 408 } AFSFcb, *PAFSFcb;
 409
 410 typedef struct _AFS_DEVICE_EXTENSION
 411 {
 412
 413     //
 414     // Self pointer
 415     //
 416
 417     PDEVICE_OBJECT  Self;
 418
 419     //
 420     // List of device isntances
 421     //
 422
 423     struct _AFS_DEVICE_EXTENSION *DeviceLink;
 424
 425     //
 426     // Device flags
 427     //
 428
 429     ULONG           DeviceFlags;
 430
 431     AFSFcb*         Fcb;
 432
 433     union
 434     {
 435
 436         struct
 437         {
 438
 439             //
 440             // Volume worker tracking information
 441             //
 442
 443             KEVENT           VolumeWorkerCloseEvent;
 444
 445             LONG             VolumeWorkerThreadCount;
 446
 447             //
 448             // Fcb lifetime & flush time tickcount. This is calculated
 449             // in DriverEntry() for the control device.
 450             //
 451
 452             LARGE_INTEGER           ObjectLifeTimeCount;
 453             LARGE_INTEGER           FcbFlushTimeCount;
 454             LARGE_INTEGER           FcbPurgeTimeCount;
 455             LARGE_INTEGER           ExtentRequestTimeCount;
 456
 457             //
 458             // Comm interface
 459             //
 460
 461             AFSCommSrvcCB    CommServiceCB;
 462
 463             //
 464             // Extent Release Interface
 465             //
 466
 467             ERESOURCE        ExtentReleaseResource;
 468
 469             KEVENT           ExtentReleaseEvent;
 470
 471             ULONG            ExtentReleaseSequence;
 472
 473             PKPROCESS        ServiceProcess;
 474
 475             //
 476             // SysName information control block
 477             //
 478
 479             ERESOURCE       SysName32ListLock;
 480
 481             AFSSysNameCB    *SysName32ListHead;
 482
 483             AFSSysNameCB    *SysName32ListTail;
 484
 485             ERESOURCE       SysName64ListLock;
 486
 487             AFSSysNameCB    *SysName64ListHead;
 488
 489             AFSSysNameCB    *SysName64ListTail;
 490
 491             //
 492             // Our process tree information
 493             //
 494
 495             AFSTreeHdr          ProcessTree;
 496
 497             ERESOURCE           ProcessTreeLock;
 498
 499             //
 500             // SID Entry tree
 501             //
 502
 503             AFSTreeHdr          AuthGroupTree;
 504
 505             ERESOURCE           AuthGroupTreeLock;
 506
 507             //
 508             // Notificaiton information. This is used for change notification
 509             //
 510
 511             LIST_ENTRY          DirNotifyList;
 512
 513             PNOTIFY_SYNC        NotifySync;
 514
 515             //
 516             // Library load information
 517             //
 518
 519             KEVENT              LoadLibraryEvent;
 520
 521             ULONG               LibraryState;
 522
 523             ERESOURCE           LibraryStateLock;
 524
 525             LONG                InflightLibraryRequests;
 526
 527             KEVENT              InflightLibraryEvent;
 528
 529             ERESOURCE           LibraryQueueLock;
 530
 531             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueHead;
 532
 533             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueTail;
 534
 535             UNICODE_STRING      LibraryServicePath;
 536
 537             DEVICE_OBJECT      *LibraryDeviceObject;
 538
 539             FILE_OBJECT        *LibraryFileObject;
 540
 541             //
 542             // Extent processing information within the library
 543             //
 544
 545             LONG                ExtentCount;
 546
 547             LONG                ExtentsHeldLength;
 548
 549             KEVENT              ExtentsHeldEvent;
 550
 551             //
 552             // Outstanding service request information
 553             //
 554
 555             LONG                OutstandingServiceRequestCount;
 556
 557             KEVENT              OutstandingServiceRequestEvent;
 558
 559             //
 560             // Out of memory signalling
 561             //
 562
 563             LONG                WaitingForMemoryCount;
 564
 565             KEVENT              MemoryAvailableEvent;
 566
 567         } Control;
 568
 569         struct
 570         {
 571
 572             //
 573             // Cache file information
 574             //
 575
 576             HANDLE              CacheFileHandle;
 577
 578             PFILE_OBJECT        CacheFileObject;
 579
 580             ULONG               CacheBlockSize;
 581
 582             UNICODE_STRING      CacheFile;
 583
 584             LARGE_INTEGER       CacheBlockCount; // Total number of cache blocks in the cache file
 585
 586             void               *CacheBaseAddress;
 587
 588             LARGE_INTEGER       CacheLength;
 589
 590             PMDL                CacheMdl;
 591
 592             //
 593             // Throttles on behavior
 594             //
 595             LARGE_INTEGER       MaxIo;
 596
 597             LARGE_INTEGER       MaxDirty;
 598
 599             //
 600             // Maximum RPC length that is issued by the service. We should limit our
 601             // data requests such as for extents to this length
 602             //
 603
 604             ULONG               MaximumRPCLength;
 605
 606             //
 607             // Volume tree
 608             //
 609
 610             AFSTreeHdr          VolumeTree;
 611
 612             ERESOURCE           VolumeTreeLock;
 613
 614             struct _AFS_VOLUME_CB        *VolumeListHead;
 615
 616             struct _AFS_VOLUME_CB        *VolumeListTail;
 617
 618             ERESOURCE           VolumeListLock;
 619
 620             //
 621             // Queued extent release count and event
 622             //
 623
 624             LONG                QueuedReleaseExtentCount;
 625
 626             KEVENT              QueuedReleaseExtentEvent;
 627
 628             //
 629             // Name array related information
 630             //
 631
 632             ULONG               NameArrayLength;
 633
 634             ULONG               MaxLinkCount;
 635
 636             //
 637             // Our root cell tree
 638             //
 639
 640             AFSTreeHdr          RootCellTree;
 641
 642             ERESOURCE           RootCellTreeLock;
 643
 644             //
 645             // Cache file object access
 646             //
 647
 648             ERESOURCE           CacheFileLock;
 649
 650             //
 651             // NP Connection list information
 652             //
 653
 654             ERESOURCE                 ProviderListLock;
 655
 656             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderConnectionList;
 657
 658             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderEnumerationList;
 659
 660         } RDR;
 661
 662         struct
 663         {
 664
 665             //
 666             // Worker pool information
 667             //
 668
 669             ULONG            WorkerCount;
 670
 671             struct _AFS_WORKER_QUEUE_HDR *PoolHead;
 672
 673             ERESOURCE        QueueLock;
 674
 675             struct _AFS_WORK_ITEM     *QueueHead;
 676
 677             struct _AFS_WORK_ITEM     *QueueTail;
 678
 679             KEVENT           WorkerQueueHasItems;
 680
 681             LONG             QueueItemCount;
 682
 683             //
 684             // IO Worker queue
 685             //
 686
 687             ULONG            IOWorkerCount;
 688
 689             struct _AFS_WORKER_QUEUE_HDR *IOPoolHead;
 690
 691             ERESOURCE        IOQueueLock;
 692
 693             struct _AFS_WORK_ITEM     *IOQueueHead;
 694
 695             struct _AFS_WORK_ITEM     *IOQueueTail;
 696
 697             KEVENT           IOWorkerQueueHasItems;
 698
 699             LONG             IOQueueItemCount;
 700
 701         } Library;
 702
 703     } Specific;
 704
 705 } AFSDeviceExt, *PAFSDeviceExt;
 706
 707 //
 708 // Network provider connection cb
 709 //
 710 #pragma pack(push, 1)
 711 typedef struct _AFSFSD_PROVIDER_CONNECTION_CB
 712 {
 713
 714     struct _AFSFSD_PROVIDER_CONNECTION_CB *fLink;
 715
 716     struct _AFSFSD_PROVIDER_CONNECTION_CB *EnumerationList;
 717
 718     ULONG       Flags;
 719
 720     ULONG       Type;
 721
 722     ULONG       Scope;
 723
 724     ULONG       DisplayType;
 725
 726     ULONG       Usage;
 727
 728     LARGE_INTEGER AuthenticationId;
 729
 730     WCHAR       LocalName;
 731
 732     UNICODE_STRING RemoteName;
 733
 734     UNICODE_STRING ComponentName;
 735
 736     UNICODE_STRING Comment;
 737
 738 } AFSProviderConnectionCB;
 739 #pragma pack(pop)
 740
 741 //
 742 // Callbacks defined in the framework
 743 //
 744
 745 typedef
 746 NTSTATUS
 747 (*PAFSProcessRequest)( IN ULONG RequestType,
 748                        IN ULONG RequestFlags,
 749                        IN GUID *AuthGroup,
 750                        IN PUNICODE_STRING FileName,
 751                        IN AFSFileID *FileId,
 752                        IN void  *Data,
 753                        IN ULONG DataLength,
 754                        IN OUT void *ResultBuffer,
 755                        IN OUT PULONG ResultBufferLength);
 756
 757 typedef
 758 NTSTATUS
 759 (*PAFSDbgLogMsg)( IN ULONG Subsystem,
 760                   IN ULONG Level,
 761                   IN PCCH Format,
 762                   ...);
 763
 764 typedef
 765 NTSTATUS
 766 (*PAFSAddConnectionEx)( IN UNICODE_STRING *RemoteName,
 767                         IN ULONG DisplayType,
 768                         IN ULONG Flags);
 769
 770 typedef
 771 void *
 772 (*PAFSExAllocatePoolWithTag)( IN POOL_TYPE  PoolType,
 773                               IN SIZE_T  NumberOfBytes,
 774                               IN ULONG  Tag);
 775
 776 typedef
 777 void
 778 (*PAFSExFreePoolWithTag)( IN void *Pointer, IN ULONG Tag);
 779
 780 typedef
 781 void
 782 (*PAFSRetrieveAuthGroup)( IN ULONGLONG ProcessId,
 783                           IN ULONGLONG ThreadId,
 784                           OUT GUID *AuthGroup);
 785
 786 typedef struct _AFS_LIBRARY_INIT_CB
 787 {
 788
 789     PDEVICE_OBJECT      AFSControlDeviceObject;
 790
 791     PDEVICE_OBJECT      AFSRDRDeviceObject;
 792
 793     UNICODE_STRING      AFSServerName;
 794
 795     ULONG               AFSDebugFlags;
 796
 797     AFSFileID           GlobalRootFid;
 798
 799     CACHE_MANAGER_CALLBACKS *AFSCacheManagerCallbacks;
 800
 801     void               *AFSCacheBaseAddress;
 802
 803     LARGE_INTEGER       AFSCacheLength;
 804
 805     //
 806     // Callbacks in the framework
 807     //
 808
 809     PAFSProcessRequest  AFSProcessRequest;
 810
 811     PAFSDbgLogMsg       AFSDbgLogMsg;
 812
 813     PAFSAddConnectionEx AFSAddConnectionEx;
 814
 815     PAFSExAllocatePoolWithTag   AFSExAllocatePoolWithTag;
 816
 817     PAFSExFreePoolWithTag      AFSExFreePoolWithTag;
 818
 819     PAFSDumpTraceFiles  AFSDumpTraceFiles;
 820
 821     PAFSRetrieveAuthGroup AFSRetrieveAuthGroup;
 822
 823 } AFSLibraryInitCB;
 824
 825
 826 #endif
 827