ReactOS 0.4.15-dev-5672-gf73ac17
fs_rec.c File Reference
#include "fs_rec.h"
#include <debug.h>
Include dependency graph for fs_rec.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

NTSTATUS NTAPI FsRecLoadFileSystem (IN PDEVICE_OBJECT DeviceObject, IN PWCHAR DriverServiceName)
 
NTSTATUS NTAPI FsRecCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI FsRecClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS NTAPI FsRecFsControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
VOID NTAPI FsRecUnload (IN PDRIVER_OBJECT DriverObject)
 
NTSTATUS NTAPI FsRecRegisterFs (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT ParentObject OPTIONAL, OUT PDEVICE_OBJECT *NewDeviceObject OPTIONAL, IN PCWSTR FsName, IN PCWSTR RecognizerName, IN ULONG FsType, IN DEVICE_TYPE DeviceType, IN ULONG AdditionalFlags)
 
NTSTATUS NTAPI DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
 

Variables

PKEVENT FsRecLoadSync
 
DRIVER_DISPATCH FsRecCreate
 
DRIVER_DISPATCH FsRecClose
 
DRIVER_DISPATCH FsRecFsControl
 
DRIVER_UNLOAD FsRecUnload
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 14 of file fs_rec.c.

Function Documentation

◆ DriverEntry()

NTSTATUS NTAPI DriverEntry ( IN PDRIVER_OBJECT  DriverObject,
IN PUNICODE_STRING  RegistryPath 
)

Definition at line 324 of file fs_rec.c.

326{
328 ULONG DeviceCount = 0;
329 PDEVICE_OBJECT CdfsObject;
330 PDEVICE_OBJECT UdfsObject;
331 PDEVICE_OBJECT FatObject;
332
333 PAGED_CODE();
334
336
337 /* Page the entire driver */
339
340 /* Allocate the lock */
342 sizeof(KEVENT),
343 FSREC_TAG);
345
346 /* Initialize it */
348
349 /* Setup the major functions */
350 DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRecCreate;
351 DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsRecClose;
352 DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FsRecClose;
354 DriverObject->DriverUnload = FsRecUnload;
355
356 /* Register CDFS for CDs */
358 NULL,
359 &CdfsObject,
360 L"\\Cdfs",
361 L"\\FileSystem\\CdfsRecognizer",
366
367 /* Register CDFS for HDDs */
369 CdfsObject,
370 NULL,
371 L"\\CdfsHdd",
372 L"\\FileSystem\\CdfsHddRecognizer",
377
378 /* Register UDFS for CDs */
380 NULL,
381 &UdfsObject,
382 L"\\UdfsCdRom",
383 L"\\FileSystem\\UdfsCdRomRecognizer",
386 0);
388
389 /* Register UDFS for HDDs */
391 UdfsObject,
392 NULL,
393 L"\\UdfsDisk",
394 L"\\FileSystem\\UdfsDiskRecognizer",
397 0);
399
400 /* Register FAT */
402 NULL,
403 &FatObject,
404 L"\\Fat",
405 L"\\FileSystem\\FatRecognizer",
408 0);
410
411 /* Register FAT for CDs */
413 FatObject,
414 NULL,
415 L"\\FatCdrom",
416 L"\\FileSystem\\FatCdRomRecognizer",
419 0);
421
422 /* Register NTFS */
424 NULL,
425 NULL,
426 L"\\Ntfs",
427 L"\\FileSystem\\NtfsRecognizer",
430 0);
432
433 /* Register EXT2 */
435 NULL,
436 NULL,
437 L"\\Ext2fs",
438 L"\\FileSystem\\Ext2Recognizer",
441 0);
443
444 /* Register BTRFS */
446 NULL,
447 NULL,
448 L"\\Btrfs",
449 L"\\FileSystem\\BtrfsRecognizer",
452 0);
454
455 /* Register REISERFS */
457 NULL,
458 NULL,
459 L"\\Reiserfs",
460 L"\\FileSystem\\ReiserfsRecognizer",
463 0);
465
466 /* Register FFS */
468 NULL,
469 NULL,
470 L"\\ffs",
471 L"\\FileSystem\\FfsRecognizer",
474 0);
476
477 /* Register FATX */
479 NULL,
480 NULL,
481 L"\\FatX",
482 L"\\FileSystem\\FatXRecognizer",
485 0);
487
488 /* Return appropriate Status */
490}
#define PAGED_CODE()
LONG NTSTATUS
Definition: precomp.h:26
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define NonPagedPool
Definition: env_spec_w32.h:307
DRIVER_DISPATCH FsRecCreate
Definition: fs_rec.c:78
DRIVER_DISPATCH FsRecClose
Definition: fs_rec.c:109
DRIVER_DISPATCH FsRecFsControl
Definition: fs_rec.c:124
NTSTATUS NTAPI FsRecRegisterFs(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT ParentObject OPTIONAL, OUT PDEVICE_OBJECT *NewDeviceObject OPTIONAL, IN PCWSTR FsName, IN PCWSTR RecognizerName, IN ULONG FsType, IN DEVICE_TYPE DeviceType, IN ULONG AdditionalFlags)
Definition: fs_rec.c:223
DRIVER_UNLOAD FsRecUnload
Definition: fs_rec.c:203
PKEVENT FsRecLoadSync
Definition: fs_rec.c:17
@ FS_TYPE_UDFS
Definition: fs_rec.h:175
@ FS_TYPE_BTRFS
Definition: fs_rec.h:177
@ FS_TYPE_NTFS
Definition: fs_rec.h:173
@ FS_TYPE_FFS
Definition: fs_rec.h:179
@ FS_TYPE_CDFS
Definition: fs_rec.h:174
@ FS_TYPE_FATX
Definition: fs_rec.h:180
@ FS_TYPE_EXT2
Definition: fs_rec.h:176
@ FS_TYPE_REISERFS
Definition: fs_rec.h:178
@ FS_TYPE_VFAT
Definition: fs_rec.h:172
#define FSREC_TAG
Definition: fs_rec.h:16
Status
Definition: gdiplustypes.h:25
ULONG DeviceCount
Definition: mpu401.c:26
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
@ SynchronizationEvent
#define STATUS_IMAGE_ALREADY_LOADED
Definition: ntstatus.h:506
#define L(x)
Definition: ntvdm.h:50
#define FILE_DEVICE_DISK_FILE_SYSTEM
Definition: winioctl.h:114
#define FILE_DEVICE_CD_ROM_FILE_SYSTEM
Definition: winioctl.h:109
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define STATUS_SUCCESS
Definition: shellext.h:65
PVOID NTAPI MmPageEntireDriver(IN PVOID AddressWithinSection)
Definition: sysldr.c:3504
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define DO_LOW_PRIORITY_FILESYSTEM
#define IRP_MJ_CLEANUP

◆ FsRecClose()

NTSTATUS NTAPI FsRecClose ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 112 of file fs_rec.c.

114{
115 PAGED_CODE();
116
118
119 /* Just complete the IRP and return success */
121 return STATUS_SUCCESS;
122}
_In_ PIRP Irp
Definition: csq.h:116
#define IoCompleteRequest
Definition: irp.c:1240
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define IO_NO_INCREMENT
Definition: iotypes.h:598

◆ FsRecCreate()

NTSTATUS NTAPI FsRecCreate ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 81 of file fs_rec.c.

83{
86 PAGED_CODE();
87
89
90 /* Make sure we have a file name */
91 if (IoStack->FileObject->FileName.Length)
92 {
93 /* Fail the request */
95 }
96 else
97 {
98 /* Let it through */
100 }
101
102 /* Complete the IRP */
103 Irp->IoStatus.Status = Status;
104 Irp->IoStatus.Information = FILE_OPENED;
106 return Status;
107}
#define FILE_OPENED
Definition: nt_native.h:769
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
#define STATUS_OBJECT_PATH_NOT_FOUND
Definition: udferr_usr.h:151
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793

◆ FsRecFsControl()

NTSTATUS NTAPI FsRecFsControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 127 of file fs_rec.c.

129{
130 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
132 PAGED_CODE();
133
134 /* Check the file system type */
135 switch (DeviceExtension->FsType)
136 {
137 case FS_TYPE_VFAT:
138
139 /* Send FAT command */
141 break;
142
143 case FS_TYPE_NTFS:
144
145 /* Send NTFS command */
147 break;
148
149 case FS_TYPE_CDFS:
150
151 /* Send CDFS command */
153 break;
154
155 case FS_TYPE_UDFS:
156
157 /* Send UDFS command */
159 break;
160
161 case FS_TYPE_EXT2:
162
163 /* Send EXT2 command */
165 break;
166
167 case FS_TYPE_BTRFS:
168
169 /* Send BTRFS command */
171 break;
172
173 case FS_TYPE_REISERFS:
174
175 /* Send REISERFS command */
177 break;
178
179 case FS_TYPE_FFS:
180
181 /* Send FFS command */
183 break;
184
185 case FS_TYPE_FATX:
186
187 /* Send FATX command */
189 break;
190
191 default:
192
193 /* Unrecognized FS */
195 }
196
197 /* Complete the IRP */
198 Irp->IoStatus.Status = Status;
200 return Status;
201}
NTSTATUS NTAPI FsRecCdfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: cdfs.c:66
NTSTATUS NTAPI FsRecBtrfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: btrfs.c:30
NTSTATUS NTAPI FsRecExt2FsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: ext2.c:30
NTSTATUS NTAPI FsRecVfatFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: fat.c:100
NTSTATUS NTAPI FsRecFatxFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: fatx.c:66
NTSTATUS NTAPI FsRecFfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: ffs.c:43
NTSTATUS NTAPI FsRecNtfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: ntfs.c:52
NTSTATUS NTAPI FsRecReiserfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: reiserfs.c:43
NTSTATUS NTAPI FsRecUdfsFsControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: udfs.c:106
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138

◆ FsRecLoadFileSystem()

NTSTATUS NTAPI FsRecLoadFileSystem ( IN PDEVICE_OBJECT  DeviceObject,
IN PWCHAR  DriverServiceName 
)

Definition at line 23 of file fs_rec.c.

25{
27 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
28 UNICODE_STRING DriverName;
29
30 PAGED_CODE();
31
32 /* Make sure we haven't already been called */
33 if (DeviceExtension->State != Loaded)
34 {
35 /* Acquire the load lock */
40 FALSE,
41 NULL);
42
43 /* Make sure we're active */
44 if (DeviceExtension->State == Pending)
45 {
46 /* Load the FS driver */
47 RtlInitUnicodeString(&DriverName, DriverServiceName);
48 Status = ZwLoadDriver(&DriverName);
49
50 /* Loop all the linked recognizer objects */
51 while (DeviceExtension->State != Unloading)
52 {
53 /* Set them to the unload state */
54 DeviceExtension->State = Unloading;
55
56 /* Go to the next one */
57 DeviceObject = DeviceExtension->Alternate;
58 DeviceExtension = DeviceObject->DeviceExtension;
59 }
60 }
61
62 /* Make sure that we haven't already loaded the FS */
63 if (DeviceExtension->State != Loaded)
64 {
65 /* Unregister us, and set us as loaded */
67 DeviceExtension->State = Loaded;
68 }
69
70 /* Release the lock */
73 }
74
75 return Status;
76}
#define FALSE
Definition: types.h:117
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
@ Pending
Definition: fs_rec.h:186
@ Unloading
Definition: fs_rec.h:188
@ Loaded
Definition: fs_rec.h:187
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
#define KernelMode
Definition: asm.h:34
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
VOID NTAPI IoUnregisterFileSystem(IN PDEVICE_OBJECT DeviceObject)
Definition: volume.c:1056
@ Executive
Definition: ketypes.h:403

Referenced by FsRecBtrfsFsControl(), FsRecCdfsFsControl(), FsRecExt2FsControl(), FsRecFatxFsControl(), FsRecFfsFsControl(), FsRecNtfsFsControl(), FsRecReiserfsFsControl(), FsRecUdfsFsControl(), and FsRecVfatFsControl().

◆ FsRecRegisterFs()

NTSTATUS NTAPI FsRecRegisterFs ( IN PDRIVER_OBJECT  DriverObject,
IN PDEVICE_OBJECT ParentObject  OPTIONAL,
OUT PDEVICE_OBJECT *NewDeviceObject  OPTIONAL,
IN PCWSTR  FsName,
IN PCWSTR  RecognizerName,
IN ULONG  FsType,
IN DEVICE_TYPE  DeviceType,
IN ULONG  AdditionalFlags 
)

Definition at line 223 of file fs_rec.c.

231{
234 PDEVICE_EXTENSION DeviceExtension;
239
240 /* Assume failure */
241 if (NewDeviceObject) *NewDeviceObject = NULL;
242
243 /* Setup the attributes */
246 &DeviceName,
248 0,
249 NULL);
250
251 /* Open the device */
252 Status = ZwCreateFile(&FileHandle,
255 &IoStatus,
256 NULL,
257 0,
259 FILE_OPEN,
260 0,
261 NULL,
262 0);
263 if (NT_SUCCESS(Status))
264 {
265 /* We succeeded, close the handle */
267 }
269 {
270 /* We failed with anything else then what we want to fail with */
272 }
273
274 /* If we succeeded, there's no point in trying this again */
276
277 /* Create recognizer device object */
278 RtlInitUnicodeString(&DeviceName, RecognizerName);
280 sizeof(DEVICE_EXTENSION),
281 &DeviceName,
283 0,
284 FALSE,
285 &DeviceObject);
286 if (NT_SUCCESS(Status))
287 {
288 /* Set additional flags in the device object */
289 DeviceObject->Flags |= AdditionalFlags;
290
291 /* Get the device extension and set it up */
292 DeviceExtension = DeviceObject->DeviceExtension;
293 DeviceExtension->FsType = FsType;
294 DeviceExtension->State = Pending;
295
296 /* Do we have a parent? */
297 if (ParentObject)
298 {
299 /* Link it in */
300 DeviceExtension->Alternate =
301 ((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate;
302 ((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate =
304 }
305 else
306 {
307 /* Otherwise, we're the only one */
308 DeviceExtension->Alternate = DeviceObject;
309 }
310
311 /* Return the DO if needed */
312 if (NewDeviceObject) *NewDeviceObject = DeviceObject;
313
314 /* Register the file system */
316 }
317
318 /* Return Status */
319 return Status;
320}
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define FILE_SHARE_READ
Definition: compat.h:136
struct _BEEP_DEVICE_EXTENSION * PDEVICE_EXTENSION
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
#define FILE_OPEN
Definition: from_kernel.h:54
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
DeviceType
Definition: mmdrv.h:42
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define SYNCHRONIZE
Definition: nt_native.h:61
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
VOID NTAPI IoRegisterFileSystem(IN PDEVICE_OBJECT DeviceObject)
Definition: volume.c:987
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3275

Referenced by DriverEntry().

◆ FsRecUnload()

VOID NTAPI FsRecUnload ( IN PDRIVER_OBJECT  DriverObject)

Definition at line 206 of file fs_rec.c.

207{
208 PAGED_CODE();
209
210 /* Loop all driver device objects */
211 while (DriverObject->DeviceObject)
212 {
213 /* Delete this device */
214 IoDeleteDevice(DriverObject->DeviceObject);
215 }
216
217 /* Free the lock */
219}
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251

Variable Documentation

◆ FsRecClose

DRIVER_DISPATCH FsRecClose

Definition at line 109 of file fs_rec.c.

Referenced by DriverEntry().

◆ FsRecCreate

DRIVER_DISPATCH FsRecCreate

Definition at line 78 of file fs_rec.c.

Referenced by DriverEntry().

◆ FsRecFsControl

DRIVER_DISPATCH FsRecFsControl

Definition at line 124 of file fs_rec.c.

Referenced by DriverEntry().

◆ FsRecLoadSync

PKEVENT FsRecLoadSync

Definition at line 17 of file fs_rec.c.

Referenced by DriverEntry(), FsRecLoadFileSystem(), and FsRecUnload().

◆ FsRecUnload

DRIVER_UNLOAD FsRecUnload

Definition at line 203 of file fs_rec.c.

Referenced by DriverEntry().