Windows: RDR DeviceObject Characteristics
[openafs.git] / src / WINNT / afsrdr / kernel / fs / AFSRDRSupport.cpp
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3  * Copyright (c) 2009, 2010, 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 names of Kernel Drivers, LLC and Your File System, Inc.
18  *   nor the names of their contributors may be used to endorse or promote
19  *   products derived from this software without specific prior written
20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 //
36 // File: AFSRDRSupport.cpp
37 //
38 #include "AFSCommon.h"
39
40 typedef NTSTATUS  (*FsRtlRegisterUncProviderEx_t)( PHANDLE  MupHandle, PUNICODE_STRING  RedirDevName, PDEVICE_OBJECT  DeviceObject, ULONG  Flags);
41
42 NTSTATUS
43 AFSInitRDRDevice()
44 {
45
46     NTSTATUS       ntStatus = STATUS_SUCCESS;
47     UNICODE_STRING uniDeviceName;
48     AFSDeviceExt  *pDeviceExt = NULL;
49     UNICODE_STRING uniFsRtlRegisterUncProviderEx;
50     FsRtlRegisterUncProviderEx_t pFsRtlRegisterUncProviderEx = NULL;
51
52     __Enter
53     {
54
55         RtlInitUnicodeString( &uniDeviceName,
56                               AFS_RDR_DEVICE_NAME);
57
58         RtlInitUnicodeString( &uniFsRtlRegisterUncProviderEx,
59                               L"FsRtlRegisterUncProviderEx");
60
61         pFsRtlRegisterUncProviderEx = (FsRtlRegisterUncProviderEx_t)MmGetSystemRoutineAddress(&uniFsRtlRegisterUncProviderEx);
62
63         ntStatus = IoCreateDevice( AFSDriverObject,
64                                    sizeof( AFSDeviceExt),
65                                    pFsRtlRegisterUncProviderEx ? NULL : &uniDeviceName,
66                                    FILE_DEVICE_NETWORK_FILE_SYSTEM,
67                                    FILE_DEVICE_SECURE_OPEN | FILE_REMOTE_DEVICE,
68                                    FALSE,
69                                    &AFSRDRDeviceObject);
70
71         if( !NT_SUCCESS( ntStatus))
72         {
73
74             AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
75                           AFS_TRACE_LEVEL_ERROR,
76                           "AFSInitRDRDevice IoCreateDevice failure %08lX\n",
77                           ntStatus));
78
79             try_return( ntStatus);
80         }
81
82         pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
83
84         RtlZeroMemory( pDeviceExt,
85                        sizeof( AFSDeviceExt));
86
87         //
88         // Initialize resources
89         //
90
91         pDeviceExt->Specific.RDR.VolumeTree.TreeLock = &pDeviceExt->Specific.RDR.VolumeTreeLock;
92
93         ExInitializeResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
94
95         pDeviceExt->Specific.RDR.VolumeTree.TreeHead = NULL;
96
97         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
98
99         pDeviceExt->Specific.RDR.VolumeListHead = NULL;
100
101         pDeviceExt->Specific.RDR.VolumeListTail = NULL;
102
103         KeInitializeEvent( &pDeviceExt->Specific.RDR.QueuedReleaseExtentEvent,
104                            NotificationEvent,
105                            TRUE);
106
107         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
108
109         pDeviceExt->Specific.RDR.RootCellTree.TreeLock = &pDeviceExt->Specific.RDR.RootCellTreeLock;
110
111         pDeviceExt->Specific.RDR.RootCellTree.TreeHead = NULL;
112
113         ExInitializeResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
114
115         ntStatus = AFSInitRdrFcb( &pDeviceExt->Fcb);
116
117         if ( !NT_SUCCESS(ntStatus))
118         {
119
120             AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
121                           AFS_TRACE_LEVEL_ERROR,
122                           "AFSInitRDRDevice AFSInitRdrFcb failure %08lX\n",
123                           ntStatus));
124
125             try_return( ntStatus);
126         }
127
128         //
129         // Clear the initializing bit
130         //
131
132         AFSRDRDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
133
134         //
135         // Increase the StackSize to support the extra stack frame required
136         // for use of IoCompletion routines.
137         //
138
139         AFSRDRDeviceObject->StackSize++;
140
141         //
142         // Register this device with MUP with FilterMgr if Vista or above
143         //
144
145         if( pFsRtlRegisterUncProviderEx)
146         {
147
148             ntStatus = pFsRtlRegisterUncProviderEx( &AFSMUPHandle,
149                                                     &uniDeviceName,
150                                                     AFSRDRDeviceObject,
151                                                     0);
152             if ( !NT_SUCCESS( ntStatus))
153             {
154                 AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
155                               AFS_TRACE_LEVEL_ERROR,
156                               "AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
157                               ntStatus));
158             }
159         }
160         else
161         {
162
163             ntStatus = FsRtlRegisterUncProvider( &AFSMUPHandle,
164                                                  &uniDeviceName,
165                                                  FALSE);
166
167             if ( NT_SUCCESS( ntStatus))
168             {
169
170                 IoRegisterFileSystem( AFSRDRDeviceObject);
171             }
172             else
173             {
174                 AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
175                               AFS_TRACE_LEVEL_ERROR,
176                               "AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
177                               ntStatus));
178             }
179         }
180
181         //
182         // Good to go, all registered and ready to start receiving requests
183         //
184
185 try_exit:
186
187         if( !NT_SUCCESS( ntStatus))
188         {
189
190             //
191             // Delete our device and bail
192             //
193
194             ExDeleteResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
195
196             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
197
198             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
199
200             ExDeleteResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
201
202             IoDeleteDevice( AFSRDRDeviceObject);
203
204             AFSRDRDeviceObject = NULL;
205
206             try_return( ntStatus);
207         }
208     }
209
210     return ntStatus;
211 }
212
213 NTSTATUS
214 AFSRDRDeviceControl( IN PDEVICE_OBJECT DeviceObject,
215                      IN PIRP Irp)
216 {
217     UNREFERENCED_PARAMETER(DeviceObject);
218
219     NTSTATUS           ntStatus = STATUS_SUCCESS;
220     PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
221     BOOLEAN            bCompleteIrp = TRUE;
222
223     __Enter
224     {
225
226         switch( pIrpSp->Parameters.DeviceIoControl.IoControlCode)
227         {
228
229             case IOCTL_REDIR_QUERY_PATH:
230             {
231
232                 QUERY_PATH_REQUEST *pPathRequest = (QUERY_PATH_REQUEST *)pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
233                 QUERY_PATH_RESPONSE *pPathResponse = (QUERY_PATH_RESPONSE *)Irp->UserBuffer;
234                 UNICODE_STRING uniPathName;
235
236                 ntStatus = STATUS_BAD_NETWORK_PATH;
237
238                 uniPathName.Length = (USHORT)pPathRequest->PathNameLength;
239                 uniPathName.MaximumLength = uniPathName.Length;
240
241                 uniPathName.Buffer = pPathRequest->FilePathName;
242
243                 if( uniPathName.Length >= AFSServerName.Length + sizeof( WCHAR))
244                 {
245
246                     USHORT usLength = uniPathName.Length;
247
248                     uniPathName.Length = AFSServerName.Length;
249
250                     //
251                     // Skip over the first slash in the name
252                     //
253
254                     uniPathName.Buffer = &uniPathName.Buffer[ 1];
255
256
257                     //
258                     // Check to see if the first (or only) component
259                     // of the path matches the server name
260                     //
261
262                     if( RtlCompareUnicodeString( &AFSServerName,
263                                                  &uniPathName,
264                                                  TRUE) == 0 &&
265                         ( usLength == AFSServerName.Length + sizeof( WCHAR) ||
266                           uniPathName.Buffer[ AFSServerName.Length / sizeof( WCHAR)] == '\\'))
267                     {
268
269                         ntStatus = STATUS_SUCCESS;
270
271                         pPathResponse->LengthAccepted = AFSServerName.Length + sizeof( WCHAR);
272                     }
273                 }
274
275                 break;
276             }
277
278             case IOCTL_REDIR_QUERY_PATH_EX:
279             {
280
281                 QUERY_PATH_REQUEST_EX *pPathRequest = (QUERY_PATH_REQUEST_EX *)pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
282                 QUERY_PATH_RESPONSE *pPathResponse = (QUERY_PATH_RESPONSE *)Irp->UserBuffer;
283                 UNICODE_STRING uniPathName;
284
285                 ntStatus = STATUS_BAD_NETWORK_PATH;
286
287                 uniPathName.Length = pPathRequest->PathName.Length;
288                 uniPathName.MaximumLength = uniPathName.Length;
289
290                 uniPathName.Buffer = pPathRequest->PathName.Buffer;
291
292                 if( uniPathName.Length >= AFSServerName.Length + sizeof( WCHAR))
293                 {
294
295                     USHORT usLength = uniPathName.Length;
296
297                     uniPathName.Length = AFSServerName.Length;
298
299                     //
300                     // Skip over the first slash in the name
301                     //
302
303                     uniPathName.Buffer = &uniPathName.Buffer[ 1];
304
305
306                     //
307                     // Check to see if the first (or only) component
308                     // of the path matches the server name
309                     //
310
311                     if( RtlCompareUnicodeString( &AFSServerName,
312                                                  &uniPathName,
313                                                  TRUE) == 0 &&
314                         ( usLength == AFSServerName.Length + sizeof( WCHAR) ||
315                           uniPathName.Buffer[ AFSServerName.Length / sizeof( WCHAR)] == '\\'))
316                     {
317
318                         ntStatus = STATUS_SUCCESS;
319
320                         pPathResponse->LengthAccepted = AFSServerName.Length + sizeof( WCHAR);
321                     }
322                 }
323
324                 break;
325             }
326
327             default:
328
329                 ntStatus = STATUS_INVALID_DEVICE_REQUEST;
330
331                 break;
332         }
333
334         if (bCompleteIrp)
335         {
336             //
337             // Complete the request
338             //
339
340             AFSCompleteRequest( Irp,
341                                 ntStatus);
342         }
343     }
344
345     return ntStatus;
346 }
347
348 NTSTATUS
349 AFSInitializeRedirector( IN AFSRedirectorInitInfo *RedirInitInfo)
350 {
351
352     NTSTATUS ntStatus = STATUS_SUCCESS;
353     LARGE_INTEGER cacheSizeBytes;
354     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
355     OBJECT_ATTRIBUTES   stObjectAttribs;
356     IO_STATUS_BLOCK stIoStatus;
357     UNICODE_STRING uniServiceName;
358
359     __Enter
360     {
361
362         //
363         // First this is to load the library
364         //
365
366         RtlInitUnicodeString( &uniServiceName,
367                               AFS_REDIR_LIBRARY_SERVICE_ENTRY);
368
369         ntStatus = AFSLoadLibrary( 0,
370                                    &uniServiceName);
371
372         if( !NT_SUCCESS( ntStatus))
373         {
374
375             AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
376                           AFS_TRACE_LEVEL_ERROR,
377                           "AFSInitializeRedirector AFSLoadLibrary failure %08lX\n",
378                           ntStatus));
379
380             try_return( ntStatus);
381         }
382
383         //
384         // Save off the cache file information
385         //
386
387         pDevExt->Specific.RDR.CacheBlockSize = RedirInitInfo->CacheBlockSize;
388
389         pDevExt->Specific.RDR.CacheBlockCount = RedirInitInfo->ExtentCount;
390
391         pDevExt->Specific.RDR.MaximumRPCLength = RedirInitInfo->MaximumChunkLength;
392
393         cacheSizeBytes = RedirInitInfo->ExtentCount;
394         cacheSizeBytes.QuadPart *= RedirInitInfo->CacheBlockSize;
395
396         AFSDumpFileLocation.Length = 0;
397
398         AFSDumpFileLocation.MaximumLength = (USHORT)RedirInitInfo->DumpFileLocationLength + (4 * sizeof( WCHAR));
399
400         AFSDumpFileLocation.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
401                                                                         AFSDumpFileLocation.MaximumLength,
402                                                                         AFS_GENERIC_MEMORY_23_TAG);
403
404         if( AFSDumpFileLocation.Buffer == NULL)
405         {
406
407             AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
408                           AFS_TRACE_LEVEL_ERROR,
409                           "AFSInitializeRedirector AFS_GENERIC_MEMORY_23_TAG allocation error\n"));
410
411             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
412         }
413
414         RtlCopyMemory( AFSDumpFileLocation.Buffer,
415                        L"\\??\\",
416                        4 * sizeof( WCHAR));
417
418         AFSDumpFileLocation.Length = 4 * sizeof( WCHAR);
419
420         RtlCopyMemory( &AFSDumpFileLocation.Buffer[ AFSDumpFileLocation.Length/sizeof( WCHAR)],
421                        (void *)((char *)RedirInitInfo + RedirInitInfo->DumpFileLocationOffset),
422                        RedirInitInfo->DumpFileLocationLength);
423
424         AFSDumpFileLocation.Length += (USHORT)RedirInitInfo->DumpFileLocationLength;
425
426         //
427         // Be sure the shutdown flag is not set
428         //
429
430         ClearFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN);
431
432         //
433         // Set up the Throttles.
434         //
435         // Max IO is 10% of the cache, or the value in the registry,
436         // with a minimum of 5Mb (and a maximum of 50% cache size)
437         //
438         if( AFSMaxDirectIo)
439         {
440             //
441             // collect what the user
442             //
443             pDevExt->Specific.RDR.MaxIo.QuadPart = AFSMaxDirectIo;
444             pDevExt->Specific.RDR.MaxIo.QuadPart *= (1024 * 1024);
445
446         }
447         else
448         {
449
450             pDevExt->Specific.RDR.MaxIo.QuadPart = cacheSizeBytes.QuadPart / 2;
451         }
452
453         if (pDevExt->Specific.RDR.MaxIo.QuadPart < (5 * 1024 * 1204))
454         {
455
456             pDevExt->Specific.RDR.MaxIo.QuadPart = 5 * 1024 * 1204;
457
458         }
459
460         //
461         // For small cache configurations ...
462         //
463
464         if (pDevExt->Specific.RDR.MaxIo.QuadPart > cacheSizeBytes.QuadPart / 2)
465         {
466
467             pDevExt->Specific.RDR.MaxIo.QuadPart  = cacheSizeBytes.QuadPart / 2;
468         }
469
470         //
471         // Maximum Dirty is 50% of the cache, or the value in the
472         // registry.  No minimum, maximum of 90% of cache size.
473         //
474         if (AFSMaxDirtyFile)
475         {
476
477             pDevExt->Specific.RDR.MaxDirty.QuadPart = AFSMaxDirtyFile;
478             pDevExt->Specific.RDR.MaxDirty.QuadPart *= (1024 * 1024);
479
480         }
481         else
482         {
483
484             pDevExt->Specific.RDR.MaxDirty.QuadPart = cacheSizeBytes.QuadPart/2;
485
486         }
487
488         cacheSizeBytes.QuadPart *= 9;
489         cacheSizeBytes.QuadPart  = cacheSizeBytes.QuadPart / 10;
490
491         if (pDevExt->Specific.RDR.MaxDirty.QuadPart > cacheSizeBytes.QuadPart)
492         {
493             pDevExt->Specific.RDR.MaxDirty.QuadPart = cacheSizeBytes.QuadPart;
494         }
495
496         //
497         // Store off any flags for the file system
498         //
499
500         if( BooleanFlagOn( RedirInitInfo->Flags, AFS_REDIR_INIT_FLAG_HIDE_DOT_FILES))
501         {
502
503             //
504             // Hide files which begin with .
505             //
506
507             SetFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_HIDE_DOT_NAMES);
508         }
509
510         if( BooleanFlagOn( RedirInitInfo->Flags, AFS_REDIR_INIT_FLAG_DISABLE_SHORTNAMES))
511         {
512
513             //
514             // Hide files which begin with .
515             //
516
517             SetFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES);
518         }
519
520         //
521         // Are we performing direct to service IO?
522         //
523
524         if( BooleanFlagOn( RedirInitInfo->Flags, AFS_REDIR_INIT_PERFORM_SERVICE_IO))
525         {
526
527             //
528             // Send IO requests directly to service
529             //
530
531             SetFlag( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DIRECT_SERVICE_IO);
532         }
533         else
534         {
535
536             if( RedirInitInfo->MemoryCacheOffset.QuadPart != 0 &&
537                 RedirInitInfo->MemoryCacheLength.QuadPart != 0)
538             {
539
540                 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
541
542 #ifdef AMD64
543                 pDevExt->Specific.RDR.CacheMdl = MmCreateMdl( NULL,
544                                                               (void *)RedirInitInfo->MemoryCacheOffset.QuadPart,
545                                                               RedirInitInfo->MemoryCacheLength.QuadPart);
546 #else
547                 pDevExt->Specific.RDR.CacheMdl = MmCreateMdl( NULL,
548                                                               (void *)RedirInitInfo->MemoryCacheOffset.LowPart,
549                                                               RedirInitInfo->MemoryCacheLength.LowPart);
550 #endif
551
552                 if( pDevExt->Specific.RDR.CacheMdl != NULL)
553                 {
554
555                     __try
556                     {
557
558                         MmProbeAndLockPages( pDevExt->Specific.RDR.CacheMdl,
559                                              KernelMode,
560                                              IoModifyAccess);
561
562                         pDevExt->Specific.RDR.CacheBaseAddress = MmGetSystemAddressForMdlSafe( pDevExt->Specific.RDR.CacheMdl,
563                                                                                                NormalPagePriority);
564                     }
565                     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
566                     {
567
568                         AFSDumpTraceFilesFnc();
569
570                         IoFreeMdl( pDevExt->Specific.RDR.CacheMdl);
571                         pDevExt->Specific.RDR.CacheMdl = NULL;
572                     }
573
574                     if( pDevExt->Specific.RDR.CacheMdl != NULL)
575                     {
576                         pDevExt->Specific.RDR.CacheLength = RedirInitInfo->MemoryCacheLength;
577                         ntStatus = STATUS_SUCCESS;
578                     }
579
580                 }
581             }
582
583             if( !NT_SUCCESS( ntStatus) &&
584                 RedirInitInfo->CacheFileNameLength == 0)
585             {
586
587                 AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
588                               AFS_TRACE_LEVEL_ERROR,
589                               "AFSInitializeRedirector Unable to initialize cache file %08lX\n",
590                               ntStatus));
591
592                 try_return( ntStatus);
593             }
594
595             if( pDevExt->Specific.RDR.CacheMdl == NULL)
596             {
597
598                 if( RedirInitInfo->CacheFileNameLength == 0)
599                 {
600
601                     AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
602                                   AFS_TRACE_LEVEL_ERROR,
603                                   "AFSInitializeRedirector CacheMdl == NULL\n"));
604
605                     try_return( ntStatus = STATUS_INVALID_PARAMETER);
606                 }
607
608                 //
609                 // Go open the cache file
610                 //
611
612                 pDevExt->Specific.RDR.CacheFile.Length = 0;
613                 pDevExt->Specific.RDR.CacheFile.MaximumLength = (USHORT)RedirInitInfo->CacheFileNameLength + (4 * sizeof( WCHAR));
614
615                 pDevExt->Specific.RDR.CacheFile.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
616                                                                                             pDevExt->Specific.RDR.CacheFile.MaximumLength,
617                                                                                             AFS_GENERIC_MEMORY_24_TAG);
618
619                 if( pDevExt->Specific.RDR.CacheFile.Buffer == NULL)
620                 {
621
622                     AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
623                                   AFS_TRACE_LEVEL_ERROR,
624                                   "AFSInitializeRedirector AFS_GENERIC_MEMORY_24_TAG allocation failure\n"));
625
626                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
627                 }
628
629                 RtlCopyMemory( pDevExt->Specific.RDR.CacheFile.Buffer,
630                                L"\\??\\",
631                                4 * sizeof( WCHAR));
632
633                 pDevExt->Specific.RDR.CacheFile.Length = 4 * sizeof( WCHAR);
634
635                 RtlCopyMemory( &pDevExt->Specific.RDR.CacheFile.Buffer[ pDevExt->Specific.RDR.CacheFile.Length/sizeof( WCHAR)],
636                                RedirInitInfo->CacheFileName,
637                                RedirInitInfo->CacheFileNameLength);
638
639                 pDevExt->Specific.RDR.CacheFile.Length += (USHORT)RedirInitInfo->CacheFileNameLength;
640
641                 InitializeObjectAttributes( &stObjectAttribs,
642                                             &pDevExt->Specific.RDR.CacheFile,
643                                             OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
644                                             NULL,
645                                             NULL);
646
647                 ntStatus = ZwOpenFile( &pDevExt->Specific.RDR.CacheFileHandle,
648                                        GENERIC_READ | GENERIC_WRITE,
649                                        &stObjectAttribs,
650                                        &stIoStatus,
651                                        FILE_SHARE_READ | FILE_SHARE_WRITE,
652                                        FILE_WRITE_THROUGH | FILE_RANDOM_ACCESS);
653
654                 if( !NT_SUCCESS( ntStatus))
655                 {
656
657                     AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
658                                   AFS_TRACE_LEVEL_ERROR,
659                                   "AFSInitializeRedirector ZwOpenFile failure %08lX\n",
660                                   ntStatus));
661
662                     try_return( ntStatus);
663                 }
664
665                 //
666                 // Map to the fileobject
667                 //
668
669                 ntStatus = ObReferenceObjectByHandle( pDevExt->Specific.RDR.CacheFileHandle,
670                                                       SYNCHRONIZE,
671                                                       NULL,
672                                                       KernelMode,
673                                                       (void **)&pDevExt->Specific.RDR.CacheFileObject,
674                                                       NULL);
675
676                 if( !NT_SUCCESS( ntStatus))
677                 {
678
679                     AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
680                                   AFS_TRACE_LEVEL_ERROR,
681                                   "AFSInitializeRedirector ObReferenceObjectByHandle failure %08lX\n",
682                                   ntStatus));
683
684                     try_return( ntStatus);
685                 }
686             }
687         }
688
689         pDevExt->Specific.RDR.MaxLinkCount = RedirInitInfo->MaxPathLinkCount;
690
691         pDevExt->Specific.RDR.NameArrayLength = RedirInitInfo->NameArrayLength;
692
693         //
694         // Intialize the library
695         //
696
697         ntStatus = AFSInitializeLibrary( &RedirInitInfo->GlobalFileId,
698                                          TRUE);
699
700         if ( !NT_SUCCESS( ntStatus))
701         {
702             AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
703                           AFS_TRACE_LEVEL_ERROR,
704                           "AFSInitializeRedirector AFSInitializeLibrary failure %08lX\n",
705                           ntStatus));
706         }
707
708 try_exit:
709
710         if( !NT_SUCCESS( ntStatus))
711         {
712
713             if( pDevExt->Specific.RDR.CacheMdl != NULL)
714             {
715
716                 MmUnmapLockedPages( pDevExt->Specific.RDR.CacheBaseAddress,
717                                     pDevExt->Specific.RDR.CacheMdl);
718
719                 MmUnlockPages( pDevExt->Specific.RDR.CacheMdl);
720
721                 ExFreePool( pDevExt->Specific.RDR.CacheMdl);
722
723                 pDevExt->Specific.RDR.CacheMdl = NULL;
724                 pDevExt->Specific.RDR.CacheBaseAddress = NULL;
725                 pDevExt->Specific.RDR.CacheLength.QuadPart = 0;
726             }
727
728             if( pDevExt->Specific.RDR.CacheFileHandle != NULL)
729             {
730
731                 ZwClose( pDevExt->Specific.RDR.CacheFileHandle);
732
733                 pDevExt->Specific.RDR.CacheFileHandle = NULL;
734             }
735
736             if( pDevExt->Specific.RDR.CacheFileObject != NULL)
737             {
738
739                 ObDereferenceObject( pDevExt->Specific.RDR.CacheFileObject);
740
741                 pDevExt->Specific.RDR.CacheFileObject = NULL;
742             }
743
744             if( pDevExt->Specific.RDR.CacheFile.Buffer != NULL)
745             {
746
747                 ExFreePool( pDevExt->Specific.RDR.CacheFile.Buffer);
748
749                 pDevExt->Specific.RDR.CacheFile.Buffer = NULL;
750             }
751
752             if( AFSDumpFileLocation.Buffer != NULL)
753             {
754                 ExFreePool( AFSDumpFileLocation.Buffer);
755
756                 AFSDumpFileLocation.Buffer = NULL;
757             }
758
759             if ( pDevExt->Fcb != NULL)
760             {
761
762                 AFSRemoveRdrFcb( &pDevExt->Fcb);
763
764                 pDevExt = NULL;
765             }
766
767             AFSUnloadLibrary( TRUE);
768         }
769     }
770
771     return ntStatus;
772 }
773
774 NTSTATUS
775 AFSCloseRedirector()
776 {
777
778     NTSTATUS ntStatus = STATUS_SUCCESS;
779     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
780
781     __Enter
782     {
783
784         //
785         // Unload the library first so we close off any accesses to the cache or underlying
786         // shared memory
787         //
788
789         AFSUnloadLibrary( TRUE);
790
791         //
792         // Close off the cache file or mapping
793         //
794
795         if( pDevExt->Specific.RDR.CacheMdl != NULL)
796         {
797
798             MmUnmapLockedPages( pDevExt->Specific.RDR.CacheBaseAddress,
799                                 pDevExt->Specific.RDR.CacheMdl);
800
801             MmUnlockPages( pDevExt->Specific.RDR.CacheMdl);
802
803             ExFreePool( pDevExt->Specific.RDR.CacheMdl);
804
805             pDevExt->Specific.RDR.CacheMdl = NULL;
806             pDevExt->Specific.RDR.CacheBaseAddress = NULL;
807             pDevExt->Specific.RDR.CacheLength.QuadPart = 0;
808         }
809
810         if( pDevExt->Specific.RDR.CacheFileHandle != NULL)
811         {
812
813             ZwClose( pDevExt->Specific.RDR.CacheFileHandle);
814
815             pDevExt->Specific.RDR.CacheFileHandle = NULL;
816         }
817
818         if( pDevExt->Specific.RDR.CacheFileObject != NULL)
819         {
820
821             ObDereferenceObject( pDevExt->Specific.RDR.CacheFileObject);
822
823             pDevExt->Specific.RDR.CacheFileObject = NULL;
824         }
825
826         if( pDevExt->Specific.RDR.CacheFile.Buffer != NULL)
827         {
828
829             ExFreePool( pDevExt->Specific.RDR.CacheFile.Buffer);
830
831             pDevExt->Specific.RDR.CacheFile.Buffer = NULL;
832         }
833
834         if( AFSDumpFileLocation.Buffer != NULL)
835         {
836             ExFreePool( AFSDumpFileLocation.Buffer);
837
838             AFSDumpFileLocation.Buffer = NULL;
839         }
840
841         if ( pDevExt->Fcb != NULL)
842         {
843
844             AFSRemoveRdrFcb( &pDevExt->Fcb);
845
846             pDevExt->Fcb = NULL;
847         }
848
849     }
850
851     return ntStatus;
852 }
853
854 //
855 // Function: AFSInitRdrFcb
856 //
857 // Description:
858 //
859 //      This function performs Redirector Fcb initialization
860 //
861 // Return:
862 //
863 //      A status is returned for the function
864 //
865
866 NTSTATUS
867 AFSInitRdrFcb( OUT AFSFcb **RdrFcb)
868 {
869
870     NTSTATUS ntStatus = STATUS_SUCCESS;
871     AFSFcb *pFcb = NULL;
872     AFSNonPagedFcb *pNPFcb = NULL;
873
874     __Enter
875     {
876
877         //
878         // Initialize the root fcb
879         //
880
881         pFcb = (AFSFcb *)AFSExAllocatePoolWithTag( PagedPool,
882                                                    sizeof( AFSFcb),
883                                                    AFS_FCB_ALLOCATION_TAG);
884
885         if( pFcb == NULL)
886         {
887
888             AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
889                           AFS_TRACE_LEVEL_ERROR,
890                           "AFSInitRdrFcb Failed to allocate the root fcb\n"));
891
892             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
893         }
894
895         RtlZeroMemory( pFcb,
896                        sizeof( AFSFcb));
897
898         pFcb->Header.NodeByteSize = sizeof( AFSFcb);
899         pFcb->Header.NodeTypeCode = AFS_REDIRECTOR_FCB;
900
901         pNPFcb = (AFSNonPagedFcb *)AFSExAllocatePoolWithTag( NonPagedPool,
902                                                              sizeof( AFSNonPagedFcb),
903                                                              AFS_FCB_NP_ALLOCATION_TAG);
904
905         if( pNPFcb == NULL)
906         {
907
908             AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
909                           AFS_TRACE_LEVEL_ERROR,
910                           "AFSInitRdrFcb Failed to allocate the non-paged fcb\n"));
911
912             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
913         }
914
915         RtlZeroMemory( pNPFcb,
916                        sizeof( AFSNonPagedFcb));
917
918         pNPFcb->Size = sizeof( AFSNonPagedFcb);
919
920         pNPFcb->Type = AFS_NON_PAGED_FCB;
921
922         //
923         // OK, initialize the entry
924         //
925
926         ExInitializeFastMutex( &pNPFcb->AdvancedHdrMutex);
927
928         FsRtlSetupAdvancedHeader( &pFcb->Header, &pNPFcb->AdvancedHdrMutex);
929
930         ExInitializeResourceLite( &pNPFcb->Resource);
931
932         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
933                       AFS_TRACE_LEVEL_VERBOSE,
934                       "AFSInitRootFcb Acquiring Fcb lock %p EXCL %08lX\n",
935                       &pNPFcb->Resource,
936                       PsGetCurrentThread()));
937
938         ExInitializeResourceLite( &pNPFcb->PagingResource);
939
940         pFcb->Header.Resource = &pNPFcb->Resource;
941
942         pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
943
944         pFcb->NPFcb = pNPFcb;
945
946         if ( InterlockedCompareExchangePointer( (PVOID *)RdrFcb, pFcb, NULL) != NULL)
947         {
948
949             try_return( ntStatus = STATUS_REPARSE);
950         }
951
952 try_exit:
953
954         if( ntStatus != STATUS_SUCCESS)
955         {
956
957             if( pFcb != NULL)
958             {
959
960                 AFSRemoveRdrFcb( &pFcb);
961             }
962         }
963     }
964
965     return ntStatus;
966 }
967
968 //
969 // Function: AFSRemoveRdrFcb
970 //
971 // Description:
972 //
973 //      This function performs Redirector Fcb removal/deallocation
974 //
975 // Return:
976 //
977 //      void.
978 //
979
980 void
981 AFSRemoveRdrFcb( IN OUT AFSFcb **RdrFcb)
982 {
983     AFSFcb *pFcb = NULL;
984
985     pFcb = (AFSFcb *) InterlockedCompareExchangePointer( (PVOID *)RdrFcb, NULL, (PVOID)(*RdrFcb));
986
987     if ( pFcb == NULL)
988     {
989
990         return;
991     }
992
993     if( pFcb->NPFcb != NULL)
994     {
995
996         //
997         // Now the resource
998         //
999
1000         ExDeleteResourceLite( &pFcb->NPFcb->Resource);
1001
1002         ExDeleteResourceLite( &pFcb->NPFcb->PagingResource);
1003
1004         //
1005         // The non paged region
1006         //
1007
1008         AFSExFreePoolWithTag( pFcb->NPFcb, AFS_FCB_NP_ALLOCATION_TAG);
1009     }
1010
1011     //
1012     // And the Fcb itself
1013     //
1014
1015     AFSExFreePoolWithTag( pFcb, AFS_FCB_ALLOCATION_TAG);
1016
1017     return;
1018 }