reactos/drivers/filesystems/fs_rec/fs_rec.h

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS File System Recognizer
   4  * FILE:             drivers/filesystems/fs_rec/fs_rec.h
   5  * PURPOSE:          Main Header File
   6  * PROGRAMMER:       Alex Ionescu (alex.ionescu@reactos.org)
   7  *                   Eric Kohl
   8  */
   9
  10 //
  11 // IFS Headers
  12 //
  13 #include <ntifs.h>
  14 #include <ntdddisk.h>
  15 #include <ntddcdrm.h>
  16
  17 //
  18 // Tag for memory allocations
  19 //
  20 #define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
  21 #define FSREC_TAG TAG('F', 's', 'R', 'c')
  22
  23 //
  24 // UDFS Offsets
  25 //
  26 #define UDFS_VRS_START_OFFSET  32768
  27 #define UDFS_AVDP_SECTOR       256
  28
  29 //
  30 // Non-standard rounding macros
  31 //
  32 #define ROUND_UP(n, align) \
  33     ROUND_DOWN(((ULONG)n) + (align) - 1, (align))
  34
  35 #define ROUND_DOWN(n, align) \
  36     (((ULONG)n) & ~((align) - 1l))
  37
  38 //
  39 // Conversion types and macros taken from internal ntifs headers
  40 //
  41 typedef union _UCHAR1
  42 {
  43     UCHAR Uchar[1];
  44     UCHAR ForceAlignment;
  45 } UCHAR1, *PUCHAR1;
  46
  47 typedef union _UCHAR2
  48 {
  49     UCHAR Uchar[2];
  50     USHORT ForceAlignment;
  51 } UCHAR2, *PUCHAR2;
  52
  53 typedef union _UCHAR4
  54 {
  55     UCHAR Uchar[4];
  56     ULONG ForceAlignment;
  57 } UCHAR4, *PUCHAR4;
  58
  59 #define CopyUchar1(Dst,Src) {                                \
  60     *((UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src)); \
  61 }
  62
  63 #define CopyUchar2(Dst,Src) {                                \
  64     *((UCHAR2 *)(Dst)) = *((UNALIGNED UCHAR2 *)(Src)); \
  65 }
  66
  67 #define CopyUchar4(Dst,Src) {                                \
  68     *((UCHAR4 *)(Dst)) = *((UNALIGNED UCHAR4 *)(Src)); \
  69 }
  70
  71 #define FatUnpackBios(Bios,Pbios) {                                         \
  72     CopyUchar2(&(Bios)->BytesPerSector,    &(Pbios)->BytesPerSector[0]   ); \
  73     CopyUchar1(&(Bios)->SectorsPerCluster, &(Pbios)->SectorsPerCluster[0]); \
  74     CopyUchar2(&(Bios)->ReservedSectors,   &(Pbios)->ReservedSectors[0]  ); \
  75     CopyUchar1(&(Bios)->Fats,              &(Pbios)->Fats[0]             ); \
  76     CopyUchar2(&(Bios)->RootEntries,       &(Pbios)->RootEntries[0]      ); \
  77     CopyUchar2(&(Bios)->Sectors,           &(Pbios)->Sectors[0]          ); \
  78     CopyUchar1(&(Bios)->Media,             &(Pbios)->Media[0]            ); \
  79     CopyUchar2(&(Bios)->SectorsPerFat,     &(Pbios)->SectorsPerFat[0]    ); \
  80     CopyUchar2(&(Bios)->SectorsPerTrack,   &(Pbios)->SectorsPerTrack[0]  ); \
  81     CopyUchar2(&(Bios)->Heads,             &(Pbios)->Heads[0]            ); \
  82     CopyUchar4(&(Bios)->HiddenSectors,     &(Pbios)->HiddenSectors[0]    ); \
  83     CopyUchar4(&(Bios)->LargeSectors,      &(Pbios)->LargeSectors[0]     ); \
  84 }
  85
  86 //
  87 // Packed versions of the BPB and Boot Sector
  88 //
  89 typedef struct _PACKED_BIOS_PARAMETER_BLOCK
  90 {
  91     UCHAR BytesPerSector[2];
  92     UCHAR SectorsPerCluster[1];
  93     UCHAR ReservedSectors[2];
  94     UCHAR Fats[1];
  95     UCHAR RootEntries[2];
  96     UCHAR Sectors[2];
  97     UCHAR Media[1];
  98     UCHAR SectorsPerFat[2];
  99     UCHAR SectorsPerTrack[2];
 100     UCHAR Heads[2];
 101     UCHAR HiddenSectors[4];
 102     UCHAR LargeSectors[4];
 103 } PACKED_BIOS_PARAMETER_BLOCK, *PPACKED_BIOS_PARAMETER_BLOCK;
 104
 105 typedef struct _PACKED_BOOT_SECTOR
 106 {
 107     UCHAR Jump[3];
 108     UCHAR Oem[8];
 109     PACKED_BIOS_PARAMETER_BLOCK PackedBpb;
 110     UCHAR PhysicalDriveNumber;
 111     UCHAR CurrentHead;
 112     UCHAR Signature;
 113     UCHAR Id[4];
 114     UCHAR VolumeLabel[11];
 115     UCHAR SystemId[8];
 116 } PACKED_BOOT_SECTOR, *PPACKED_BOOT_SECTOR;
 117
 118 //
 119 // Unpacked version of the BPB
 120 //
 121 typedef struct BIOS_PARAMETER_BLOCK
 122 {
 123     USHORT BytesPerSector;
 124     UCHAR SectorsPerCluster;
 125     USHORT ReservedSectors;
 126     UCHAR Fats;
 127     USHORT RootEntries;
 128     USHORT Sectors;
 129     UCHAR Media;
 130     USHORT SectorsPerFat;
 131     USHORT SectorsPerTrack;
 132     USHORT Heads;
 133     ULONG32 HiddenSectors;
 134     ULONG32 LargeSectors;
 135     ULONG32 LargeSectorsPerFat;
 136     union
 137     {
 138         USHORT ExtendedFlags;
 139         struct
 140         {
 141             ULONG ActiveFat:4;
 142             ULONG Reserved0:3;
 143             ULONG MirrorDisabled:1;
 144             ULONG Reserved1:8;
 145         };
 146     };
 147     USHORT FsVersion;
 148     ULONG32 RootDirFirstCluster;
 149     USHORT FsInfoSector;
 150     USHORT BackupBootSector;
 151 } BIOS_PARAMETER_BLOCK, *PBIOS_PARAMETER_BLOCK;
 152
 153 //
 154 // UDFS Structures
 155 //
 156 #include <pshpack1.h>
 157 typedef struct _TAG
 158 {
 159     USHORT Identifier;
 160     USHORT Version;
 161     UCHAR  Checksum;
 162     UCHAR  Reserved;
 163     USHORT SerialNumber;
 164     USHORT Crc;
 165     USHORT CrcLength;
 166     ULONG  Location;
 167 } TAG, *PTAG;
 168
 169 typedef struct _EXTENT
 170 {
 171     ULONG Length;
 172     ULONG Location;
 173 } EXTENT, *PEXTENT;
 174
 175 typedef struct _AVDP
 176 {
 177     TAG DescriptorTag;
 178     EXTENT MainVolumeDescriptorExtent;
 179     EXTENT ReserveVolumeDescriptorExtent;
 180 } AVDP, *PAVDP;
 181 #include <poppack.h>
 182
 183 //
 184 // Filesystem Types
 185 //
 186 typedef enum _FILE_SYSTEM_TYPE
 187 {
 188     FS_TYPE_UNUSED,
 189     FS_TYPE_VFAT,
 190     FS_TYPE_NTFS,
 191     FS_TYPE_CDFS,
 192     FS_TYPE_UDFS,
 193     FS_TYPE_EXT2,
 194 } FILE_SYSTEM_TYPE, *PFILE_SYSTEM_TYPE;
 195
 196 //
 197 // FS Recognizer State
 198 //
 199 typedef enum _FS_REC_STATE
 200 {
 201     Pending,
 202     Loaded,
 203     Unloading
 204 } FS_REC_STATE, *PFS_REC_STATE;
 205
 206 //
 207 // Device extension
 208 //
 209 typedef struct _DEVICE_EXTENSION
 210 {
 211     FS_REC_STATE State;
 212     FILE_SYSTEM_TYPE FsType;
 213     PDEVICE_OBJECT Alternate;
 214 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
 215
 216 //
 217 // Prototypes
 218 //
 219 NTSTATUS
 220 NTAPI
 221 FsRecCdfsFsControl(
 222     IN PDEVICE_OBJECT DeviceObject,
 223     IN PIRP Irp
 224 );
 225
 226 NTSTATUS
 227 NTAPI
 228 FsRecVfatFsControl(
 229     IN PDEVICE_OBJECT DeviceObject,
 230     IN PIRP Irp
 231 );
 232
 233 NTSTATUS
 234 NTAPI
 235 FsRecNtfsFsControl(
 236     IN PDEVICE_OBJECT DeviceObject,
 237     IN PIRP Irp
 238 );
 239
 240 NTSTATUS
 241 NTAPI
 242 FsRecUdfsFsControl(
 243     IN PDEVICE_OBJECT DeviceObject,
 244     IN PIRP Irp
 245 );
 246
 247 NTSTATUS
 248 NTAPI
 249 FsRecExt2FsControl(
 250     IN PDEVICE_OBJECT DeviceObject,
 251     IN PIRP Irp
 252 );
 253
 254 BOOLEAN
 255 NTAPI
 256 FsRecGetDeviceSectors(
 257     IN PDEVICE_OBJECT DeviceObject,
 258     IN ULONG SectorSize,
 259     OUT PLARGE_INTEGER SectorCount
 260 );
 261
 262 BOOLEAN
 263 NTAPI
 264 FsRecGetDeviceSectorSize(
 265     IN PDEVICE_OBJECT DeviceObject,
 266     OUT PULONG SectorSize
 267 );
 268
 269 BOOLEAN
 270 NTAPI
 271 FsRecReadBlock(
 272     IN PDEVICE_OBJECT DeviceObject,
 273     IN PLARGE_INTEGER Offset,
 274     IN ULONG Length,
 275     IN ULONG SectorSize,
 276     IN OUT PVOID *Buffer,
 277     OUT PBOOLEAN DeviceError OPTIONAL
 278 );
 279
 280 NTSTATUS
 281 NTAPI
 282 FsRecLoadFileSystem(
 283     IN PDEVICE_OBJECT DeviceObject,
 284     IN PWCHAR DriverServiceName
 285 );