drivers/filesystems/fs_rec/fs_rec.c

   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     NTSTATUS Status = STATUS_IMAGE_ALREADY_LOADED;
  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 */
  36         KeEnterCriticalRegion();
  37         KeWaitForSingleObject(FsRecLoadSync,
  38                               Executive,
  39                               KernelMode,
  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 */
  66             IoUnregisterFileSystem(DeviceObject);
  67             DeviceExtension->State = Loaded;
  68         }
  69
  70         /* Release the lock */
  71         KeSetEvent(FsRecLoadSync, IO_NO_INCREMENT, FALSE);
  72         KeLeaveCriticalRegion();
  73     }
  74
  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         case FS_TYPE_FATX:
 186
 187             /* Send FATX command */
 188             Status = FsRecFatxFsControl(DeviceObject, Irp);
 189             break;
 190
 191         default:
 192
 193             /* Unrecognized FS */
 194             Status = STATUS_INVALID_DEVICE_REQUEST;
 195     }
 196
 197     /* Complete the IRP */
 198     Irp->IoStatus.Status = Status;
 199     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 200     return Status;
 201 }
 202
 203 DRIVER_UNLOAD FsRecUnload;
 204 VOID
 205 NTAPI
 206 FsRecUnload(IN PDRIVER_OBJECT DriverObject)
 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 */
 218     ExFreePool(FsRecLoadSync);
 219 }
 220
 221 NTSTATUS
 222 NTAPI
 223 FsRecRegisterFs(IN PDRIVER_OBJECT DriverObject,
 224                 IN PDEVICE_OBJECT ParentObject OPTIONAL,
 225                 OUT PDEVICE_OBJECT *NewDeviceObject OPTIONAL,
 226                 IN PCWSTR FsName,
 227                 IN PCWSTR RecognizerName,
 228                 IN ULONG FsType,
 229                 IN DEVICE_TYPE DeviceType,
 230                 IN ULONG AdditionalFlags)
 231 {
 232     OBJECT_ATTRIBUTES ObjectAttributes;
 233     IO_STATUS_BLOCK IoStatus;
 234     PDEVICE_EXTENSION DeviceExtension;
 235     UNICODE_STRING DeviceName;
 236     PDEVICE_OBJECT DeviceObject;
 237     HANDLE FileHandle;
 238     NTSTATUS Status;
 239
 240     /* Assume failure */
 241     if (NewDeviceObject) *NewDeviceObject = NULL;
 242
 243     /* Setup the attributes */
 244     RtlInitUnicodeString(&DeviceName, FsName);
 245     InitializeObjectAttributes(&ObjectAttributes,
 246                                &DeviceName,
 247                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 248                                0,
 249                                NULL);
 250
 251     /* Open the device */
 252     Status = ZwCreateFile(&FileHandle,
 253                           SYNCHRONIZE,
 254                           &ObjectAttributes,
 255                           &IoStatus,
 256                           NULL,
 257                           0,
 258                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 259                           FILE_OPEN,
 260                           0,
 261                           NULL,
 262                           0);
 263     if (NT_SUCCESS(Status))
 264     {
 265         /* We succeeded, close the handle */
 266         ZwClose(FileHandle);
 267     }
 268     else if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
 269     {
 270         /* We failed with anything else then what we want to fail with */
 271         Status = STATUS_SUCCESS;
 272     }
 273
 274     /* If we succeeded, there's no point in trying this again */
 275     if (NT_SUCCESS(Status)) return STATUS_IMAGE_ALREADY_LOADED;
 276
 277     /* Create recognizer device object */
 278     RtlInitUnicodeString(&DeviceName, RecognizerName);
 279     Status = IoCreateDevice(DriverObject,
 280                             sizeof(DEVICE_EXTENSION),
 281                             &DeviceName,
 282                             DeviceType,
 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 =
 303                 DeviceObject;
 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 */
 315         IoRegisterFileSystem(DeviceObject);
 316     }
 317
 318     /* Return Status */
 319     return Status;
 320 }
 321
 322 NTSTATUS
 323 NTAPI
 324 DriverEntry(IN PDRIVER_OBJECT DriverObject,
 325             IN PUNICODE_STRING RegistryPath)
 326 {
 327     NTSTATUS Status;
 328     ULONG DeviceCount = 0;
 329     PDEVICE_OBJECT CdfsObject;
 330     PDEVICE_OBJECT UdfsObject;
 331     PDEVICE_OBJECT FatObject;
 332
 333     PAGED_CODE();
 334
 335     UNREFERENCED_PARAMETER(RegistryPath);
 336
 337     /* Page the entire driver */
 338     MmPageEntireDriver(DriverEntry);
 339
 340     /* Allocate the lock */
 341     FsRecLoadSync = ExAllocatePoolWithTag(NonPagedPool,
 342                                           sizeof(KEVENT),
 343                                           FSREC_TAG);
 344     if (!FsRecLoadSync) return STATUS_INSUFFICIENT_RESOURCES;
 345
 346     /* Initialize it */
 347     KeInitializeEvent(FsRecLoadSync, SynchronizationEvent, TRUE);
 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;
 353     DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FsRecFsControl;
 354     DriverObject->DriverUnload = FsRecUnload;
 355
 356     /* Register CDFS for CDs */
 357     Status = FsRecRegisterFs(DriverObject,
 358                              NULL,
 359                              &CdfsObject,
 360                              L"\\Cdfs",
 361                              L"\\FileSystem\\CdfsRecognizer",
 362                              FS_TYPE_CDFS,
 363                              FILE_DEVICE_CD_ROM_FILE_SYSTEM,
 364                              DO_LOW_PRIORITY_FILESYSTEM);
 365     if (NT_SUCCESS(Status)) DeviceCount++;
 366
 367     /* Register CDFS for HDDs */
 368     Status = FsRecRegisterFs(DriverObject,
 369                              CdfsObject,
 370                              NULL,
 371                              L"\\CdfsHdd",
 372                              L"\\FileSystem\\CdfsHddRecognizer",
 373                              FS_TYPE_CDFS,
 374                              FILE_DEVICE_DISK_FILE_SYSTEM,
 375                              DO_LOW_PRIORITY_FILESYSTEM);
 376     if (NT_SUCCESS(Status)) DeviceCount++;
 377
 378     /* Register UDFS for CDs */
 379     Status = FsRecRegisterFs(DriverObject,
 380                              NULL,
 381                              &UdfsObject,
 382                              L"\\UdfsCdRom",
 383                              L"\\FileSystem\\UdfsCdRomRecognizer",
 384                              FS_TYPE_UDFS,
 385                              FILE_DEVICE_CD_ROM_FILE_SYSTEM,
 386                              0);
 387     if (NT_SUCCESS(Status)) DeviceCount++;
 388
 389     /* Register UDFS for HDDs */
 390     Status = FsRecRegisterFs(DriverObject,
 391                              UdfsObject,
 392                              NULL,
 393                              L"\\UdfsDisk",
 394                              L"\\FileSystem\\UdfsDiskRecognizer",
 395                              FS_TYPE_UDFS,
 396                              FILE_DEVICE_DISK_FILE_SYSTEM,
 397                              0);
 398     if (NT_SUCCESS(Status)) DeviceCount++;
 399
 400     /* Register FAT */
 401     Status = FsRecRegisterFs(DriverObject,
 402                              NULL,
 403                              &FatObject,
 404                              L"\\Fat",
 405                              L"\\FileSystem\\FatRecognizer",
 406                              FS_TYPE_VFAT,
 407                              FILE_DEVICE_DISK_FILE_SYSTEM,
 408                              0);
 409     if (NT_SUCCESS(Status)) DeviceCount++;
 410
 411     /* Register FAT for CDs */
 412     Status = FsRecRegisterFs(DriverObject,
 413                              FatObject,
 414                              NULL,
 415                              L"\\FatCdrom",
 416                              L"\\FileSystem\\FatCdRomRecognizer",
 417                              FS_TYPE_VFAT,
 418                              FILE_DEVICE_CD_ROM_FILE_SYSTEM,
 419                              0);
 420     if (NT_SUCCESS(Status)) DeviceCount++;
 421
 422     /* Register NTFS */
 423     Status = FsRecRegisterFs(DriverObject,
 424                              NULL,
 425                              NULL,
 426                              L"\\Ntfs",
 427                              L"\\FileSystem\\NtfsRecognizer",
 428                              FS_TYPE_NTFS,
 429                              FILE_DEVICE_DISK_FILE_SYSTEM,
 430                              0);
 431     if (NT_SUCCESS(Status)) DeviceCount++;
 432
 433     /* Register EXT2 */
 434     Status = FsRecRegisterFs(DriverObject,
 435                              NULL,
 436                              NULL,
 437                              L"\\Ext2fs",
 438                              L"\\FileSystem\\Ext2Recognizer",
 439                              FS_TYPE_EXT2,
 440                              FILE_DEVICE_DISK_FILE_SYSTEM,
 441                              0);
 442     if (NT_SUCCESS(Status)) DeviceCount++;
 443
 444     /* Register BTRFS */
 445     Status = FsRecRegisterFs(DriverObject,
 446                              NULL,
 447                              NULL,
 448                              L"\\Btrfs",
 449                              L"\\FileSystem\\BtrfsRecognizer",
 450                              FS_TYPE_BTRFS,
 451                              FILE_DEVICE_DISK_FILE_SYSTEM,
 452                              0);
 453     if (NT_SUCCESS(Status)) DeviceCount++;
 454
 455     /* Register REISERFS */
 456     Status = FsRecRegisterFs(DriverObject,
 457                              NULL,
 458                              NULL,
 459                              L"\\Reiserfs",
 460                              L"\\FileSystem\\ReiserfsRecognizer",
 461                              FS_TYPE_REISERFS,
 462                              FILE_DEVICE_DISK_FILE_SYSTEM,
 463                              0);
 464     if (NT_SUCCESS(Status)) DeviceCount++;
 465
 466     /* Register FFS */
 467     Status = FsRecRegisterFs(DriverObject,
 468                              NULL,
 469                              NULL,
 470                              L"\\ffs",
 471                              L"\\FileSystem\\FfsRecognizer",
 472                              FS_TYPE_FFS,
 473                              FILE_DEVICE_DISK_FILE_SYSTEM,
 474                              0);
 475     if (NT_SUCCESS(Status)) DeviceCount++;
 476
 477     /* Register FATX */
 478     Status = FsRecRegisterFs(DriverObject,
 479                              NULL,
 480                              NULL,
 481                              L"\\FatX",
 482                              L"\\FileSystem\\FatXRecognizer",
 483                              FS_TYPE_FATX,
 484                              FILE_DEVICE_DISK_FILE_SYSTEM,
 485                              0);
 486     if (NT_SUCCESS(Status)) DeviceCount++;
 487
 488     /* Return appropriate Status */
 489     return (DeviceCount > 0) ? STATUS_SUCCESS : STATUS_IMAGE_ALREADY_LOADED;
 490 }
 491
 492 /* EOF */