--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS VFAT filesystem library
+ * FILE: fat16.c
+ * PURPOSE: Fat16 support
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * Eric Kohl (ekohl@rz-online.de)
+ * REVISIONS:
+ * EK 05/04-2003 Created
+ */
+#define NDEBUG
+#include <debug.h>
+#define NTOS_MODE_USER
+#include <ntos.h>
+#include <ddk/ntddscsi.h>
+#include <mem.h>
+#include "vfatlib.h"
+
+
+static ULONG
+GetShiftCount(ULONG Value)
+{
+ ULONG i = 1;
+ while (Value > 0)
+ {
+ i++;
+ Value /= 2;
+ }
+ return i - 2;
+}
+
+
+static ULONG
+CalcVolumeSerialNumber(VOID)
+{
+ LARGE_INTEGER SystemTime;
+ TIME_FIELDS TimeFields;
+ ULONG Serial;
+ PUCHAR Buffer;
+
+ NtQuerySystemTime (&SystemTime);
+ RtlTimeToTimeFields (&SystemTime, &TimeFields);
+
+ Buffer = (PUCHAR)&Serial;
+ Buffer[0] = (UCHAR)(TimeFields.Year & 0xFF) + (UCHAR)(TimeFields.Hour & 0xFF);
+ Buffer[1] = (UCHAR)(TimeFields.Year >> 8) + (UCHAR)(TimeFields.Minute & 0xFF);
+ Buffer[2] = (UCHAR)(TimeFields.Month & 0xFF) + (UCHAR)(TimeFields.Second & 0xFF);
+ Buffer[3] = (UCHAR)(TimeFields.Day & 0xFF) + (UCHAR)(TimeFields.Milliseconds & 0xFF);
+
+ return Serial;
+}
+
+
+static NTSTATUS
+Fat16WriteBootSector(IN HANDLE FileHandle,
+ IN PFAT16_BOOT_SECTOR BootSector)
+{
+ IO_STATUS_BLOCK IoStatusBlock;
+ NTSTATUS Status;
+ PUCHAR NewBootSector;
+ LARGE_INTEGER FileOffset;
+
+ /* Allocate buffer for new bootsector */
+ NewBootSector = (PUCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ SECTORSIZE);
+ if (NewBootSector == NULL)
+ return(STATUS_INSUFFICIENT_RESOURCES);
+
+ /* Zero the new bootsector */
+ memset(NewBootSector, 0, SECTORSIZE);
+
+ /* Copy FAT16 BPB to new bootsector */
+ memcpy((NewBootSector + 3),
+ &BootSector->OEMName[0],
+ 59); /* FAT16 BPB length (up to (not including) Res2) */
+
+ /* Write sector 0 */
+ FileOffset.QuadPart = 0ULL;
+ Status = NtWriteFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &IoStatusBlock,
+ NewBootSector,
+ SECTORSIZE,
+ &FileOffset,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, NewBootSector);
+ return(Status);
+ }
+
+ /* Free the new boot sector */
+ RtlFreeHeap(RtlGetProcessHeap(), 0, NewBootSector);
+
+ return(Status);
+}
+
+
+static NTSTATUS
+Fat16WriteFAT(IN HANDLE FileHandle,
+ ULONG SectorOffset,
+ IN PFAT16_BOOT_SECTOR BootSector)
+{
+ IO_STATUS_BLOCK IoStatusBlock;
+ NTSTATUS Status;
+ PUCHAR Buffer;
+ LARGE_INTEGER FileOffset;
+ ULONG i;
+ ULONG Size;
+ ULONG Sectors;
+
+ /* Allocate buffer */
+ Buffer = (PUCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ 32 * 1024);
+ if (Buffer == NULL)
+ return(STATUS_INSUFFICIENT_RESOURCES);
+
+ /* Zero the buffer */
+ memset(Buffer, 0, 32 * 1024);
+
+ /* FAT cluster 0 */
+ Buffer[0] = 0xf8; /* Media type */
+ Buffer[1] = 0xff;
+
+ /* FAT cluster 1 */
+ Buffer[2] = 0xff; /* Clean shutdown, no disk read/write errors, end-of-cluster (EOC) mark */
+ Buffer[3] = 0xff;
+
+ /* Write first sector of the FAT */
+ FileOffset.QuadPart = (SectorOffset + BootSector->ReservedSectors) * BootSector->BytesPerSector;
+ Status = NtWriteFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &IoStatusBlock,
+ Buffer,
+ BootSector->BytesPerSector,
+ &FileOffset,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+ return(Status);
+ }
+
+ /* Zero the begin of the buffer */
+ memset(Buffer, 0, 4);
+
+ /* Zero the rest of the FAT */
+ Sectors = 32 * 1024 / BootSector->BytesPerSector;
+ for (i = 1; i < (ULONG)BootSector->FATSectors; i += Sectors)
+ {
+ /* Zero some sectors of the FAT */
+ FileOffset.QuadPart = (SectorOffset + BootSector->ReservedSectors + i) * BootSector->BytesPerSector;
+ Size = (ULONG)BootSector->FATSectors - i;
+ if (Size > Sectors)
+ {
+ Size = Sectors;
+ }
+ Size *= BootSector->BytesPerSector;
+ Status = NtWriteFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &IoStatusBlock,
+ Buffer,
+ Size,
+ &FileOffset,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+ return(Status);
+ }
+ }
+
+ /* Free the buffer */
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+
+ return(Status);
+}
+
+
+static NTSTATUS
+Fat16WriteRootDirectory(IN HANDLE FileHandle,
+ IN PFAT16_BOOT_SECTOR BootSector)
+{
+ IO_STATUS_BLOCK IoStatusBlock;
+ NTSTATUS Status;
+ PUCHAR Buffer;
+ LARGE_INTEGER FileOffset;
+ ULONG FirstRootDirSector;
+ ULONG RootDirSectors;
+ ULONG Sectors;
+ ULONG Size;
+ ULONG i;
+
+ DPRINT("BootSector->ReservedSectors = %hu\n", BootSector->ReservedSectors);
+ DPRINT("BootSector->FATSectors = %hu\n", BootSector->FATSectors);
+ DPRINT("BootSector->SectorsPerCluster = %u\n", BootSector->SectorsPerCluster);
+
+ /* Write cluster */
+ RootDirSectors = ((BootSector->RootEntries * 32) +
+ (BootSector->BytesPerSector - 1)) / BootSector->BytesPerSector;
+ FirstRootDirSector =
+ BootSector->ReservedSectors + (BootSector->FATCount * BootSector->FATSectors);
+
+ DPRINT("RootDirSectors = %lu\n", RootDirSectors);
+ DPRINT("FirstRootDirSector = %lu\n", FirstRootDirSector);
+
+ /* Allocate buffer for the cluster */
+ Buffer = (PUCHAR)RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ 32 * 1024);
+ if (Buffer == NULL)
+ return(STATUS_INSUFFICIENT_RESOURCES);
+
+ /* Zero the buffer */
+ memset(Buffer, 0, 32 * 1024);
+
+ Sectors = 32 * 1024 / BootSector->BytesPerSector;
+ for (i = 1; i < RootDirSectors; i += Sectors)
+ {
+ /* Zero some sectors of the root directory */
+ FileOffset.QuadPart = (FirstRootDirSector + i) * BootSector->BytesPerSector;
+ Size = RootDirSectors - i;
+ if (Size > Sectors)
+ {
+ Size = Sectors;
+ }
+ Size *= BootSector->BytesPerSector;
+
+ Status = NtWriteFile(FileHandle,
+ NULL,
+ NULL,
+ NULL,
+ &IoStatusBlock,
+ Buffer,
+ Size,
+ &FileOffset,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+ return(Status);
+ }
+ }
+
+ /* Free the buffer */
+ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+
+ return(Status);
+}
+
+
+NTSTATUS
+Fat16Format (HANDLE FileHandle,
+ PPARTITION_INFORMATION PartitionInfo,
+ PDISK_GEOMETRY DiskGeometry,
+ PUNICODE_STRING Label,
+ BOOL QuickFormat,
+ DWORD ClusterSize,
+ PFMIFSCALLBACK Callback)
+{
+ FAT16_BOOT_SECTOR BootSector;
+ OEM_STRING VolumeLabel;
+ ULONG SectorCount;
+ ULONG RootDirSectors;
+ ULONG TmpVal1;
+ ULONG TmpVal2;
+ ULONG TmpVal3;
+ NTSTATUS Status;
+
+ /* Calculate cluster size */
+ if (ClusterSize == 0)
+ {
+ if (PartitionInfo->PartitionLength.QuadPart < 16ULL * 1024ULL * 1024ULL)
+ {
+ /* Partition < 16MB ==> 1KB Cluster */
+ ClusterSize = 1024;
+ }
+ else if (PartitionInfo->PartitionLength.QuadPart < 128ULL * 1024ULL * 1024ULL)
+ {
+ /* Partition < 128MB ==> 2KB Cluster */
+ ClusterSize = 2048;
+ }
+ else if (PartitionInfo->PartitionLength.QuadPart < 256ULL * 1024ULL * 1024ULL)
+ {
+ /* Partition < 256MB ==> 4KB Cluster */
+ ClusterSize = 4096;
+ }
+ else
+ {
+ /* Partition >= 256MB (< 512MB) ==> 8KB Cluster */
+ ClusterSize = 8192;
+ }
+ }
+
+ SectorCount = PartitionInfo->PartitionLength.QuadPart >>
+ GetShiftCount(DiskGeometry->BytesPerSector); /* Use shifting to avoid 64-bit division */
+
+ memset(&BootSector, 0, sizeof(FAT16_BOOT_SECTOR));
+ memcpy(&BootSector.OEMName[0], "MSWIN4.1", 8);
+ BootSector.BytesPerSector = DiskGeometry->BytesPerSector;
+ BootSector.SectorsPerCluster = ClusterSize / BootSector.BytesPerSector;
+ BootSector.ReservedSectors = 1;
+ BootSector.FATCount = 2;
+ BootSector.RootEntries = 512;
+ BootSector.Sectors = (SectorCount < 0x10000) ? (unsigned short)SectorCount : 0;
+ BootSector.Media = 0xf8;
+ BootSector.FATSectors = 0; /* Set later. See below. */
+ BootSector.SectorsPerTrack = DiskGeometry->SectorsPerTrack;
+ BootSector.Heads = DiskGeometry->TracksPerCylinder;
+ BootSector.HiddenSectors = PartitionInfo->HiddenSectors;
+ BootSector.SectorsHuge = (SectorCount >= 0x10000) ? (unsigned long)SectorCount : 0;
+ BootSector.Drive = 0xff; /* No BIOS boot drive available */
+ BootSector.ExtBootSignature = 0x29;
+ BootSector.VolumeID = CalcVolumeSerialNumber();
+ if ((Label == NULL) || (Label->Buffer == NULL))
+ {
+ memcpy(&BootSector.VolumeLabel[0], "NO NAME ", 11);
+ }
+ else
+ {
+ RtlUnicodeStringToOemString(&VolumeLabel, Label, TRUE);
+ memset(&BootSector.VolumeLabel[0], ' ', 11);
+ memcpy(&BootSector.VolumeLabel[0], VolumeLabel.Buffer,
+ VolumeLabel.Length < 11 ? VolumeLabel.Length : 11);
+ RtlFreeOemString(&VolumeLabel);
+ }
+ memcpy(&BootSector.SysType[0], "FAT16 ", 8);
+
+ DPRINT("BootSector.SectorsHuge = %lx\n", BootSector.SectorsHuge);
+
+ RootDirSectors = ((BootSector.RootEntries * 32) +
+ (BootSector.BytesPerSector - 1)) / BootSector.BytesPerSector;
+
+ /* Calculate number of FAT sectors */
+ /* (BootSector.BytesPerSector / 2) FAT entries (16bit) fit into one sector */
+ TmpVal1 = SectorCount - (BootSector.ReservedSectors + RootDirSectors);
+ TmpVal2 = ((BootSector.BytesPerSector / 2) * BootSector.SectorsPerCluster) + BootSector.FATCount;
+ TmpVal3 = (TmpVal1 + (TmpVal2 - 1)) / TmpVal2;
+ BootSector.FATSectors = (unsigned short)(TmpVal3 & 0xffff);
+ DPRINT("BootSector.FATSectors = %hu\n", BootSector.FATSectors);
+
+ Status = Fat16WriteBootSector(FileHandle,
+ &BootSector);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Fat16WriteBootSector() failed with status 0x%.08x\n", Status);
+ return Status;
+ }
+
+ /* Write first FAT copy */
+ Status = Fat16WriteFAT(FileHandle,
+ 0,
+ &BootSector);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Fat16WriteFAT() failed with status 0x%.08x\n", Status);
+ return Status;
+ }
+
+ /* Write second FAT copy */
+ Status = Fat16WriteFAT(FileHandle,
+ (ULONG)BootSector.FATSectors,
+ &BootSector);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Fat16WriteFAT() failed with status 0x%.08x.\n", Status);
+ return Status;
+ }
+
+ Status = Fat16WriteRootDirectory(FileHandle,
+ &BootSector);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Fat16WriteRootDirectory() failed with status 0x%.08x\n", Status);
+ }
+
+ return Status;
+}
git://git.jankratochvil.net / reactos.git / blobdiff