217ecc739f45cf12f3a56e51a90a4f6998f0d35c
[openafs.git] / 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