ReactOS 0.4.16-dev-550-g2186ce3
fat32.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS VFAT filesystem library
4 * FILE: fat32.c
5 * PURPOSE: Fat32 support
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Eric Kohl
8 */
9
10/* INCLUDES *******************************************************************/
11
12#include "vfatlib.h"
13
14#define NDEBUG
15#include <debug.h>
16
17
18/* FUNCTIONS ******************************************************************/
19
20static NTSTATUS
21Fat32WriteBootSector(IN HANDLE FileHandle,
22 IN PFAT32_BOOT_SECTOR BootSector,
23 IN OUT PFORMAT_CONTEXT Context)
24{
25 IO_STATUS_BLOCK IoStatusBlock;
26 NTSTATUS Status;
27 PFAT32_BOOT_SECTOR NewBootSector;
28 LARGE_INTEGER FileOffset;
29
30 /* Allocate buffer for new bootsector */
31 NewBootSector = (PFAT32_BOOT_SECTOR)RtlAllocateHeap(RtlGetProcessHeap(),
32 0,
33 BootSector->BytesPerSector);
34 if (NewBootSector == NULL)
35 return STATUS_INSUFFICIENT_RESOURCES;
36
37 /* Zero the new bootsector */
38 RtlZeroMemory(NewBootSector, BootSector->BytesPerSector);
39
40 /* Copy FAT32 BPB to new bootsector */
41 memcpy(NewBootSector, BootSector,
42 FIELD_OFFSET(FAT32_BOOT_SECTOR, Res2) - FIELD_OFFSET(FAT32_BOOT_SECTOR, Jump));
43 /* FAT32 BPB length (up to (not including) Res2) */
44
45 /* Write the boot sector signature */
46 NewBootSector->Signature1 = 0xAA550000;
47
48 /* Write sector 0 */
49 FileOffset.QuadPart = 0ULL;
50 Status = NtWriteFile(FileHandle,
51 NULL,
52 NULL,
53 NULL,
54 &IoStatusBlock,
55 NewBootSector,
56 BootSector->BytesPerSector,
57 &FileOffset,
58 NULL);
59 if (!NT_SUCCESS(Status))
60 {
61 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
62 goto done;
63 }
64
65 UpdateProgress(Context, 1);
66
67 /* Write backup boot sector */
68 if (BootSector->BootBackup != 0x0000)
69 {
70 FileOffset.QuadPart = (ULONGLONG)((ULONG)BootSector->BootBackup * BootSector->BytesPerSector);
71 Status = NtWriteFile(FileHandle,
72 NULL,
73 NULL,
74 NULL,
75 &IoStatusBlock,
76 NewBootSector,
77 BootSector->BytesPerSector,
78 &FileOffset,
79 NULL);
80 if (!NT_SUCCESS(Status))
81 {
82 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
83 goto done;
84 }
85
86 UpdateProgress(Context, 1);
87 }
88
89done:
90 /* Free the buffer */
91 RtlFreeHeap(RtlGetProcessHeap(), 0, NewBootSector);
92 return Status;
93}
94
95
96static NTSTATUS
97Fat32WriteFsInfo(IN HANDLE FileHandle,
98 IN PFAT32_BOOT_SECTOR BootSector,
99 IN OUT PFORMAT_CONTEXT Context)
100{
101 IO_STATUS_BLOCK IoStatusBlock;
102 NTSTATUS Status;
103 PFAT32_FSINFO FsInfo;
104 LARGE_INTEGER FileOffset;
105 ULONGLONG FirstDataSector;
106
107 /* Allocate buffer for new sector */
108 FsInfo = (PFAT32_FSINFO)RtlAllocateHeap(RtlGetProcessHeap(),
109 0,
110 BootSector->BytesPerSector);
111 if (FsInfo == NULL)
112 return STATUS_INSUFFICIENT_RESOURCES;
113
114 /* Zero the first FsInfo sector */
115 RtlZeroMemory(FsInfo, BootSector->BytesPerSector);
116
117 FirstDataSector = BootSector->ReservedSectors +
118 (BootSector->FATCount * BootSector->FATSectors32) + 0 /* RootDirSectors */;
119
120 FsInfo->LeadSig = FSINFO_SECTOR_BEGIN_SIGNATURE;
121 FsInfo->StrucSig = FSINFO_SIGNATURE;
122 FsInfo->FreeCount = (BootSector->SectorsHuge - FirstDataSector) / BootSector->SectorsPerCluster - 1;
123 FsInfo->NextFree = 0xffffffff;
124 FsInfo->TrailSig = FSINFO_SECTOR_END_SIGNATURE;
125
126 /* Write the first FsInfo sector */
127 FileOffset.QuadPart = BootSector->FSInfoSector * BootSector->BytesPerSector;
128 Status = NtWriteFile(FileHandle,
129 NULL,
130 NULL,
131 NULL,
132 &IoStatusBlock,
133 FsInfo,
134 BootSector->BytesPerSector,
135 &FileOffset,
136 NULL);
137 if (!NT_SUCCESS(Status))
138 {
139 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
140 goto done;
141 }
142
143 UpdateProgress(Context, 1);
144
145 /* Write backup of the first FsInfo sector */
146 if (BootSector->BootBackup != 0x0000)
147 {
148 /* Reset the free cluster count for the backup */
149 FsInfo->FreeCount = 0xffffffff;
150
151 FileOffset.QuadPart = (ULONGLONG)(((ULONG)BootSector->BootBackup + (ULONG)BootSector->FSInfoSector) * BootSector->BytesPerSector);
152 Status = NtWriteFile(FileHandle,
153 NULL,
154 NULL,
155 NULL,
156 &IoStatusBlock,
157 FsInfo,
158 BootSector->BytesPerSector,
159 &FileOffset,
160 NULL);
161 if (!NT_SUCCESS(Status))
162 {
163 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
164 goto done;
165 }
166
167 UpdateProgress(Context, 1);
168 }
169
170 /* Zero the second FsInfo sector */
171 RtlZeroMemory(FsInfo, BootSector->BytesPerSector);
172 FsInfo->TrailSig = FSINFO_SECTOR_END_SIGNATURE;
173
174 /* Write the second FsInfo sector */
175 FileOffset.QuadPart = (BootSector->FSInfoSector + 1) * BootSector->BytesPerSector;
176 Status = NtWriteFile(FileHandle,
177 NULL,
178 NULL,
179 NULL,
180 &IoStatusBlock,
181 FsInfo,
182 BootSector->BytesPerSector,
183 &FileOffset,
184 NULL);
185 if (!NT_SUCCESS(Status))
186 {
187 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
188 goto done;
189 }
190
191 UpdateProgress(Context, 1);
192
193 /* Write backup of the second FsInfo sector */
194 if (BootSector->BootBackup != 0x0000)
195 {
196 FileOffset.QuadPart = (ULONGLONG)(((ULONG)BootSector->BootBackup + (ULONG)BootSector->FSInfoSector + 1) * BootSector->BytesPerSector);
197 Status = NtWriteFile(FileHandle,
198 NULL,
199 NULL,
200 NULL,
201 &IoStatusBlock,
202 FsInfo,
203 BootSector->BytesPerSector,
204 &FileOffset,
205 NULL);
206 if (!NT_SUCCESS(Status))
207 {
208 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
209 goto done;
210 }
211
212 UpdateProgress(Context, 1);
213 }
214
215done:
216 /* Free the buffer */
217 RtlFreeHeap(RtlGetProcessHeap(), 0, FsInfo);
218 return Status;
219}
220
221
222static NTSTATUS
223Fat32WriteFAT(IN HANDLE FileHandle,
224 IN ULONG SectorOffset,
225 IN PFAT32_BOOT_SECTOR BootSector,
226 IN OUT PFORMAT_CONTEXT Context)
227{
228 IO_STATUS_BLOCK IoStatusBlock;
229 NTSTATUS Status;
230 PUCHAR Buffer;
231 LARGE_INTEGER FileOffset;
232 ULONG i;
233 ULONG Sectors;
234
235 /* Allocate buffer */
236 Buffer = (PUCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
237 0,
238 64 * 1024);
239 if (Buffer == NULL)
240 return STATUS_INSUFFICIENT_RESOURCES;
241
242 /* Zero the buffer */
243 RtlZeroMemory(Buffer, 64 * 1024);
244
245 /* FAT cluster 0 */
246 Buffer[0] = 0xf8; /* Media type */
247 Buffer[1] = 0xff;
248 Buffer[2] = 0xff;
249 Buffer[3] = 0x0f;
250
251 /* FAT cluster 1 */
252 Buffer[4] = 0xff; /* Clean shutdown, no disk read/write errors, end-of-cluster (EOC) mark */
253 Buffer[5] = 0xff;
254 Buffer[6] = 0xff;
255 Buffer[7] = 0x0f;
256
257 /* FAT cluster 2 */
258 Buffer[8] = 0xff; /* End of root directory */
259 Buffer[9] = 0xff;
260 Buffer[10] = 0xff;
261 Buffer[11] = 0x0f;
262
263 /* Write first sector of the FAT */
264 FileOffset.QuadPart = (SectorOffset + BootSector->ReservedSectors) * BootSector->BytesPerSector;
265 Status = NtWriteFile(FileHandle,
266 NULL,
267 NULL,
268 NULL,
269 &IoStatusBlock,
270 Buffer,
271 BootSector->BytesPerSector,
272 &FileOffset,
273 NULL);
274 if (!NT_SUCCESS(Status))
275 {
276 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
277 goto done;
278 }
279
280 UpdateProgress(Context, 1);
281
282 /* Zero the begin of the buffer */
283 RtlZeroMemory(Buffer, 12);
284
285 /* Zero the rest of the FAT */
286 Sectors = 64 * 1024 / BootSector->BytesPerSector;
287 for (i = 1; i < BootSector->FATSectors32; i += Sectors)
288 {
289 /* Zero some sectors of the FAT */
290 FileOffset.QuadPart = (SectorOffset + BootSector->ReservedSectors + i) * BootSector->BytesPerSector;
291
292 if ((BootSector->FATSectors32 - i) <= Sectors)
293 {
294 Sectors = BootSector->FATSectors32 - i;
295 }
296
297 Status = NtWriteFile(FileHandle,
298 NULL,
299 NULL,
300 NULL,
301 &IoStatusBlock,
302 Buffer,
303 Sectors * BootSector->BytesPerSector,
304 &FileOffset,
305 NULL);
306 if (!NT_SUCCESS(Status))
307 {
308 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
309 goto done;
310 }
311
312 UpdateProgress(Context, Sectors);
313 }
314
315done:
316 /* Free the buffer */
317 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
318 return Status;
319}
320
321
322static NTSTATUS
323Fat32WriteRootDirectory(IN HANDLE FileHandle,
324 IN PFAT32_BOOT_SECTOR BootSector,
325 IN OUT PFORMAT_CONTEXT Context)
326{
327 IO_STATUS_BLOCK IoStatusBlock;
328 NTSTATUS Status;
329 PUCHAR Buffer;
330 LARGE_INTEGER FileOffset;
331 ULONGLONG FirstDataSector;
332 ULONGLONG FirstRootDirSector;
333
334 /* Allocate buffer for the cluster */
335 Buffer = (PUCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
336 0,
337 BootSector->SectorsPerCluster * BootSector->BytesPerSector);
338 if (Buffer == NULL)
339 return STATUS_INSUFFICIENT_RESOURCES;
340
341 /* Zero the buffer */
342 RtlZeroMemory(Buffer, BootSector->SectorsPerCluster * BootSector->BytesPerSector);
343
344 DPRINT("BootSector->ReservedSectors = %lu\n", BootSector->ReservedSectors);
345 DPRINT("BootSector->FATSectors32 = %lu\n", BootSector->FATSectors32);
346 DPRINT("BootSector->RootCluster = %lu\n", BootSector->RootCluster);
347 DPRINT("BootSector->SectorsPerCluster = %lu\n", BootSector->SectorsPerCluster);
348
349 /* Write cluster */
350 FirstDataSector = BootSector->ReservedSectors +
351 (BootSector->FATCount * BootSector->FATSectors32) + 0 /* RootDirSectors */;
352
353 DPRINT("FirstDataSector = %lu\n", FirstDataSector);
354
355 FirstRootDirSector = ((BootSector->RootCluster - 2) * BootSector->SectorsPerCluster) + FirstDataSector;
356 FileOffset.QuadPart = FirstRootDirSector * BootSector->BytesPerSector;
357
358 DPRINT("FirstRootDirSector = %lu\n", FirstRootDirSector);
359 DPRINT("FileOffset = %lu\n", FileOffset.QuadPart);
360
361 Status = NtWriteFile(FileHandle,
362 NULL,
363 NULL,
364 NULL,
365 &IoStatusBlock,
366 Buffer,
367 BootSector->SectorsPerCluster * BootSector->BytesPerSector,
368 &FileOffset,
369 NULL);
370 if (!NT_SUCCESS(Status))
371 {
372 DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
373 goto done;
374 }
375
376 UpdateProgress(Context, (ULONG)BootSector->SectorsPerCluster);
377
378done:
379 /* Free the buffer */
380 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
381 return Status;
382}
383
384
385NTSTATUS
386Fat32Format(IN HANDLE FileHandle,
387 IN PPARTITION_INFORMATION PartitionInfo,
388 IN PDISK_GEOMETRY DiskGeometry,
389 IN PUNICODE_STRING Label,
390 IN BOOLEAN QuickFormat,
391 IN ULONG ClusterSize,
392 IN OUT PFORMAT_CONTEXT Context)
393{
394 FAT32_BOOT_SECTOR BootSector;
395 OEM_STRING VolumeLabel;
396 ULONG TmpVal1;
397 ULONG TmpVal2;
398 NTSTATUS Status;
399 ULONG UsableFatEntries;
400 ULONG FirstDataSector;
401 ULONG DataClusters;
402
403 /* Calculate cluster size */
404 if (ClusterSize == 0)
405 {
406 if (PartitionInfo->PartitionLength.QuadPart < 8LL * 1024LL * 1024LL * 1024LL)
407 {
408 /* Partition < 8GB ==> 4KB Cluster */
409 ClusterSize = 4096;
410 }
411 else if (PartitionInfo->PartitionLength.QuadPart < 16LL * 1024LL * 1024LL * 1024LL)
412 {
413 /* Partition 8GB - 16GB ==> 8KB Cluster */
414 ClusterSize = 8192;
415 }
416 else if (PartitionInfo->PartitionLength.QuadPart < 32LL * 1024LL * 1024LL * 1024LL)
417 {
418 /* Partition 16GB - 32GB ==> 16KB Cluster */
419 ClusterSize = 16384;
420 }
421 else
422 {
423 /* Partition >= 32GB ==> 32KB Cluster */
424 ClusterSize = 32768;
425 }
426 }
427
428 RtlZeroMemory(&BootSector, sizeof(FAT32_BOOT_SECTOR));
429 memcpy(&BootSector.OEMName[0], "MSWIN4.1", 8);
430 /* FIXME: Add dummy bootloader for real */
431 BootSector.Jump[0] = 0xeb;
432 BootSector.Jump[1] = 0x58;
433 BootSector.Jump[2] = 0x90;
434 BootSector.BytesPerSector = DiskGeometry->BytesPerSector;
435 BootSector.SectorsPerCluster = ClusterSize / BootSector.BytesPerSector;
436 BootSector.ReservedSectors = 32;
437 BootSector.FATCount = 2;
438 BootSector.RootEntries = 0;
439 BootSector.Sectors = 0;
440 BootSector.Media = 0xf8;
441 BootSector.FATSectors = 0;
442 BootSector.SectorsPerTrack = DiskGeometry->SectorsPerTrack;
443 BootSector.Heads = DiskGeometry->TracksPerCylinder;
444 BootSector.HiddenSectors = PartitionInfo->HiddenSectors;
445 BootSector.SectorsHuge = PartitionInfo->PartitionLength.QuadPart >>
446 GetShiftCount(BootSector.BytesPerSector); /* Use shifting to avoid 64-bit division */
447 BootSector.FATSectors32 = 0; /* Set later */
448 BootSector.ExtFlag = 0; /* Mirror all FATs */
449 BootSector.FSVersion = 0x0000; /* 0:0 */
450 BootSector.RootCluster = 2;
451 BootSector.FSInfoSector = 1;
452 BootSector.BootBackup = 6;
453 BootSector.Drive = (DiskGeometry->MediaType == FixedMedia) ? 0x80 : 0x00;
454 BootSector.ExtBootSignature = 0x29;
455 BootSector.VolumeID = CalcVolumeSerialNumber();
456 if ((Label == NULL) || (Label->Buffer == NULL))
457 {
458 memcpy(&BootSector.VolumeLabel[0], "NO NAME ", 11);
459 }
460 else
461 {
462 RtlUnicodeStringToOemString(&VolumeLabel, Label, TRUE);
463 RtlFillMemory(&BootSector.VolumeLabel[0], 11, ' ');
464 memcpy(&BootSector.VolumeLabel[0], VolumeLabel.Buffer,
465 VolumeLabel.Length < 11 ? VolumeLabel.Length : 11);
466 RtlFreeOemString(&VolumeLabel);
467 }
468
469 memcpy(&BootSector.SysType[0], "FAT32 ", 8);
470
471 /* Calculate number of FAT sectors */
472 /* (BytesPerSector / 4) FAT entries (32bit) fit into one sector */
473 TmpVal1 = BootSector.SectorsHuge - BootSector.ReservedSectors;
474 TmpVal2 = ((BootSector.BytesPerSector / 4) * BootSector.SectorsPerCluster) + BootSector.FATCount;
475 BootSector.FATSectors32 = (TmpVal1 + (TmpVal2 - 1)) / TmpVal2;
476 DPRINT("FATSectors32 = %lu\n", BootSector.FATSectors32);
477
478 /* edge case: first 2 fat entries are not usable, so the calculation might need a correction */
479 UsableFatEntries = BootSector.FATSectors32 * (BootSector.BytesPerSector / 4) - 2;
480 FirstDataSector = BootSector.ReservedSectors + BootSector.FATCount * BootSector.FATSectors32;
481 DataClusters = (BootSector.SectorsHuge - FirstDataSector) / BootSector.SectorsPerCluster;
482 if (DataClusters > UsableFatEntries)
483 {
484 /* Need more fat entries */
485 BootSector.FATSectors32 += (DataClusters - UsableFatEntries);
486
487 DPRINT("UsableFatEntries = %lu\n", UsableFatEntries);
488 DPRINT("DataClusters = %lu\n", DataClusters);
489 DPRINT("BootSector.FATSectors32 incremented to %lu\n", BootSector.FATSectors32);
490 }
491
492 /* Init context data */
493 Context->TotalSectorCount =
494 2 + (BootSector.FATSectors32 * BootSector.FATCount) + BootSector.SectorsPerCluster;
495
496 if (!QuickFormat)
497 {
498 Context->TotalSectorCount += BootSector.SectorsHuge;
499
500 Status = FatWipeSectors(FileHandle,
501 BootSector.SectorsHuge,
502 (ULONG)BootSector.SectorsPerCluster,
503 (ULONG)BootSector.BytesPerSector,
504 Context);
505 if (!NT_SUCCESS(Status))
506 {
507 DPRINT("FatWipeSectors() failed with status 0x%.08x\n", Status);
508 return Status;
509 }
510 }
511
512 Status = Fat32WriteBootSector(FileHandle,
513 &BootSector,
514 Context);
515 if (!NT_SUCCESS(Status))
516 {
517 DPRINT("Fat32WriteBootSector() failed with status 0x%.08x\n", Status);
518 return Status;
519 }
520
521 Status = Fat32WriteFsInfo(FileHandle,
522 &BootSector,
523 Context);
524 if (!NT_SUCCESS(Status))
525 {
526 DPRINT("Fat32WriteFsInfo() failed with status 0x%.08x\n", Status);
527 return Status;
528 }
529
530 /* Write first FAT copy */
531 Status = Fat32WriteFAT(FileHandle,
532 0,
533 &BootSector,
534 Context);
535 if (!NT_SUCCESS(Status))
536 {
537 DPRINT("Fat32WriteFAT() failed with status 0x%.08x\n", Status);
538 return Status;
539 }
540
541 /* Write second FAT copy */
542 Status = Fat32WriteFAT(FileHandle,
543 BootSector.FATSectors32,
544 &BootSector,
545 Context);
546 if (!NT_SUCCESS(Status))
547 {
548 DPRINT("Fat32WriteFAT() failed with status 0x%.08x.\n", Status);
549 return Status;
550 }
551
552 Status = Fat32WriteRootDirectory(FileHandle,
553 &BootSector,
554 Context);
555 if (!NT_SUCCESS(Status))
556 {
557 DPRINT("Fat32WriteRootDirectory() failed with status 0x%.08x\n", Status);
558 }
559
560 return Status;
561}
562
563/* EOF */
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
QuickFormat
BOOL QuickFormat
Definition: format.c:66
Label
PWCHAR Label
Definition: format.c:70
ClusterSize
DWORD ClusterSize
Definition: format.c:67
RtlAllocateHeap
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:590
RtlFreeHeap
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:608
FileOffset
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
SectorOffset
#define SectorOffset(L)
Definition: cdprocs.h:1622
Buffer
Definition: bufpool.h:45
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
FSINFO_SIGNATURE
#define FSINFO_SIGNATURE
Definition: fat.h:207
FSINFO_SECTOR_BEGIN_SIGNATURE
#define FSINFO_SECTOR_BEGIN_SIGNATURE
Definition: fat.h:204
FSINFO_SECTOR_END_SIGNATURE
#define FSINFO_SECTOR_END_SIGNATURE
Definition: fat.h:205
Fat32Format
NTSTATUS Fat32Format(IN HANDLE FileHandle, IN PPARTITION_INFORMATION PartitionInfo, IN PDISK_GEOMETRY DiskGeometry, IN PUNICODE_STRING Label, IN BOOLEAN QuickFormat, IN ULONG ClusterSize, IN OUT PFORMAT_CONTEXT Context)
Definition: fat32.c:386
Fat32WriteFAT
static NTSTATUS Fat32WriteFAT(IN HANDLE FileHandle, IN ULONG SectorOffset, IN PFAT32_BOOT_SECTOR BootSector, IN OUT PFORMAT_CONTEXT Context)
Definition: fat32.c:223
Fat32WriteFsInfo
static NTSTATUS Fat32WriteFsInfo(IN HANDLE FileHandle, IN PFAT32_BOOT_SECTOR BootSector, IN OUT PFORMAT_CONTEXT Context)
Definition: fat32.c:97
Fat32WriteBootSector
static NTSTATUS Fat32WriteBootSector(IN HANDLE FileHandle, IN PFAT32_BOOT_SECTOR BootSector, IN OUT PFORMAT_CONTEXT Context)
Definition: fat32.c:21
Fat32WriteRootDirectory
static NTSTATUS Fat32WriteRootDirectory(IN HANDLE FileHandle, IN PFAT32_BOOT_SECTOR BootSector, IN OUT PFORMAT_CONTEXT Context)
Definition: fat32.c:323
FileHandle
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
Status
Status
Definition: gdiplustypes.h:25
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
RtlFreeOemString
VOID NTAPI RtlFreeOemString(POEM_STRING OemString)
RtlFillMemory
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:599
PFAT32_BOOT_SECTOR
struct _FAT32_BOOT_SECTOR * PFAT32_BOOT_SECTOR
PFAT32_FSINFO
struct _FAT32_FSINFO * PFAT32_FSINFO
if
if(dx< 0)
Definition: linetemp.h:194
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ULL
#define ULL(a, b)
Definition: format_msg.c:27
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
RtlUnicodeStringToOemString
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToOemString(POEM_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NtWriteFile
NTSYSAPI NTSTATUS NTAPI NtWriteFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN PVOID WriteBuffer, IN ULONG WriteBufferLength, IN PLARGE_INTEGER FileOffset OPTIONAL, IN PULONG LockOperationKey OPTIONAL)
FixedMedia
@ FixedMedia
Definition: ntdddisk.h:383
GetShiftCount
ULONG GetShiftCount(IN ULONG Value)
Definition: common.c:21
FatWipeSectors
NTSTATUS FatWipeSectors(IN HANDLE FileHandle, IN ULONG TotalSectors, IN ULONG SectorsPerCluster, IN ULONG BytesPerSector, IN OUT PFORMAT_CONTEXT Context)
Definition: common.c:56
CalcVolumeSerialNumber
ULONG CalcVolumeSerialNumber(VOID)
Definition: common.c:35
DPRINT
#define DPRINT
Definition: sndvol32.h:73
BootSector::Heads
WORD Heads
Definition: fatfs.h:84
BootSector::RootEntries
WORD RootEntries
Definition: fatfs.h:79
BootSector::HiddenSectors
DWORD HiddenSectors
Definition: fatfs.h:85
BootSector::SectorsPerTrack
WORD SectorsPerTrack
Definition: fatfs.h:83
BootSector::ReservedSectors
WORD ReservedSectors
Definition: fatfs.h:77
BootSector::SectorsPerCluster
BYTE SectorsPerCluster
Definition: fatfs.h:76
BootSector::BytesPerSector
WORD BytesPerSector
Definition: fatfs.h:75
_DISK_GEOMETRY
Definition: ntdddisk.h:399
_FAT32_BOOT_SECTOR
Definition: vfatlib.h:55
_FAT32_BOOT_SECTOR::Signature1
unsigned long Signature1
Definition: vfatlib.h:84
_FAT32_FSINFO
Definition: vfatlib.h:88
_FAT32_FSINFO::StrucSig
unsigned long StrucSig
Definition: vfatlib.h:91
_FAT32_FSINFO::FreeCount
unsigned long FreeCount
Definition: vfatlib.h:92
_FAT32_FSINFO::LeadSig
unsigned long LeadSig
Definition: vfatlib.h:89
_FAT32_FSINFO::NextFree
unsigned long NextFree
Definition: vfatlib.h:93
_FAT32_FSINFO::TrailSig
unsigned long TrailSig
Definition: vfatlib.h:95
_FORMAT_CONTEXT
Definition: vfatlib.h:104
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_PARTITION_INFORMATION
Definition: ntdddisk.h:407
_UNICODE_STRING
Definition: env_spec_w32.h:368
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
IN
#define IN
Definition: typedefs.h:39
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
OUT
#define OUT
Definition: typedefs.h:40
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
OEM_STRING
STRING OEM_STRING
Definition: umtypes.h:203
_LARGE_INTEGER
Definition: typedefs.h:103
UpdateProgress
VOID UpdateProgress(PFORMAT_CONTEXT Context, ULONG Increment)
Definition: vfatlib.c:321
PartitionInfo
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2105