Windows: Remove Fcb.Specific.File.LazyWriterThread
[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             // Current count of queued flush items for the file
381             //
382
383             LONG                QueuedFlushCount;
384
385             //
386             // Cache space currently held by extents for the file
387             //
388
389             LONG                ExtentLength; // in KBs
390
391         } File;
392
393         struct
394         {
395
396             ULONG       Reserved;
397
398         } Directory;
399
400     } Specific;
401
402 } AFSFcb, *PAFSFcb;
403
404 typedef struct _AFS_DEVICE_EXTENSION
405 {
406
407     //
408     // Self pointer
409     //
410
411     PDEVICE_OBJECT  Self;
412
413     //
414     // List of device isntances
415     //
416
417     struct _AFS_DEVICE_EXTENSION *DeviceLink;
418
419     //
420     // Device flags
421     //
422
423     ULONG           DeviceFlags;
424
425     AFSFcb*         Fcb;
426
427     union
428     {
429
430         struct
431         {
432
433             //
434             // Volume worker tracking information
435             //
436
437             KEVENT           VolumeWorkerCloseEvent;
438
439             LONG             VolumeWorkerThreadCount;
440
441             //
442             // Fcb lifetime & flush time tickcount. This is calculated
443             // in DriverEntry() for the control device.
444             //
445
446             LARGE_INTEGER           ObjectLifeTimeCount;
447             LARGE_INTEGER           FcbFlushTimeCount;
448             LARGE_INTEGER           FcbPurgeTimeCount;
449             LARGE_INTEGER           ExtentRequestTimeCount;
450
451             //
452             // Comm interface
453             //
454
455             AFSCommSrvcCB    CommServiceCB;
456
457             //
458             // Extent Release Interface
459             //
460
461             ERESOURCE        ExtentReleaseResource;
462
463             KEVENT           ExtentReleaseEvent;
464
465             ULONG            ExtentReleaseSequence;
466
467             PKPROCESS        ServiceProcess;
468
469             //
470             // SysName information control block
471             //
472
473             ERESOURCE       SysName32ListLock;
474
475             AFSSysNameCB    *SysName32ListHead;
476
477             AFSSysNameCB    *SysName32ListTail;
478
479             ERESOURCE       SysName64ListLock;
480
481             AFSSysNameCB    *SysName64ListHead;
482
483             AFSSysNameCB    *SysName64ListTail;
484
485             //
486             // Our process tree information
487             //
488
489             AFSTreeHdr          ProcessTree;
490
491             ERESOURCE           ProcessTreeLock;
492
493             //
494             // SID Entry tree
495             //
496
497             AFSTreeHdr          AuthGroupTree;
498
499             ERESOURCE           AuthGroupTreeLock;
500
501             //
502             // Notificaiton information. This is used for change notification
503             //
504
505             LIST_ENTRY          DirNotifyList;
506
507             PNOTIFY_SYNC        NotifySync;
508
509             //
510             // Library load information
511             //
512
513             KEVENT              LoadLibraryEvent;
514
515             ULONG               LibraryState;
516
517             ERESOURCE           LibraryStateLock;
518
519             LONG                InflightLibraryRequests;
520
521             KEVENT              InflightLibraryEvent;
522
523             ERESOURCE           LibraryQueueLock;
524
525             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueHead;
526
527             struct _AFS_LIBRARY_QUEUE_REQUEST_CB    *LibraryQueueTail;
528
529             UNICODE_STRING      LibraryServicePath;
530
531             DEVICE_OBJECT      *LibraryDeviceObject;
532
533             FILE_OBJECT        *LibraryFileObject;
534
535             //
536             // Extent processing information within the library
537             //
538
539             LONG                ExtentCount;
540
541             LONG                ExtentsHeldLength;
542
543             KEVENT              ExtentsHeldEvent;
544
545             //
546             // Outstanding service request information
547             //
548
549             LONG                OutstandingServiceRequestCount;
550
551             KEVENT              OutstandingServiceRequestEvent;
552
553             //
554             // Out of memory signalling
555             //
556
557             LONG                WaitingForMemoryCount;
558
559             KEVENT              MemoryAvailableEvent;
560
561         } Control;
562
563         struct
564         {
565
566             //
567             // Cache file information
568             //
569
570             HANDLE              CacheFileHandle;
571
572             PFILE_OBJECT        CacheFileObject;
573
574             ULONG               CacheBlockSize;
575
576             UNICODE_STRING      CacheFile;
577
578             LARGE_INTEGER       CacheBlockCount; // Total number of cache blocks in the cache file
579
580             void               *CacheBaseAddress;
581
582             LARGE_INTEGER       CacheLength;
583
584             PMDL                CacheMdl;
585
586             //
587             // Throttles on behavior
588             //
589             LARGE_INTEGER       MaxIo;
590
591             LARGE_INTEGER       MaxDirty;
592
593             //
594             // Maximum RPC length that is issued by the service. We should limit our
595             // data requests such as for extents to this length
596             //
597
598             ULONG               MaximumRPCLength;
599
600             //
601             // Volume tree
602             //
603
604             AFSTreeHdr          VolumeTree;
605
606             ERESOURCE           VolumeTreeLock;
607
608             struct _AFS_VOLUME_CB        *VolumeListHead;
609
610             struct _AFS_VOLUME_CB        *VolumeListTail;
611
612             ERESOURCE           VolumeListLock;
613
614             //
615             // Queued extent release count and event
616             //
617
618             LONG                QueuedReleaseExtentCount;
619
620             KEVENT              QueuedReleaseExtentEvent;
621
622             //
623             // Name array related information
624             //
625
626             ULONG               NameArrayLength;
627
628             ULONG               MaxLinkCount;
629
630             //
631             // Our root cell tree
632             //
633
634             AFSTreeHdr          RootCellTree;
635
636             ERESOURCE           RootCellTreeLock;
637
638             //
639             // Cache file object access
640             //
641
642             ERESOURCE           CacheFileLock;
643
644             //
645             // NP Connection list information
646             //
647
648             ERESOURCE                 ProviderListLock;
649
650             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderConnectionList;
651
652             struct _AFSFSD_PROVIDER_CONNECTION_CB   *ProviderEnumerationList;
653
654         } RDR;
655
656         struct
657         {
658
659             //
660             // Worker pool information
661             //
662
663             ULONG            WorkerCount;
664
665             struct _AFS_WORKER_QUEUE_HDR *PoolHead;
666
667             ERESOURCE        QueueLock;
668
669             struct _AFS_WORK_ITEM     *QueueHead;
670
671             struct _AFS_WORK_ITEM     *QueueTail;
672
673             KEVENT           WorkerQueueHasItems;
674
675             LONG             QueueItemCount;
676
677             //
678             // IO Worker queue
679             //
680
681             ULONG            IOWorkerCount;
682
683             struct _AFS_WORKER_QUEUE_HDR *IOPoolHead;
684
685             ERESOURCE        IOQueueLock;
686
687             struct _AFS_WORK_ITEM     *IOQueueHead;
688
689             struct _AFS_WORK_ITEM     *IOQueueTail;
690
691             KEVENT           IOWorkerQueueHasItems;
692
693             LONG             IOQueueItemCount;
694
695         } Library;
696
697     } Specific;
698
699 } AFSDeviceExt, *PAFSDeviceExt;
700
701 //
702 // Network provider connection cb
703 //
704 #pragma pack(push, 1)
705 typedef struct _AFSFSD_PROVIDER_CONNECTION_CB
706 {
707
708     struct _AFSFSD_PROVIDER_CONNECTION_CB *fLink;
709
710     struct _AFSFSD_PROVIDER_CONNECTION_CB *EnumerationList;
711
712     ULONG       Flags;
713
714     ULONG       Type;
715
716     ULONG       Scope;
717
718     ULONG       DisplayType;
719
720     ULONG       Usage;
721
722     LARGE_INTEGER AuthenticationId;
723
724     WCHAR       LocalName;
725
726     UNICODE_STRING RemoteName;
727
728     UNICODE_STRING ComponentName;
729
730     UNICODE_STRING Comment;
731
732 } AFSProviderConnectionCB;
733 #pragma pack(pop)
734
735 //
736 // Callbacks defined in the framework
737 //
738
739 typedef
740 NTSTATUS
741 (*PAFSProcessRequest)( IN ULONG RequestType,
742                        IN ULONG RequestFlags,
743                        IN GUID *AuthGroup,
744                        IN PUNICODE_STRING FileName,
745                        IN AFSFileID *FileId,
746                        IN void  *Data,
747                        IN ULONG DataLength,
748                        IN OUT void *ResultBuffer,
749                        IN OUT PULONG ResultBufferLength);
750
751 typedef
752 NTSTATUS
753 (*PAFSDbgLogMsg)( IN ULONG Subsystem,
754                   IN ULONG Level,
755                   IN PCCH Format,
756                   ...);
757
758 typedef
759 NTSTATUS
760 (*PAFSAddConnectionEx)( IN UNICODE_STRING *RemoteName,
761                         IN ULONG DisplayType,
762                         IN ULONG Flags);
763
764 typedef
765 void *
766 (*PAFSExAllocatePoolWithTag)( IN POOL_TYPE  PoolType,
767                               IN SIZE_T  NumberOfBytes,
768                               IN ULONG  Tag);
769
770 typedef
771 void
772 (*PAFSExFreePoolWithTag)( IN void *Pointer, IN ULONG Tag);
773
774 typedef
775 void
776 (*PAFSRetrieveAuthGroup)( IN ULONGLONG ProcessId,
777                           IN ULONGLONG ThreadId,
778                           OUT GUID *AuthGroup);
779
780 typedef struct _AFS_LIBRARY_INIT_CB
781 {
782
783     PDEVICE_OBJECT      AFSControlDeviceObject;
784
785     PDEVICE_OBJECT      AFSRDRDeviceObject;
786
787     UNICODE_STRING      AFSServerName;
788
789     ULONG               AFSDebugFlags;
790
791     AFSFileID           GlobalRootFid;
792
793     CACHE_MANAGER_CALLBACKS *AFSCacheManagerCallbacks;
794
795     void               *AFSCacheBaseAddress;
796
797     LARGE_INTEGER       AFSCacheLength;
798
799     //
800     // Callbacks in the framework
801     //
802
803     PAFSProcessRequest  AFSProcessRequest;
804
805     PAFSDbgLogMsg       AFSDbgLogMsg;
806
807     PAFSAddConnectionEx AFSAddConnectionEx;
808
809     PAFSExAllocatePoolWithTag   AFSExAllocatePoolWithTag;
810
811     PAFSExFreePoolWithTag      AFSExFreePoolWithTag;
812
813     PAFSDumpTraceFiles  AFSDumpTraceFiles;
814
815     PAFSRetrieveAuthGroup AFSRetrieveAuthGroup;
816
817 } AFSLibraryInitCB;
818
819
820 #endif
821