Remove unnecessary executable bits
[reactos.git] / drivers / filesystems / cdfs_new / cdinit.c
1 /*++
2
3 Copyright (c) 1989-2000 Microsoft Corporation
4
5 Module Name:
6
7 CdInit.c
8
9 Abstract:
10
11 This module implements the DRIVER_INITIALIZATION routine for Cdfs
12
13
14 --*/
15
16 #include "cdprocs.h"
17
18 //
19 // The Bug check file id for this module
20 //
21
22 #define BugCheckFileId (CDFS_BUG_CHECK_CDINIT)
23
24 // Tell prefast the function type.
25 DRIVER_INITIALIZE DriverEntry;
26
27 NTSTATUS
28 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
29 DriverEntry(
30 _In_ PDRIVER_OBJECT DriverObject,
31 _In_ PUNICODE_STRING RegistryPath
32 );
33
34
35 // tell prefast this is a driver unload function
36 DRIVER_UNLOAD CdUnload;
37
38 VOID
39 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
40 CdUnload(
41 _In_ PDRIVER_OBJECT DriverObject
42 );
43
44 NTSTATUS
45 CdInitializeGlobalData (
46 _In_ PDRIVER_OBJECT DriverObject,
47 _In_ PDEVICE_OBJECT FileSystemDeviceObject
48 #ifdef __REACTOS__
49 ,
50 IN PDEVICE_OBJECT HddFileSystemDeviceObject
51 #endif
52 );
53
54 #ifdef ALLOC_PRAGMA
55 #pragma alloc_text(INIT, DriverEntry)
56 #pragma alloc_text(PAGE, CdUnload)
57 #pragma alloc_text(INIT, CdInitializeGlobalData)
58 #endif
59
60 \f
61 //
62 // Local support routine
63 //
64
65 NTSTATUS
66 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
67 DriverEntry(
68 _In_ PDRIVER_OBJECT DriverObject,
69 _In_ PUNICODE_STRING RegistryPath
70 )
71
72 /*++
73
74 Routine Description:
75
76 This is the initialization routine for the Cdrom file system
77 device driver. This routine creates the device object for the FileSystem
78 device and performs all other driver initialization.
79
80 Arguments:
81
82 DriverObject - Pointer to driver object created by the system.
83
84 Return Value:
85
86 NTSTATUS - The function value is the final status from the initialization
87 operation.
88
89 --*/
90
91 {
92 NTSTATUS Status;
93 UNICODE_STRING UnicodeString;
94 PDEVICE_OBJECT CdfsFileSystemDeviceObject;
95 FS_FILTER_CALLBACKS FilterCallbacks;
96 #ifdef __REACTOS__
97 PDEVICE_OBJECT HddFileSystemDeviceObject;
98 #endif
99
100 UNREFERENCED_PARAMETER( RegistryPath );
101
102 //
103 // Create the device object.
104 //
105
106 RtlInitUnicodeString( &UnicodeString, L"\\Cdfs" );
107
108 Status = IoCreateDevice( DriverObject,
109 0,
110 &UnicodeString,
111 FILE_DEVICE_CD_ROM_FILE_SYSTEM,
112 0,
113 FALSE,
114 &CdfsFileSystemDeviceObject );
115
116 if (!NT_SUCCESS( Status )) {
117 return Status;
118 }
119
120 #ifdef __REACTOS__
121 //
122 // Create the HDD device object.
123 //
124
125 RtlInitUnicodeString( &UnicodeString, L"\\CdfsHdd" );
126
127 Status = IoCreateDevice( DriverObject,
128 0,
129 &UnicodeString,
130 FILE_DEVICE_DISK_FILE_SYSTEM,
131 0,
132 FALSE,
133 &HddFileSystemDeviceObject );
134
135 if (!NT_SUCCESS( Status )) {
136 IoDeleteDevice (CdfsFileSystemDeviceObject);
137 return Status;
138 }
139 #endif
140
141 #ifdef _MSC_VER
142 #pragma prefast(push)
143 #pragma prefast(disable: 28155, "the dispatch routine has the correct type, prefast is just being paranoid.")
144 #pragma prefast(disable: 28168, "the dispatch routine has the correct type, prefast is just being paranoid.")
145 #pragma prefast(disable: 28169, "the dispatch routine has the correct type, prefast is just being paranoid.")
146 #pragma prefast(disable: 28175, "we're allowed to change these.")
147 #endif
148
149 DriverObject->DriverUnload = CdUnload;
150
151 //
152 // Note that because of the way data caching is done, we set neither
153 // the Direct I/O or Buffered I/O bit in DeviceObject->Flags. If
154 // data is not in the cache, or the request is not buffered, we may,
155 // set up for Direct I/O by hand.
156 //
157
158 //
159 // Initialize the driver object with this driver's entry points.
160 //
161 // NOTE - Each entry in the dispatch table must have an entry in
162 // the Fsp/Fsd dispatch switch statements.
163 //
164
165 DriverObject->MajorFunction[IRP_MJ_CREATE] =
166 DriverObject->MajorFunction[IRP_MJ_CLOSE] =
167 DriverObject->MajorFunction[IRP_MJ_READ] =
168 DriverObject->MajorFunction[IRP_MJ_WRITE] =
169 DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
170 DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
171 DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION]=
172 DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
173 DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
174 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
175 DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] =
176 DriverObject->MajorFunction[IRP_MJ_CLEANUP] =
177 DriverObject->MajorFunction[IRP_MJ_PNP] =
178 DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH) CdFsdDispatch;
179 #ifdef _MSC_VER
180 #pragma prefast(pop)
181
182 #pragma prefast(suppress: 28175, "this is a file system driver, we're allowed to touch FastIoDispatch.")
183 #endif
184 DriverObject->FastIoDispatch = &CdFastIoDispatch;
185
186 //
187 // Initialize the filter callbacks we use.
188 //
189
190 RtlZeroMemory( &FilterCallbacks,
191 sizeof(FS_FILTER_CALLBACKS) );
192
193 FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
194 FilterCallbacks.PreAcquireForSectionSynchronization = CdFilterCallbackAcquireForCreateSection;
195
196 Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject,
197 &FilterCallbacks );
198
199 if (!NT_SUCCESS( Status )) {
200
201 IoDeleteDevice( CdfsFileSystemDeviceObject );
202 #ifdef __REACTOS__
203 IoDeleteDevice (HddFileSystemDeviceObject);
204 #endif
205 return Status;
206 }
207
208 //
209 // Initialize the global data structures
210 //
211
212 #ifndef __REACTOS__
213 Status = CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject );
214 #else
215 Status = CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject, HddFileSystemDeviceObject );
216 #endif
217 if (!NT_SUCCESS (Status)) {
218 IoDeleteDevice (CdfsFileSystemDeviceObject);
219 #ifdef __REACTOS__
220 IoDeleteDevice (HddFileSystemDeviceObject);
221 #endif
222 return Status;
223 }
224
225 //
226 // Register the file system as low priority with the I/O system. This will cause
227 // CDFS to receive mount requests after a) other filesystems currently registered
228 // and b) other normal priority filesystems that may be registered later.
229 //
230
231 CdfsFileSystemDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
232 #ifdef __REACTOS__
233 HddFileSystemDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
234 #endif
235
236 IoRegisterFileSystem( CdfsFileSystemDeviceObject );
237 ObReferenceObject (CdfsFileSystemDeviceObject);
238 #ifdef __REACTOS__
239 IoRegisterFileSystem( HddFileSystemDeviceObject );
240 ObReferenceObject (HddFileSystemDeviceObject);
241 #endif
242
243 #ifdef CDFS_TELEMETRY_DATA
244 //
245 // Initialize Telemetry
246 //
247
248 CdInitializeTelemetry();
249
250 #endif
251
252 //
253 // And return to our caller
254 //
255
256 return( STATUS_SUCCESS );
257 }
258
259
260 VOID
261 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
262 CdUnload(
263 _In_ PDRIVER_OBJECT DriverObject
264 )
265 /*++
266
267 Routine Description:
268
269 This routine unload routine for CDFS.
270
271 Arguments:
272
273 DriverObject - Supplies the driver object for CDFS.
274
275 Return Value:
276
277 None.
278
279 --*/
280 {
281 PIRP_CONTEXT IrpContext;
282
283 PAGED_CODE();
284
285 UNREFERENCED_PARAMETER( DriverObject );
286
287 //
288 // Free any IRP contexts
289 //
290 while (1) {
291 IrpContext = (PIRP_CONTEXT) PopEntryList( &CdData.IrpContextList) ;
292 if (IrpContext == NULL) {
293 break;
294 }
295 CdFreePool(&IrpContext);
296 }
297
298 IoFreeWorkItem (CdData.CloseItem);
299 ExDeleteResourceLite( &CdData.DataResource );
300 ObDereferenceObject (CdData.FileSystemDeviceObject);
301 #ifdef __REACTOS__
302 ObDereferenceObject (CdData.HddFileSystemDeviceObject);
303 #endif
304 }
305 \f
306 //
307 // Local support routine
308 //
309
310 NTSTATUS
311 CdInitializeGlobalData (
312 _In_ PDRIVER_OBJECT DriverObject,
313 _In_ PDEVICE_OBJECT FileSystemDeviceObject
314 #ifdef __REACTOS__
315 ,
316 IN PDEVICE_OBJECT HddFileSystemDeviceObject
317 #endif
318 )
319
320 /*++
321
322 Routine Description:
323
324 This routine initializes the global cdfs data structures.
325
326 Arguments:
327
328 DriverObject - Supplies the driver object for CDFS.
329
330 FileSystemDeviceObject - Supplies the device object for CDFS.
331
332 Return Value:
333
334 None.
335
336 --*/
337
338 {
339 //
340 // Start by initializing the FastIoDispatch Table.
341 //
342
343 RtlZeroMemory( &CdFastIoDispatch, sizeof( FAST_IO_DISPATCH ));
344
345 CdFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
346
347 #ifdef _MSC_VER
348 #pragma prefast(push)
349 #pragma prefast(disable:28155, "these are all correct")
350 #endif
351
352 CdFastIoDispatch.FastIoCheckIfPossible = CdFastIoCheckIfPossible; // CheckForFastIo
353 CdFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read
354 CdFastIoDispatch.FastIoQueryBasicInfo = CdFastQueryBasicInfo; // QueryBasicInfo
355 CdFastIoDispatch.FastIoQueryStandardInfo = CdFastQueryStdInfo; // QueryStandardInfo
356 CdFastIoDispatch.FastIoLock = CdFastLock; // Lock
357 CdFastIoDispatch.FastIoUnlockSingle = CdFastUnlockSingle; // UnlockSingle
358 CdFastIoDispatch.FastIoUnlockAll = CdFastUnlockAll; // UnlockAll
359 CdFastIoDispatch.FastIoUnlockAllByKey = CdFastUnlockAllByKey; // UnlockAllByKey
360 //
361 // This callback has been replaced by CdFilterCallbackAcquireForCreateSection.
362 //
363
364 CdFastIoDispatch.AcquireFileForNtCreateSection = NULL;
365 CdFastIoDispatch.ReleaseFileForNtCreateSection = CdReleaseForCreateSection;
366 CdFastIoDispatch.FastIoQueryNetworkOpenInfo = CdFastQueryNetworkInfo; // QueryNetworkInfo
367
368 CdFastIoDispatch.MdlRead = FsRtlMdlReadDev;
369 CdFastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
370 CdFastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
371 CdFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
372
373 #ifdef _MSC_VER
374 #pragma prefast(pop)
375 #endif
376
377 //
378 // Initialize the CdData structure.
379 //
380
381 RtlZeroMemory( &CdData, sizeof( CD_DATA ));
382
383 CdData.NodeTypeCode = CDFS_NTC_DATA_HEADER;
384 CdData.NodeByteSize = sizeof( CD_DATA );
385
386 CdData.DriverObject = DriverObject;
387 CdData.FileSystemDeviceObject = FileSystemDeviceObject;
388 #ifdef __REACTOS__
389 CdData.HddFileSystemDeviceObject = HddFileSystemDeviceObject;
390 #endif
391
392 InitializeListHead( &CdData.VcbQueue );
393
394 ExInitializeResourceLite( &CdData.DataResource );
395
396 //
397 // Initialize the cache manager callback routines
398 //
399
400 CdData.CacheManagerCallbacks.AcquireForLazyWrite = (PVOID)&CdAcquireForCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */
401 CdData.CacheManagerCallbacks.ReleaseFromLazyWrite = (PVOID)&CdReleaseFromCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */
402 CdData.CacheManagerCallbacks.AcquireForReadAhead = (PVOID)&CdAcquireForCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */
403 CdData.CacheManagerCallbacks.ReleaseFromReadAhead = (PVOID)&CdReleaseFromCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */
404
405 CdData.CacheManagerVolumeCallbacks.AcquireForLazyWrite = &CdNoopAcquire;
406 CdData.CacheManagerVolumeCallbacks.ReleaseFromLazyWrite = &CdNoopRelease;
407 CdData.CacheManagerVolumeCallbacks.AcquireForReadAhead = &CdNoopAcquire;
408 CdData.CacheManagerVolumeCallbacks.ReleaseFromReadAhead = &CdNoopRelease;
409
410 //
411 // Initialize the lock mutex and the async and delay close queues.
412 //
413
414 ExInitializeFastMutex( &CdData.CdDataMutex );
415 InitializeListHead( &CdData.AsyncCloseQueue );
416 InitializeListHead( &CdData.DelayedCloseQueue );
417
418 CdData.CloseItem = IoAllocateWorkItem (FileSystemDeviceObject);
419 if (CdData.CloseItem == NULL) {
420
421 ExDeleteResourceLite( &CdData.DataResource );
422 return STATUS_INSUFFICIENT_RESOURCES;
423 }
424 //
425 // Do the initialization based on the system size.
426 //
427
428 switch (MmQuerySystemSize()) {
429
430 case MmSmallSystem:
431
432 CdData.IrpContextMaxDepth = 4;
433 CdData.MaxDelayedCloseCount = 8;
434 CdData.MinDelayedCloseCount = 2;
435 break;
436
437 case MmMediumSystem:
438
439 CdData.IrpContextMaxDepth = 8;
440 CdData.MaxDelayedCloseCount = 24;
441 CdData.MinDelayedCloseCount = 6;
442 break;
443
444 case MmLargeSystem:
445
446 CdData.IrpContextMaxDepth = 32;
447 CdData.MaxDelayedCloseCount = 72;
448 CdData.MinDelayedCloseCount = 18;
449 break;
450 }
451 return STATUS_SUCCESS;
452 }
453