xref: /reactos/drivers/filesystems/fs_rec/fs_rec.c (revision 50cf16b3) 
1 /*
2  * COPYRIGHT:        See COPYING in the top level directory
3  * PROJECT:          ReactOS File System Recognizer
4  * FILE:             drivers/filesystems/fs_rec/fs_rec.c
5  * PURPOSE:          Main Driver Entrypoint and FS Registration
6  * PROGRAMMER:       Alex Ionescu (alex.ionescu@reactos.org)
7  *                   Eric Kohl
8  */
9 
10 /* INCLUDES *****************************************************************/
11 
12 #include "fs_rec.h"
13 
14 #define NDEBUG
15 #include <debug.h>
16 
17 PKEVENT FsRecLoadSync;
18 
19 /* FUNCTIONS ****************************************************************/
20 
21 NTSTATUS
22 NTAPI
23 FsRecLoadFileSystem(IN PDEVICE_OBJECT DeviceObject,
24                     IN PWCHAR DriverServiceName)
25 {
26     UNICODE_STRING DriverName;
27     PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
28     NTSTATUS Status = STATUS_IMAGE_ALREADY_LOADED;
29     PAGED_CODE();
30 
31     /* Make sure we haven't already been called */
32     if (DeviceExtension->State != Loaded)
33     {
34         /* Acquire the load lock */
35         KeWaitForSingleObject(FsRecLoadSync,
36                               Executive,
37                               KernelMode,
38                               FALSE,
39                               NULL);
40         KeEnterCriticalRegion();
41 
42         /* Make sure we're active */
43         if (DeviceExtension->State == Pending)
44         {
45             /* Load the FS driver */
46             RtlInitUnicodeString(&DriverName, DriverServiceName);
47             Status = ZwLoadDriver(&DriverName);
48 
49             /* Loop all the linked recognizer objects */
50             while (DeviceExtension->State != Unloading)
51             {
52                 /* Set them to the unload state */
53                 DeviceExtension->State = Unloading;
54 
55                 /* Go to the next one */
56                 DeviceObject = DeviceExtension->Alternate;
57                 DeviceExtension = DeviceObject->DeviceExtension;
58             }
59         }
60 
61         /* Make sure that we haven't already loaded the FS */
62         if (DeviceExtension->State != Loaded)
63         {
64             /* Unregister us, and set us as loaded */
65             IoUnregisterFileSystem(DeviceObject);
66             DeviceExtension->State = Loaded;
67         }
68 
69         /* Release the lock */
70         KeSetEvent(FsRecLoadSync, 0, FALSE);
71         KeLeaveCriticalRegion();
72     }
73 
74     /* Return */
75     return Status;
76 }
77 
78 DRIVER_DISPATCH FsRecCreate;
79 NTSTATUS
80 NTAPI
81 FsRecCreate(IN PDEVICE_OBJECT DeviceObject,
82             IN PIRP Irp)
83 {
84     PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
85     NTSTATUS Status;
86     PAGED_CODE();
87 
88     UNREFERENCED_PARAMETER(DeviceObject);
89 
90     /* Make sure we have a file name */
91     if (IoStack->FileObject->FileName.Length)
92     {
93         /* Fail the request */
94         Status = STATUS_OBJECT_PATH_NOT_FOUND;
95     }
96     else
97     {
98         /* Let it through */
99         Status = STATUS_SUCCESS;
100     }
101 
102     /* Complete the IRP */
103     Irp->IoStatus.Status = Status;
104     Irp->IoStatus.Information = FILE_OPENED;
105     IoCompleteRequest(Irp, IO_NO_INCREMENT);
106     return Status;
107 }
108 
109 DRIVER_DISPATCH FsRecClose;
110 NTSTATUS
111 NTAPI
112 FsRecClose(IN PDEVICE_OBJECT DeviceObject,
113            IN PIRP Irp)
114 {
115     PAGED_CODE();
116 
117     UNREFERENCED_PARAMETER(DeviceObject);
118 
119     /* Just complete the IRP and return success */
120     IoCompleteRequest(Irp, IO_NO_INCREMENT);
121     return STATUS_SUCCESS;
122 }
123 
124 DRIVER_DISPATCH FsRecFsControl;
125 NTSTATUS
126 NTAPI
127 FsRecFsControl(IN PDEVICE_OBJECT DeviceObject,
128                IN PIRP Irp)
129 {
130     PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
131     NTSTATUS Status;
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 */
140             Status = FsRecVfatFsControl(DeviceObject, Irp);
141             break;
142 
143         case FS_TYPE_NTFS:
144 
145             /* Send NTFS command */
146             Status = FsRecNtfsFsControl(DeviceObject, Irp);
147             break;
148 
149         case FS_TYPE_CDFS:
150 
151             /* Send CDFS command */
152             Status = FsRecCdfsFsControl(DeviceObject, Irp);
153             break;
154 
155         case FS_TYPE_UDFS:
156 
157             /* Send UDFS command */
158             Status = FsRecUdfsFsControl(DeviceObject, Irp);
159             break;
160 
161         case FS_TYPE_EXT2:
162 
163             /* Send EXT2 command */
164             Status = FsRecExt2FsControl(DeviceObject, Irp);
165             break;
166 
167         case FS_TYPE_BTRFS:
168 
169             /* Send BTRFS command */
170             Status = FsRecBtrfsFsControl(DeviceObject, Irp);
171             break;
172 
173         case FS_TYPE_REISERFS:
174 
175             /* Send REISERFS command */
176             Status = FsRecReiserfsFsControl(DeviceObject, Irp);
177             break;
178 
179         case FS_TYPE_FFS:
180 
181             /* Send FFS command */
182             Status = FsRecFfsFsControl(DeviceObject, Irp);
183             break;
184 
185         default:
186 
187             /* Unrecognized FS */
188             Status = STATUS_INVALID_DEVICE_REQUEST;
189     }
190 
191     /* Complete the IRP */
192     Irp->IoStatus.Status = Status;
193     IoCompleteRequest(Irp, IO_NO_INCREMENT);
194     return Status;
195 }
196 
197 DRIVER_UNLOAD FsRecUnload;
198 VOID
199 NTAPI
200 FsRecUnload(IN PDRIVER_OBJECT DriverObject)
201 {
202     PAGED_CODE();
203 
204     /* Loop all driver device objects */
205     while (DriverObject->DeviceObject)
206     {
207         /* Delete this device */
208         IoDeleteDevice(DriverObject->DeviceObject);
209     }
210 
211     /* Free the lock */
212     ExFreePool(FsRecLoadSync);
213 }
214 
215 NTSTATUS
216 NTAPI
217 FsRecRegisterFs(IN PDRIVER_OBJECT DriverObject,
218                 IN PDEVICE_OBJECT ParentObject OPTIONAL,
219                 OUT PDEVICE_OBJECT *NewDeviceObject OPTIONAL,
220                 IN PCWSTR FsName,
221                 IN PCWSTR RecognizerName,
222                 IN ULONG FsType,
223                 IN DEVICE_TYPE DeviceType,
224                 IN ULONG AdditionalFlags)
225 {
226     OBJECT_ATTRIBUTES ObjectAttributes;
227     IO_STATUS_BLOCK IoStatus;
228     PDEVICE_EXTENSION DeviceExtension;
229     UNICODE_STRING DeviceName;
230     PDEVICE_OBJECT DeviceObject;
231     HANDLE FileHandle;
232     NTSTATUS Status;
233 
234     /* Assume failure */
235     if (NewDeviceObject) *NewDeviceObject = NULL;
236 
237     /* Setup the attributes */
238     RtlInitUnicodeString(&DeviceName, FsName);
239     InitializeObjectAttributes(&ObjectAttributes,
240                                &DeviceName,
241                                OBJ_CASE_INSENSITIVE,
242                                0,
243                                NULL);
244 
245     /* Open the device */
246     Status = ZwCreateFile(&FileHandle,
247                           SYNCHRONIZE,
248                           &ObjectAttributes,
249                           &IoStatus,
250                           NULL,
251                           0,
252                           FILE_SHARE_READ | FILE_SHARE_WRITE,
253                           FILE_OPEN,
254                           0,
255                           NULL,
256                           0);
257     if (NT_SUCCESS(Status))
258     {
259         /* We succeeded, close the handle */
260         ZwClose(FileHandle);
261     }
262     else if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
263     {
264         /* We failed with anything else then what we want to fail with */
265         Status = STATUS_SUCCESS;
266     }
267 
268     /* If we succeeded, there's no point in trying this again */
269     if (NT_SUCCESS(Status)) return STATUS_IMAGE_ALREADY_LOADED;
270 
271     /* Create recognizer device object */
272     RtlInitUnicodeString(&DeviceName, RecognizerName);
273     Status = IoCreateDevice(DriverObject,
274                             sizeof(DEVICE_EXTENSION),
275                             &DeviceName,
276                             DeviceType,
277                             0,
278                             FALSE,
279                             &DeviceObject);
280     if (NT_SUCCESS(Status))
281     {
282         /* Set additional flags in the device object */
283         DeviceObject->Flags |= AdditionalFlags;
284 
285         /* Get the device extension and set it up */
286         DeviceExtension = DeviceObject->DeviceExtension;
287         DeviceExtension->FsType = FsType;
288         DeviceExtension->State = Pending;
289 
290         /* Do we have a parent? */
291         if (ParentObject)
292         {
293             /* Link it in */
294             DeviceExtension->Alternate =
295                 ((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate;
296             ((PDEVICE_EXTENSION)ParentObject->DeviceExtension)->Alternate =
297                 DeviceObject;
298         }
299         else
300         {
301             /* Otherwise, we're the only one */
302             DeviceExtension->Alternate = DeviceObject;
303         }
304 
305         /* Return the DO if needed */
306         if (NewDeviceObject) *NewDeviceObject = DeviceObject;
307 
308         /* Register the file system */
309         IoRegisterFileSystem(DeviceObject);
310     }
311 
312     /* Return Status */
313     return Status;
314 }
315 
316 NTSTATUS
317 NTAPI
318 DriverEntry(IN PDRIVER_OBJECT DriverObject,
319             IN PUNICODE_STRING RegistryPath)
320 {
321     ULONG DeviceCount = 0;
322     NTSTATUS Status;
323     PDEVICE_OBJECT CdfsObject;
324     PDEVICE_OBJECT UdfsObject;
325     PAGED_CODE();
326 
327     UNREFERENCED_PARAMETER(RegistryPath);
328 
329     /* Page the entire driver */
330     MmPageEntireDriver(DriverEntry);
331 
332     /* Allocate the lock */
333     FsRecLoadSync = ExAllocatePoolWithTag(NonPagedPool,
334                                           sizeof(KEVENT),
335                                           FSREC_TAG);
336     if (!FsRecLoadSync) return STATUS_INSUFFICIENT_RESOURCES;
337 
338     /* Initialize it */
339     KeInitializeEvent(FsRecLoadSync, SynchronizationEvent, TRUE);
340 
341     /* Setup the major functions */
342     DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRecCreate;
343     DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsRecClose;
344     DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FsRecClose;
345     DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FsRecFsControl;
346     DriverObject->DriverUnload = FsRecUnload;
347 
348     /* Register CDFS for CDs */
349     Status = FsRecRegisterFs(DriverObject,
350                              NULL,
351                              &CdfsObject,
352                              L"\\Cdfs",
353                              L"\\FileSystem\\CdfsRecognizer",
354                              FS_TYPE_CDFS,
355                              FILE_DEVICE_CD_ROM_FILE_SYSTEM,
356                              DO_LOW_PRIORITY_FILESYSTEM);
357     if (NT_SUCCESS(Status)) DeviceCount++;
358 
359     /* Register CDFS for HDDs */
360     Status = FsRecRegisterFs(DriverObject,
361                              CdfsObject,
362                              NULL,
363                              L"\\CdfsHdd",
364                              L"\\FileSystem\\CdfsHddRecognizer",
365                              FS_TYPE_CDFS,
366                              FILE_DEVICE_DISK_FILE_SYSTEM,
367                              DO_LOW_PRIORITY_FILESYSTEM);
368     if (NT_SUCCESS(Status)) DeviceCount++;
369 
370     /* Register UDFS for CDs */
371     Status = FsRecRegisterFs(DriverObject,
372                              NULL,
373                              &UdfsObject,
374                              L"\\UdfsCdRom",
375                              L"\\FileSystem\\UdfsCdRomRecognizer",
376                              FS_TYPE_UDFS,
377                              FILE_DEVICE_CD_ROM_FILE_SYSTEM,
378                              0);
379     if (NT_SUCCESS(Status)) DeviceCount++;
380 
381     /* Register UDFS for HDDs */
382     Status = FsRecRegisterFs(DriverObject,
383                              UdfsObject,
384                              NULL,
385                              L"\\UdfsDisk",
386                              L"\\FileSystem\\UdfsDiskRecognizer",
387                              FS_TYPE_UDFS,
388                              FILE_DEVICE_DISK_FILE_SYSTEM,
389                              0);
390     if (NT_SUCCESS(Status)) DeviceCount++;
391 
392     /* Register FAT */
393     Status = FsRecRegisterFs(DriverObject,
394                              NULL,
395                              NULL,
396                              L"\\Fat",
397                              L"\\FileSystem\\FatRecognizer",
398                              FS_TYPE_VFAT,
399                              FILE_DEVICE_DISK_FILE_SYSTEM,
400                              0);
401     if (NT_SUCCESS(Status)) DeviceCount++;
402 
403     /* Register NTFS */
404     Status = FsRecRegisterFs(DriverObject,
405                              NULL,
406                              NULL,
407                              L"\\Ntfs",
408                              L"\\FileSystem\\NtfsRecognizer",
409                              FS_TYPE_NTFS,
410                              FILE_DEVICE_DISK_FILE_SYSTEM,
411                              0);
412     if (NT_SUCCESS(Status)) DeviceCount++;
413 
414     /* Register EXT2 */
415     Status = FsRecRegisterFs(DriverObject,
416                              NULL,
417                              NULL,
418                              L"\\Ext2fs",
419                              L"\\FileSystem\\Ext2Recognizer",
420                              FS_TYPE_EXT2,
421                              FILE_DEVICE_DISK_FILE_SYSTEM,
422                              0);
423     if (NT_SUCCESS(Status)) DeviceCount++;
424 
425     /* Register BTRFS */
426     Status = FsRecRegisterFs(DriverObject,
427                              NULL,
428                              NULL,
429                              L"\\Btrfs",
430                              L"\\FileSystem\\BtrfsRecognizer",
431                              FS_TYPE_BTRFS,
432                              FILE_DEVICE_DISK_FILE_SYSTEM,
433                              0);
434     if (NT_SUCCESS(Status)) DeviceCount++;
435 
436     /* Register REISERFS */
437     Status = FsRecRegisterFs(DriverObject,
438                              NULL,
439                              NULL,
440                              L"\\Reiserfs",
441                              L"\\FileSystem\\ReiserfsRecognizer",
442                              FS_TYPE_REISERFS,
443                              FILE_DEVICE_DISK_FILE_SYSTEM,
444                              0);
445     if (NT_SUCCESS(Status)) DeviceCount++;
446 
447     /* Register FFS */
448     Status = FsRecRegisterFs(DriverObject,
449                              NULL,
450                              NULL,
451                              L"\\ffs",
452                              L"\\FileSystem\\FfsRecognizer",
453                              FS_TYPE_FFS,
454                              FILE_DEVICE_DISK_FILE_SYSTEM,
455                              0);
456     if (NT_SUCCESS(Status)) DeviceCount++;
457 
458     /* Return appropriate Status */
459     return (DeviceCount > 0) ? STATUS_SUCCESS : STATUS_IMAGE_ALREADY_LOADED;
460 }
461 
462 /* EOF */
463