Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-03 19:24:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implemented MmAllocateContinuousMemory

Browse source 
VFAT driver cleanups

svn path=/trunk/; revision=1487
This commit is contained in:
David Welch 2000-12-29 23:17:12 +00:00
parent 1f1ae27105
commit ed20b9b6ba
18 changed files with 2841 additions and 2685 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
reactos/drivers/fs/vfat/blockdev.c
View file

@ -18,10 +18,9 @@
/* FUNCTIONS ***************************************************************/ /* FUNCTIONS ***************************************************************/
BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN
IN ULONG DiskSector, VFATReadSectors (IN PDEVICE_OBJECT pDeviceObject,
IN ULONG SectorCount, IN ULONG DiskSector, IN ULONG SectorCount, IN UCHAR * Buffer)
IN UCHAR* Buffer)
{ {
LARGE_INTEGER sectorNumber; LARGE_INTEGER sectorNumber;
PIRP irp; PIRP irp;
@ -38,13 +37,10 @@ BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,
DPRINT ("VFATReadSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n", DPRINT ("VFATReadSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n",
pDeviceObject, pDeviceObject, DiskSector, Buffer);
DiskSector,
Buffer);
DPRINT ("sectorNumber %08lx:%08lx sectorSize %ld\n", DPRINT ("sectorNumber %08lx:%08lx sectorSize %ld\n",
(unsigned long int) sectorNumber.u.LowPart, (unsigned long int) sectorNumber.u.LowPart,
(unsigned long int)sectorNumber.u.HighPart, (unsigned long int) sectorNumber.u.HighPart, sectorSize);
sectorSize);
DPRINT ("Building synchronous FSD Request...\n"); DPRINT ("Building synchronous FSD Request...\n");
@ -52,39 +48,32 @@ BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,
pDeviceObject, pDeviceObject,
Buffer, Buffer,
sectorSize, sectorSize,
&sectorNumber, &sectorNumber, &event, &ioStatus);
&event,
&ioStatus );
if (!irp) { if (!irp)
{
DbgPrint ("READ failed!!!\n"); DbgPrint ("READ failed!!!\n");
return FALSE; return FALSE;
} }
DPRINT ("Calling IO Driver... with irp %x\n", irp); DPRINT ("Calling IO Driver... with irp %x\n", irp);
status = IoCallDriver(pDeviceObject, status = IoCallDriver (pDeviceObject, irp);
irp);
DPRINT ("Waiting for IO Operation for %x\n", irp); DPRINT ("Waiting for IO Operation for %x\n", irp);
if (status == STATUS_PENDING) if (status == STATUS_PENDING)
{ {
DPRINT ("Operation pending\n"); DPRINT ("Operation pending\n");
KeWaitForSingleObject(&event, KeWaitForSingleObject (&event, Suspended, KernelMode, FALSE, NULL);
Suspended,
KernelMode,
FALSE,
NULL);
DPRINT ("Getting IO Status... for %x\n", irp); DPRINT ("Getting IO Status... for %x\n", irp);
status = ioStatus.Status; status = ioStatus.Status;
} }
if (!NT_SUCCESS(status)) { if (!NT_SUCCESS (status))
{
DbgPrint ("IO failed!!! VFATREadSectors : Error code: %x\n", status); DbgPrint ("IO failed!!! VFATREadSectors : Error code: %x\n", status);
DbgPrint("(pDeviceObject %x, DiskSector %x, Buffer %x, offset 0x%x%x)\n", DbgPrint
pDeviceObject, ("(pDeviceObject %x, DiskSector %x, Buffer %x, offset 0x%x%x)\n",
DiskSector, pDeviceObject, DiskSector, Buffer, sectorNumber.u.HighPart,
Buffer,
sectorNumber.u.HighPart,
sectorNumber.u.LowPart); sectorNumber.u.LowPart);
return FALSE; return FALSE;
} }
@ -92,10 +81,10 @@ BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,
return TRUE; return TRUE;
} }
BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN
VFATWriteSectors (IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN ULONG SectorCount, IN ULONG SectorCount, IN UCHAR * Buffer)
IN UCHAR* Buffer)
{ {
LARGE_INTEGER sectorNumber; LARGE_INTEGER sectorNumber;
PIRP irp; PIRP irp;
@ -119,31 +108,27 @@ BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,
pDeviceObject, pDeviceObject,
Buffer, Buffer,
sectorSize, sectorSize,
&sectorNumber, &sectorNumber, &event, &ioStatus);
&event,
&ioStatus );
if (!irp) { if (!irp)
{
DbgPrint ("WRITE failed!!!\n"); DbgPrint ("WRITE failed!!!\n");
return FALSE; return FALSE;
} }
DPRINT ("Calling IO Driver...\n"); DPRINT ("Calling IO Driver...\n");
status = IoCallDriver(pDeviceObject, status = IoCallDriver (pDeviceObject, irp);
irp);
DPRINT ("Waiting for IO Operation...\n"); DPRINT ("Waiting for IO Operation...\n");
if (status == STATUS_PENDING) { if (status == STATUS_PENDING)
KeWaitForSingleObject(&event, {
Suspended, KeWaitForSingleObject (&event, Suspended, KernelMode, FALSE, NULL);
KernelMode,
FALSE,
NULL);
DPRINT ("Getting IO Status...\n"); DPRINT ("Getting IO Status...\n");
status = ioStatus.Status; status = ioStatus.Status;
} }
if (!NT_SUCCESS(status)) { if (!NT_SUCCESS (status))
{
DbgPrint ("IO failed!!! VFATWriteSectors : Error code: %x\n", status); DbgPrint ("IO failed!!! VFATWriteSectors : Error code: %x\n", status);
return FALSE; return FALSE;
} }
@ -151,4 +136,3 @@ BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,
DPRINT ("Block request succeeded\n"); DPRINT ("Block request succeeded\n");
return TRUE; return TRUE;
} }

10
reactos/drivers/fs/vfat/close.c
View file

@ -1,4 +1,4 @@
/* $Id: close.c,v 1.2 2000/09/12 10:12:13 jean Exp $ /* $Id: close.c,v 1.3 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -18,7 +18,8 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
NTSTATUS FsdCloseFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject) NTSTATUS
VfatCloseFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
/* /*
* FUNCTION: Closes a file * FUNCTION: Closes a file
*/ */
@ -53,7 +54,8 @@ NTSTATUS FsdCloseFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS STDCALL FsdClose(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Closes a file * FUNCTION: Closes a file
*/ */
@ -65,7 +67,7 @@ NTSTATUS STDCALL FsdClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
DPRINT ("FsdClose(DeviceObject %x, Irp %x)\n", DeviceObject, Irp); DPRINT ("FsdClose(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
Status = FsdCloseFile(DeviceExtension,FileObject); Status = VfatCloseFile (DeviceExtension, FileObject);
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;

161
reactos/drivers/fs/vfat/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.9 2000/12/08 17:12:43 jean Exp $ /* $Id: create.c,v 1.10 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -11,7 +11,6 @@
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <ddk/cctypes.h>
#include <wchar.h> #include <wchar.h>
#include <limits.h> #include <limits.h>
@ -22,7 +21,8 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
BOOLEAN IsLastEntry(PVOID Block, ULONG Offset) BOOLEAN
IsLastEntry (PVOID Block, ULONG Offset)
/* /*
* FUNCTION: Determine if the given directory entry is the last * FUNCTION: Determine if the given directory entry is the last
*/ */
@ -30,26 +30,32 @@ BOOLEAN IsLastEntry(PVOID Block, ULONG Offset)
return (((FATDirEntry *) Block)[Offset].Filename[0] == 0); return (((FATDirEntry *) Block)[Offset].Filename[0] == 0);
} }
BOOLEAN IsVolEntry(PVOID Block, ULONG Offset) BOOLEAN
IsVolEntry (PVOID Block, ULONG Offset)
/* /*
* FUNCTION: Determine if the given directory entry is a vol entry * FUNCTION: Determine if the given directory entry is a vol entry
*/ */
{ {
if( (((FATDirEntry *)Block)[Offset].Attrib)==0x28 ) return TRUE; if ((((FATDirEntry *) Block)[Offset].Attrib) == 0x28)
else return FALSE; return TRUE;
else
return FALSE;
} }
BOOLEAN IsDeletedEntry(PVOID Block, ULONG Offset) BOOLEAN
IsDeletedEntry (PVOID Block, ULONG Offset)
/* /*
* FUNCTION: Determines if the given entry is a deleted one * FUNCTION: Determines if the given entry is a deleted one
*/ */
{ {
/* Checks special character */ /* Checks special character */
return ((((FATDirEntry *)Block)[Offset].Filename[0] == 0xe5) || (((FATDirEntry *)Block)[Offset].Filename[0] == 0)); return ((((FATDirEntry *) Block)[Offset].Filename[0] == 0xe5) ||
(((FATDirEntry *) Block)[Offset].Filename[0] == 0));
} }
BOOLEAN GetEntryName(PVOID Block, PULONG _Offset, PWSTR Name, PULONG _jloop, BOOLEAN
GetEntryName (PVOID Block, PULONG _Offset, PWSTR Name, PULONG _jloop,
PDEVICE_EXTENSION DeviceExt, ULONG * _StartingSector) PDEVICE_EXTENSION DeviceExt, ULONG * _StartingSector)
/* /*
* FUNCTION: Retrieves the file name, be it in short or long file name format * FUNCTION: Retrieves the file name, be it in short or long file name format
@ -84,11 +90,13 @@ BOOLEAN GetEntryName(PVOID Block, PULONG _Offset, PWSTR Name, PULONG _jloop,
(test2[Offset].attr > 0)) (test2[Offset].attr > 0))
{ {
Offset++; Offset++;
if(Offset==ENTRIES_PER_SECTOR) { if (Offset == ENTRIES_PER_SECTOR)
{
Offset = 0; Offset = 0;
StartingSector++; //FIXME : nor always the next sector StartingSector++; //FIXME : nor always the next sector
jloop++; jloop++;
VFATReadSectors(DeviceExt->StorageDevice,StartingSector,1,Block); VFATReadSectors (DeviceExt->StorageDevice,
StartingSector, 1, Block);
test2 = (slot *) Block; test2 = (slot *) Block;
} }
cpos++; cpos++;
@ -127,7 +135,8 @@ BOOLEAN GetEntryName(PVOID Block, PULONG _Offset, PWSTR Name, PULONG _jloop,
return (TRUE); return (TRUE);
} }
NTSTATUS ReadVolumeLabel(PDEVICE_EXTENSION DeviceExt, PVPB Vpb) NTSTATUS
ReadVolumeLabel (PDEVICE_EXTENSION DeviceExt, PVPB Vpb)
/* /*
* FUNCTION: Read the volume label * FUNCTION: Read the volume label
*/ */
@ -199,8 +208,10 @@ NTSTATUS ReadVolumeLabel(PDEVICE_EXTENSION DeviceExt, PVPB Vpb)
} }
NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb, NTSTATUS
PVFATFCB Parent, PWSTR FileToFind,ULONG *StartSector,ULONG *Entry) FindFile (PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
PVFATFCB Parent, PWSTR FileToFind, ULONG * StartSector,
ULONG * Entry)
/* /*
* FUNCTION: Find a file * FUNCTION: Find a file
*/ */
@ -234,8 +245,8 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
Size = DeviceExt->rootDirectorySectors; /* FIXME : in fat32, no limit */ Size = DeviceExt->rootDirectorySectors; /* FIXME : in fat32, no limit */
StartingSector = DeviceExt->rootStart; StartingSector = DeviceExt->rootStart;
NextCluster = 0; NextCluster = 0;
if(FileToFind[0]==0 ||(FileToFind[0]=='\\' && FileToFind[1]==0) || if (FileToFind[0] == 0 || (FileToFind[0] == '\\' && FileToFind[1] == 0)
(FileToFind[0]=='.' && FileToFind[1]==0)) || (FileToFind[0] == '.' && FileToFind[1] == 0))
{ {
/* it's root : complete essentials fields then return ok */ /* it's root : complete essentials fields then return ok */
CHECKPOINT; CHECKPOINT;
@ -274,7 +285,8 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
CHECKPOINT; CHECKPOINT;
block = ExAllocatePool (NonPagedPool, BLOCKSIZE); block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
CHECKPOINT; CHECKPOINT;
if (StartSector && (*StartSector)) StartingSector=*StartSector; if (StartSector && (*StartSector))
StartingSector = *StartSector;
i = (Entry) ? (*Entry) : 0; i = (Entry) ? (*Entry) : 0;
DPRINT ("FindFile : start at sector %lx, entry %ld\n", StartingSector, i); DPRINT ("FindFile : start at sector %lx, entry %ld\n", StartingSector, i);
for (j = 0; j < Size; j++) for (j = 0; j < Size; j++)
@ -287,31 +299,38 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
continue; continue;
if (IsLastEntry ((PVOID) block, i)) if (IsLastEntry ((PVOID) block, i))
{ {
if(StartSector) *StartSector=StartingSector; if (StartSector)
if(Entry) *Entry=i; *StartSector = StartingSector;
if (Entry)
*Entry = i;
ExFreePool (block); ExFreePool (block);
return (STATUS_UNSUCCESSFUL); return (STATUS_UNSUCCESSFUL);
} }
if (GetEntryName((PVOID)block,&i,name,&j,DeviceExt,&StartingSector)) if (GetEntryName
((PVOID) block, &i, name, &j, DeviceExt, &StartingSector))
{ {
if (wstrcmpjoki (name, FileToFind)) if (wstrcmpjoki (name, FileToFind))
{ {
/* In the case of a long filename, the firstcluster is stored in /* In the case of a long filename, the firstcluster is stored in
the next record -- where it's short name is */ the next record -- where it's short name is */
if(((FATDirEntry *)block)[i].Attrib==0x0f) i++; if (((FATDirEntry *) block)[i].Attrib == 0x0f)
i++;
if (i == (ENTRIES_PER_SECTOR)) if (i == (ENTRIES_PER_SECTOR))
{ {
/* entry is in next sector */ /* entry is in next sector */
StartingSector++; StartingSector++;
/* FIXME : treat case of next sector fragmented */ /* FIXME : treat case of next sector fragmented */
VFATReadSectors(DeviceExt->StorageDevice,StartingSector,1,block); VFATReadSectors (DeviceExt->StorageDevice,
StartingSector, 1, block);
i = 0; i = 0;
} }
memcpy (&Fcb->entry, &((FATDirEntry *) block)[i], memcpy (&Fcb->entry, &((FATDirEntry *) block)[i],
sizeof (FATDirEntry)); sizeof (FATDirEntry));
vfat_wcsncpy (Fcb->ObjectName, name, MAX_PATH); vfat_wcsncpy (Fcb->ObjectName, name, MAX_PATH);
if(StartSector) *StartSector=StartingSector; if (StartSector)
if(Entry) *Entry=i; *StartSector = StartingSector;
if (Entry)
*Entry = i;
ExFreePool (block); ExFreePool (block);
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
@ -321,7 +340,8 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
/* directory can be fragmented although it is best to keep them /* directory can be fragmented although it is best to keep them
unfragmented */ unfragmented */
if(Entry) *Entry=0; if (Entry)
*Entry = 0;
StartingSector++; StartingSector++;
if ((Parent != NULL && Parent->entry.FirstCluster != 1) if ((Parent != NULL && Parent->entry.FirstCluster != 1)
|| DeviceExt->FatType == FAT32) || DeviceExt->FatType == FAT32)
@ -331,8 +351,10 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
NextCluster = GetNextCluster (DeviceExt, NextCluster); NextCluster = GetNextCluster (DeviceExt, NextCluster);
if (NextCluster == 0 || NextCluster == 0xffffffff) if (NextCluster == 0 || NextCluster == 0xffffffff)
{ {
if(StartSector) *StartSector=StartingSector; if (StartSector)
if(Entry) *Entry=i; *StartSector = StartingSector;
if (Entry)
*Entry = i;
ExFreePool (block); ExFreePool (block);
return (STATUS_UNSUCCESSFUL); return (STATUS_UNSUCCESSFUL);
} }
@ -340,15 +362,18 @@ NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
} }
} }
} }
if(StartSector) *StartSector=StartingSector; if (StartSector)
if(Entry) *Entry=i; *StartSector = StartingSector;
if (Entry)
*Entry = i;
ExFreePool (block); ExFreePool (block);
return (STATUS_UNSUCCESSFUL); return (STATUS_UNSUCCESSFUL);
} }
NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
FsdOpenFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PWSTR FileName) PWSTR FileName)
/* /*
* FUNCTION: Opens a file * FUNCTION: Opens a file
@ -368,10 +393,7 @@ NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
KIRQL oldIrql; KIRQL oldIrql;
DPRINT("FsdOpenFile(%08lx, %08lx, %S)\n", DPRINT ("FsdOpenFile(%08lx, %08lx, %S)\n", DeviceExt, FileObject, FileName);
DeviceExt,
FileObject,
FileName);
/* FIXME : treat relative name */ /* FIXME : treat relative name */
if (FileObject->RelatedFileObject) if (FileObject->RelatedFileObject)
@ -383,7 +405,8 @@ NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
pRelFcb = pRelCcb->pFcb; pRelFcb = pRelCcb->pFcb;
assert (pRelFcb); assert (pRelFcb);
/* /*
* verify related object is a directory and target name don't start with \. * verify related object is a directory and target name don't start with
* \.
*/ */
if (!(pRelFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY) if (!(pRelFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY)
|| (FileName[0] != '\\')) || (FileName[0] != '\\'))
@ -417,18 +440,18 @@ NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
DPRINT ("Scanning %x\n", Fcb); DPRINT ("Scanning %x\n", Fcb);
DPRINT ("Scanning %S\n", Fcb->PathName); DPRINT ("Scanning %S\n", Fcb->PathName);
if (DeviceExt==Fcb->pDevExt if (DeviceExt == Fcb->pDevExt && wstrcmpi (FileName, Fcb->PathName))
&& wstrcmpi(FileName,Fcb->PathName))
{ {
Fcb->RefCount++; Fcb->RefCount++;
KeReleaseSpinLock (&DeviceExt->FcbListLock, oldIrql); KeReleaseSpinLock (&DeviceExt->FcbListLock, oldIrql);
FileObject->FsContext =(PVOID) &Fcb->NTRequiredFCB; FileObject->FsContext = (PVOID)&Fcb->RFCB;
newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB)); newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB));
memset (newCCB, 0, sizeof (VFATCCB)); memset (newCCB, 0, sizeof (VFATCCB));
FileObject->FsContext2 = newCCB; FileObject->FsContext2 = newCCB;
newCCB->pFcb = Fcb; newCCB->pFcb = Fcb;
newCCB->PtrFileObject = FileObject; newCCB->PtrFileObject = FileObject;
if(AbsFileName)ExFreePool(AbsFileName); if (AbsFileName)
ExFreePool (AbsFileName);
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
@ -452,9 +475,11 @@ DPRINT("FileName %S\n", FileName);
memset (Fcb->entry.Filename, ' ', 11); memset (Fcb->entry.Filename, ' ', 11);
Fcb->entry.FileSize = DeviceExt->rootDirectorySectors * BLOCKSIZE; Fcb->entry.FileSize = DeviceExt->rootDirectorySectors * BLOCKSIZE;
Fcb->entry.Attrib = FILE_ATTRIBUTE_DIRECTORY; Fcb->entry.Attrib = FILE_ATTRIBUTE_DIRECTORY;
if (DeviceExt->FatType == FAT32)Fcb->entry.FirstCluster=2; if (DeviceExt->FatType == FAT32)
else Fcb->entry.FirstCluster=1; Fcb->entry.FirstCluster = 2;
//FIXME : is 1 the good value for mark root? else
Fcb->entry.FirstCluster = 1;
/* FIXME : is 1 the good value for mark root? */
ParentFcb = Fcb; ParentFcb = Fcb;
Fcb = NULL; Fcb = NULL;
} }
@ -538,14 +563,14 @@ CHECKPOINT;
} }
FileObject->FsContext =(PVOID) &ParentFcb->NTRequiredFCB; FileObject->FsContext = (PVOID)&ParentFcb->RFCB;
newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB)); newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB));
memset (newCCB, 0, sizeof (VFATCCB)); memset (newCCB, 0, sizeof (VFATCCB));
FileObject->FsContext2 = newCCB; FileObject->FsContext2 = newCCB;
newCCB->pFcb = ParentFcb; newCCB->pFcb = ParentFcb;
newCCB->PtrFileObject = FileObject; newCCB->PtrFileObject = FileObject;
ParentFcb->RefCount++; ParentFcb->RefCount++;
//FIXME : initialize all fields in FCB and CCB /* FIXME : initialize all fields in FCB and CCB */
KeAcquireSpinLock (&DeviceExt->FcbListLock, &oldIrql); KeAcquireSpinLock (&DeviceExt->FcbListLock, &oldIrql);
InsertTailList (&DeviceExt->FcbListHead, &ParentFcb->FcbListEntry); InsertTailList (&DeviceExt->FcbListHead, &ParentFcb->FcbListEntry);
@ -554,6 +579,12 @@ CHECKPOINT;
vfat_wcsncpy (ParentFcb->PathName, FileName, MAX_PATH); vfat_wcsncpy (ParentFcb->PathName, FileName, MAX_PATH);
ParentFcb->ObjectName = ParentFcb->PathName + (current - FileName); ParentFcb->ObjectName = ParentFcb->PathName + (current - FileName);
ParentFcb->pDevExt = DeviceExt; ParentFcb->pDevExt = DeviceExt;
Status = CcInitializeFileCache(FileObject, &ParentFcb->RFCB.Bcb);
if (!NT_SUCCESS(Status))
{
DbgPrint("CcInitializeFileCache failed\n");
KeBugCheck(0);
}
DPRINT ("file open, fcb=%x\n", ParentFcb); DPRINT ("file open, fcb=%x\n", ParentFcb);
DPRINT ("FileSize %d\n", ParentFcb->entry.FileSize); DPRINT ("FileSize %d\n", ParentFcb->entry.FileSize);
if (Fcb) if (Fcb)
@ -566,7 +597,8 @@ CHECKPOINT;
} }
NTSTATUS FsdCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS
VfatCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Create or open a file * FUNCTION: Create or open a file
*/ */
@ -582,7 +614,8 @@ NTSTATUS FsdCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp)
Stack = IoGetCurrentIrpStackLocation (Irp); Stack = IoGetCurrentIrpStackLocation (Irp);
assert (Stack); assert (Stack);
RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff); RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
RequestedOptions=Stack->Parameters.Create.Options&FILE_VALID_OPTION_FLAGS; RequestedOptions =
Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
if ((RequestedOptions & FILE_DIRECTORY_FILE) if ((RequestedOptions & FILE_DIRECTORY_FILE)
&& RequestedDisposition == FILE_SUPERSEDE) && RequestedDisposition == FILE_SUPERSEDE)
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
@ -609,15 +642,18 @@ NTSTATUS FsdCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp)
|| RequestedDisposition == FILE_SUPERSEDE) || RequestedDisposition == FILE_SUPERSEDE)
{ {
CHECKPOINT; CHECKPOINT;
Status=addEntry(DeviceExt,FileObject,RequestedOptions Status =
,(Stack->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS)); addEntry (DeviceExt, FileObject, RequestedOptions,
(Stack->Parameters.
Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS));
if (NT_SUCCESS (Status)) if (NT_SUCCESS (Status))
Irp->IoStatus.Information = FILE_CREATED; Irp->IoStatus.Information = FILE_CREATED;
// FIXME set size if AllocationSize requested /* FIXME set size if AllocationSize requested */
// FIXME set extended attributes ? /* FIXME set extended attributes? */
// FIXME set share access /* FIXME set share access */
// IoSetShareAccess(DesiredAccess,ShareAccess,FileObject /* IoSetShareAccess(DesiredAccess,ShareAccess,FileObject,
// ,((PVfatCCB)(FileObject->FsContext2))->pFcb->FCBShareAccess); * ((PVfatCCB)(FileObject->FsContext2))->pFcb->FCBShareAccess);
*/
} }
} }
else else
@ -659,22 +695,23 @@ CHECKPOINT;
{ {
Status = STATUS_NOT_A_DIRECTORY; Status = STATUS_NOT_A_DIRECTORY;
} }
// FIXME : test share access /* FIXME : test share access */
// FIXME : test write access if requested /* FIXME : test write access if requested */
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS (Status))
FsdCloseFile(DeviceExt,FileObject); VfatCloseFile (DeviceExt, FileObject);
else Irp->IoStatus.Information = FILE_OPENED; else
// FIXME : make supersed or overwrite if requested Irp->IoStatus.Information = FILE_OPENED;
/* FIXME : make supersed or overwrite if requested */
} }
CHECKPOINT;
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;
return Status; return Status;
} }
NTSTATUS STDCALL FsdCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatCreate (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Create or open a file * FUNCTION: Create or open a file
*/ */
@ -687,7 +724,7 @@ NTSTATUS STDCALL FsdCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
if (DeviceObject->Size == sizeof (DEVICE_OBJECT)) if (DeviceObject->Size == sizeof (DEVICE_OBJECT))
{ {
/* DeviceObject represent FileSystem instead of logical volume */ /* DeviceObject represents FileSystem instead of logical volume */
DbgPrint ("FsdCreate called with file system\n"); DbgPrint ("FsdCreate called with file system\n");
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = FILE_OPENED; Irp->IoStatus.Information = FILE_OPENED;
@ -699,7 +736,7 @@ NTSTATUS STDCALL FsdCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
assert (DeviceExt); assert (DeviceExt);
ExAcquireResourceExclusiveLite (&DeviceExt->DirResource, TRUE); ExAcquireResourceExclusiveLite (&DeviceExt->DirResource, TRUE);
Status = FsdCreateFile (DeviceObject, Irp); Status = VfatCreateFile (DeviceObject, Irp);
ExReleaseResourceLite (&DeviceExt->DirResource); ExReleaseResourceLite (&DeviceExt->DirResource);

185
reactos/drivers/fs/vfat/dir.c
View file

@ -43,7 +43,8 @@ BOOL FsdDosDateTimeToFileTime(WORD wDosDate,WORD wDosTime, TIME *FileTime)
// function like FileTimeToDosDateTime // function like FileTimeToDosDateTime
BOOL FsdFileTimeToDosDateTime(TIME *FileTime,WORD *pwDosDate,WORD *pwDosTime) BOOL
FsdFileTimeToDosDateTime (TIME * FileTime, WORD * pwDosDate, WORD * pwDosTime)
{ {
PDOSTIME pdtime = (PDOSTIME) pwDosTime; PDOSTIME pdtime = (PDOSTIME) pwDosTime;
PDOSDATE pddate = (PDOSDATE) pwDosDate; PDOSDATE pddate = (PDOSDATE) pwDosDate;
@ -73,12 +74,14 @@ BOOL FsdFileTimeToDosDateTime(TIME *FileTime,WORD *pwDosDate,WORD *pwDosTime)
unsigned long vfat_wstrlen(PWSTR s) unsigned long
vfat_wstrlen (PWSTR s)
{ {
WCHAR c = ' '; WCHAR c = ' ';
unsigned int len = 0; unsigned int len = 0;
while(c!=0) { while (c != 0)
{
c = *s; c = *s;
s++; s++;
len++; len++;
@ -87,9 +90,11 @@ unsigned long vfat_wstrlen(PWSTR s)
return len - 1; return len - 1;
} }
#define DWORD_ROUND_UP(x) ( (((ULONG)(x))%32) ? ((((ULONG)x)&(~0x1f))+0x20) : ((ULONG)x) ) #define DWORD_ROUND_UP(x) ( (((ULONG)(x))%32) ? ((((ULONG)x)&(~0x1f))+0x20) : ((ULONG)x) )
NTSTATUS FsdGetFileNameInformation(PVFATFCB pFcb, NTSTATUS
VfatGetFileNameInformation (PVFATFCB pFcb,
PFILE_NAMES_INFORMATION pInfo, ULONG BufferLength) PFILE_NAMES_INFORMATION pInfo, ULONG BufferLength)
{ {
ULONG Length; ULONG Length;
@ -97,15 +102,18 @@ NTSTATUS FsdGetFileNameInformation(PVFATFCB pFcb,
if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length) > BufferLength) if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length) > BufferLength)
return STATUS_BUFFER_OVERFLOW; return STATUS_BUFFER_OVERFLOW;
pInfo->FileNameLength = Length; pInfo->FileNameLength = Length;
pInfo->NextEntryOffset=DWORD_ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION)+Length); pInfo->NextEntryOffset =
memcpy(pInfo->FileName,pFcb->ObjectName DWORD_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) + Length);
,sizeof(WCHAR)*(pInfo->FileNameLength)); memcpy (pInfo->FileName, pFcb->ObjectName,
sizeof (WCHAR) * (pInfo->FileNameLength));
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS FsdGetFileDirectoryInformation(PVFATFCB pFcb, NTSTATUS
VfatGetFileDirectoryInformation (PVFATFCB pFcb,
PDEVICE_EXTENSION DeviceExt, PDEVICE_EXTENSION DeviceExt,
PFILE_DIRECTORY_INFORMATION pInfo,ULONG BufferLength) PFILE_DIRECTORY_INFORMATION pInfo,
ULONG BufferLength)
{ {
unsigned long long AllocSize; unsigned long long AllocSize;
ULONG Length; ULONG Length;
@ -113,32 +121,34 @@ NTSTATUS FsdGetFileDirectoryInformation(PVFATFCB pFcb,
if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length) > BufferLength) if ((sizeof (FILE_DIRECTORY_INFORMATION) + Length) > BufferLength)
return STATUS_BUFFER_OVERFLOW; return STATUS_BUFFER_OVERFLOW;
pInfo->FileNameLength = Length; pInfo->FileNameLength = Length;
pInfo->NextEntryOffset=DWORD_ROUND_UP(sizeof(FILE_DIRECTORY_INFORMATION)+Length); pInfo->NextEntryOffset =
memcpy(pInfo->FileName,pFcb->ObjectName DWORD_ROUND_UP (sizeof (FILE_DIRECTORY_INFORMATION) + Length);
,sizeof(WCHAR)*(pInfo->FileNameLength)); memcpy (pInfo->FileName, pFcb->ObjectName,
sizeof (WCHAR) * (pInfo->FileNameLength));
// pInfo->FileIndex=; // pInfo->FileIndex=;
FsdDosDateTimeToFileTime(pFcb->entry.CreationDate,pFcb->entry.CreationTime FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
,&pInfo->CreationTime); pFcb->entry.CreationTime, &pInfo->CreationTime);
FsdDosDateTimeToFileTime(pFcb->entry.AccessDate,0 FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
,&pInfo->LastAccessTime); &pInfo->LastAccessTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->LastWriteTime); &pInfo->LastWriteTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->ChangeTime); &pInfo->ChangeTime);
pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize); pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
/* Make allocsize a rounded up multiple of BytesPerCluster */ /* Make allocsize a rounded up multiple of BytesPerCluster */
AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) / AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
DeviceExt->BytesPerCluster;
pInfo->AllocationSize.QuadPart = AllocSize; pInfo->AllocationSize.QuadPart = AllocSize;
pInfo->FileAttributes = pFcb->entry.Attrib; pInfo->FileAttributes = pFcb->entry.Attrib;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS FsdGetFileFullDirectoryInformation(PVFATFCB pFcb, NTSTATUS
VfatGetFileFullDirectoryInformation (PVFATFCB pFcb,
PDEVICE_EXTENSION DeviceExt, PDEVICE_EXTENSION DeviceExt,
PFILE_FULL_DIRECTORY_INFORMATION pInfo,ULONG BufferLength) PFILE_FULL_DIRECTORY_INFORMATION pInfo,
ULONG BufferLength)
{ {
unsigned long long AllocSize; unsigned long long AllocSize;
ULONG Length; ULONG Length;
@ -146,32 +156,34 @@ NTSTATUS FsdGetFileFullDirectoryInformation(PVFATFCB pFcb,
if ((sizeof (FILE_FULL_DIRECTORY_INFORMATION) + Length) > BufferLength) if ((sizeof (FILE_FULL_DIRECTORY_INFORMATION) + Length) > BufferLength)
return STATUS_BUFFER_OVERFLOW; return STATUS_BUFFER_OVERFLOW;
pInfo->FileNameLength = Length; pInfo->FileNameLength = Length;
pInfo->NextEntryOffset=DWORD_ROUND_UP(sizeof(FILE_FULL_DIRECTORY_INFORMATION)+Length); pInfo->NextEntryOffset =
memcpy(pInfo->FileName,pFcb->ObjectName DWORD_ROUND_UP (sizeof (FILE_FULL_DIRECTORY_INFORMATION) + Length);
,sizeof(WCHAR)*(pInfo->FileNameLength)); memcpy (pInfo->FileName, pFcb->ObjectName,
sizeof (WCHAR) * (pInfo->FileNameLength));
// pInfo->FileIndex=; // pInfo->FileIndex=;
FsdDosDateTimeToFileTime(pFcb->entry.CreationDate,pFcb->entry.CreationTime FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
,&pInfo->CreationTime); pFcb->entry.CreationTime, &pInfo->CreationTime);
FsdDosDateTimeToFileTime(pFcb->entry.AccessDate,0 FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
,&pInfo->LastAccessTime); &pInfo->LastAccessTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->LastWriteTime); &pInfo->LastWriteTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->ChangeTime); &pInfo->ChangeTime);
pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize); pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
/* Make allocsize a rounded up multiple of BytesPerCluster */ /* Make allocsize a rounded up multiple of BytesPerCluster */
AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) / AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
DeviceExt->BytesPerCluster;
pInfo->AllocationSize.QuadPart = AllocSize; pInfo->AllocationSize.QuadPart = AllocSize;
pInfo->FileAttributes = pFcb->entry.Attrib; pInfo->FileAttributes = pFcb->entry.Attrib;
// pInfo->EaSize=; // pInfo->EaSize=;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS FsdGetFileBothInformation(PVFATFCB pFcb, NTSTATUS
VfatGetFileBothInformation (PVFATFCB pFcb,
PDEVICE_EXTENSION DeviceExt, PDEVICE_EXTENSION DeviceExt,
PFILE_BOTH_DIRECTORY_INFORMATION pInfo,ULONG BufferLength) PFILE_BOTH_DIRECTORY_INFORMATION pInfo,
ULONG BufferLength)
{ {
short i; short i;
unsigned long long AllocSize; unsigned long long AllocSize;
@ -180,23 +192,23 @@ NTSTATUS FsdGetFileBothInformation(PVFATFCB pFcb,
if ((sizeof (FILE_BOTH_DIRECTORY_INFORMATION) + Length) > BufferLength) if ((sizeof (FILE_BOTH_DIRECTORY_INFORMATION) + Length) > BufferLength)
return STATUS_BUFFER_OVERFLOW; return STATUS_BUFFER_OVERFLOW;
pInfo->FileNameLength = Length; pInfo->FileNameLength = Length;
pInfo->NextEntryOffset=DWORD_ROUND_UP(sizeof(FILE_BOTH_DIRECTORY_INFORMATION)+Length); pInfo->NextEntryOffset =
memcpy(pInfo->FileName,pFcb->ObjectName DWORD_ROUND_UP (sizeof (FILE_BOTH_DIRECTORY_INFORMATION) + Length);
,sizeof(WCHAR)*(pInfo->FileNameLength)); memcpy (pInfo->FileName, pFcb->ObjectName,
sizeof (WCHAR) * (pInfo->FileNameLength));
// pInfo->FileIndex=; // pInfo->FileIndex=;
FsdDosDateTimeToFileTime(pFcb->entry.CreationDate,pFcb->entry.CreationTime FsdDosDateTimeToFileTime (pFcb->entry.CreationDate,
,&pInfo->CreationTime); pFcb->entry.CreationTime, &pInfo->CreationTime);
FsdDosDateTimeToFileTime(pFcb->entry.AccessDate,0 FsdDosDateTimeToFileTime (pFcb->entry.AccessDate, 0,
,&pInfo->LastAccessTime); &pInfo->LastAccessTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->LastWriteTime); &pInfo->LastWriteTime);
FsdDosDateTimeToFileTime(pFcb->entry.UpdateDate,pFcb->entry.UpdateTime FsdDosDateTimeToFileTime (pFcb->entry.UpdateDate, pFcb->entry.UpdateTime,
,&pInfo->ChangeTime); &pInfo->ChangeTime);
pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize); pInfo->EndOfFile = RtlConvertUlongToLargeInteger (pFcb->entry.FileSize);
/* Make allocsize a rounded up multiple of BytesPerCluster */ /* Make allocsize a rounded up multiple of BytesPerCluster */
AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) / AllocSize = ((pFcb->entry.FileSize + DeviceExt->BytesPerCluster - 1) /
DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster) * DeviceExt->BytesPerCluster;
DeviceExt->BytesPerCluster;
pInfo->AllocationSize.QuadPart = AllocSize; pInfo->AllocationSize.QuadPart = AllocSize;
pInfo->FileAttributes = pFcb->entry.Attrib; pInfo->FileAttributes = pFcb->entry.Attrib;
// pInfo->EaSize=; // pInfo->EaSize=;
@ -206,11 +218,13 @@ NTSTATUS FsdGetFileBothInformation(PVFATFCB pFcb,
pInfo->ShortName[i] = '.'; pInfo->ShortName[i] = '.';
for (i = 0; i < 3 && (pFcb->entry.Ext[i] != ' '); i++) for (i = 0; i < 3 && (pFcb->entry.Ext[i] != ' '); i++)
pInfo->ShortName[i + 1 + pInfo->ShortNameLength] = pFcb->entry.Ext[i]; pInfo->ShortName[i + 1 + pInfo->ShortNameLength] = pFcb->entry.Ext[i];
if(i) pInfo->ShortNameLength += (i+1); if (i)
pInfo->ShortNameLength += (i + 1);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS DoQuery(PDEVICE_OBJECT DeviceObject, PIRP Irp,PIO_STACK_LOCATION Stack) NTSTATUS
DoQuery (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION Stack)
{ {
NTSTATUS RC = STATUS_SUCCESS; NTSTATUS RC = STATUS_SUCCESS;
long BufferLength = 0; long BufferLength = 0;
@ -230,7 +244,8 @@ NTSTATUS DoQuery(PDEVICE_OBJECT DeviceObject, PIRP Irp,PIO_STACK_LOCATION Stack)
// Obtain the callers parameters // Obtain the callers parameters
BufferLength = Stack->Parameters.QueryDirectory.Length; BufferLength = Stack->Parameters.QueryDirectory.Length;
pSearchPattern = Stack->Parameters.QueryDirectory.FileName; pSearchPattern = Stack->Parameters.QueryDirectory.FileName;
FileInformationClass = Stack->Parameters.QueryDirectory.FileInformationClass; FileInformationClass =
Stack->Parameters.QueryDirectory.FileInformationClass;
FileIndex = Stack->Parameters.QueryDirectory.FileIndex; FileIndex = Stack->Parameters.QueryDirectory.FileIndex;
pFileObject = Stack->FileObject; pFileObject = Stack->FileObject;
pCcb = (PVFATCCB) pFileObject->FsContext2; pCcb = (PVFATCCB) pFileObject->FsContext2;
@ -251,35 +266,47 @@ NTSTATUS DoQuery(PDEVICE_OBJECT DeviceObject, PIRP Irp,PIO_STACK_LOCATION Stack)
star[1] = 0; star[1] = 0;
pCharPattern = star; pCharPattern = star;
} }
else pCharPattern=pSearchPattern->Buffer; else
pCharPattern = pSearchPattern->Buffer;
tmpFcb.ObjectName = tmpFcb.PathName; tmpFcb.ObjectName = tmpFcb.PathName;
while (RC == STATUS_SUCCESS && BufferLength > 0) while (RC == STATUS_SUCCESS && BufferLength > 0)
{ {
OldSector = pCcb->StartSector; OldSector = pCcb->StartSector;
OldEntry = pCcb->StartEntry; OldEntry = pCcb->StartEntry;
if(OldSector)pCcb->StartEntry++; if (OldSector)
RC=FindFile(DeviceExt,&tmpFcb,pFcb,pCharPattern,&pCcb->StartSector,&pCcb->StartEntry); pCcb->StartEntry++;
DPRINT("Found %S,RC=%x, sector %x entry %x\n",tmpFcb.ObjectName,RC RC =
,pCcb->StartSector,pCcb->StartEntry); FindFile (DeviceExt, &tmpFcb, pFcb, pCharPattern, &pCcb->StartSector,
&pCcb->StartEntry);
DPRINT ("Found %S,RC=%x, sector %x entry %x\n", tmpFcb.ObjectName, RC,
pCcb->StartSector, pCcb->StartEntry);
if (NT_SUCCESS (RC)) if (NT_SUCCESS (RC))
{ {
switch (FileInformationClass) switch (FileInformationClass)
{ {
case FileNameInformation: case FileNameInformation:
RC=FsdGetFileNameInformation(&tmpFcb RC =
,(PFILE_NAMES_INFORMATION)Buffer,BufferLength); VfatGetFileNameInformation (&tmpFcb,
(PFILE_NAMES_INFORMATION) Buffer,
BufferLength);
break; break;
case FileDirectoryInformation: case FileDirectoryInformation:
RC= FsdGetFileDirectoryInformation(&tmpFcb RC =
,DeviceExt,(PFILE_DIRECTORY_INFORMATION)Buffer,BufferLength); VfatGetFileDirectoryInformation (&tmpFcb, DeviceExt,
(PFILE_DIRECTORY_INFORMATION)
Buffer, BufferLength);
break; break;
case FileFullDirectoryInformation: case FileFullDirectoryInformation:
RC= FsdGetFileFullDirectoryInformation(&tmpFcb RC =
,DeviceExt,(PFILE_FULL_DIRECTORY_INFORMATION)Buffer,BufferLength); VfatGetFileFullDirectoryInformation (&tmpFcb, DeviceExt,
(PFILE_FULL_DIRECTORY_INFORMATION)
Buffer, BufferLength);
break; break;
case FileBothDirectoryInformation: case FileBothDirectoryInformation:
RC=FsdGetFileBothInformation(&tmpFcb RC =
,DeviceExt,(PFILE_BOTH_DIRECTORY_INFORMATION)Buffer,BufferLength); VfatGetFileBothInformation (&tmpFcb, DeviceExt,
(PFILE_BOTH_DIRECTORY_INFORMATION)
Buffer, BufferLength);
break; break;
default: default:
RC = STATUS_INVALID_INFO_CLASS; RC = STATUS_INVALID_INFO_CLASS;
@ -287,29 +314,35 @@ DPRINT("Found %S,RC=%x, sector %x entry %x\n",tmpFcb.ObjectName,RC
} }
else else
{ {
if(Buffer0) Buffer0->NextEntryOffset=0; if (Buffer0)
Buffer0->NextEntryOffset = 0;
break; break;
} }
if (RC == STATUS_BUFFER_OVERFLOW) if (RC == STATUS_BUFFER_OVERFLOW)
{ {
if(Buffer0) Buffer0->NextEntryOffset=0; if (Buffer0)
Buffer0->NextEntryOffset = 0;
pCcb->StartSector = OldSector; pCcb->StartSector = OldSector;
pCcb->StartEntry = OldEntry; pCcb->StartEntry = OldEntry;
break; break;
} }
Buffer0 = (PFILE_NAMES_INFORMATION) Buffer; Buffer0 = (PFILE_NAMES_INFORMATION) Buffer;
Buffer0->FileIndex = FileIndex++; Buffer0->FileIndex = FileIndex++;
if(Stack->Flags & SL_RETURN_SINGLE_ENTRY) break; if (Stack->Flags & SL_RETURN_SINGLE_ENTRY)
break;
BufferLength -= Buffer0->NextEntryOffset; BufferLength -= Buffer0->NextEntryOffset;
Buffer += Buffer0->NextEntryOffset; Buffer += Buffer0->NextEntryOffset;
} }
if(Buffer0) Buffer0->NextEntryOffset=0; if (Buffer0)
if(FileIndex>0) return STATUS_SUCCESS; Buffer0->NextEntryOffset = 0;
if (FileIndex > 0)
return STATUS_SUCCESS;
return RC; return RC;
} }
NTSTATUS STDCALL FsdDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatDirectoryControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: directory control : read/write directory informations * FUNCTION: directory control : read/write directory informations
*/ */
@ -331,7 +364,8 @@ NTSTATUS STDCALL FsdDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
break; break;
default: default:
// error // error
DbgPrint("unexpected minor function %x in VFAT driver\n",Stack->MinorFunction); DbgPrint ("unexpected minor function %x in VFAT driver\n",
Stack->MinorFunction);
RC = STATUS_INVALID_DEVICE_REQUEST; RC = STATUS_INVALID_DEVICE_REQUEST;
break; break;
} }
@ -341,4 +375,3 @@ NTSTATUS STDCALL FsdDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
IoCompleteRequest (Irp, IO_NO_INCREMENT); IoCompleteRequest (Irp, IO_NO_INCREMENT);
return RC; return RC;
} }

108
reactos/drivers/fs/vfat/dirwr.c
View file

@ -1,4 +1,4 @@
/* $Id: dirwr.c,v 1.13 2000/06/29 23:35:50 dwelch Exp $ /* $Id: dirwr.c,v 1.14 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -103,7 +103,8 @@ NTSTATUS updEntry(PDEVICE_EXTENSION DeviceExt,PFILE_OBJECT pFileObject)
//find last \ in PathFileName //find last \ in PathFileName
posCar = -1; posCar = -1;
for (i = 0; PathFileName[i]; i++) for (i = 0; PathFileName[i]; i++)
if(PathFileName[i]=='\\')posCar=i; if (PathFileName[i] == '\\')
posCar = i;
if (posCar == -1) if (posCar == -1)
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
FileName = &PathFileName[posCar + 1]; FileName = &PathFileName[posCar + 1];
@ -116,14 +117,16 @@ NTSTATUS updEntry(PDEVICE_EXTENSION DeviceExt,PFILE_OBJECT pFileObject)
DirName[0] = L'\\'; DirName[0] = L'\\';
DirName[1] = 0; DirName[1] = 0;
} }
else { else
{
memcpy (DirName, PathFileName, posCar * sizeof (WCHAR)); memcpy (DirName, PathFileName, posCar * sizeof (WCHAR));
DirName[posCar] = 0; DirName[posCar] = 0;
} }
if (FileName[0] == 0 && DirName[0] == 0) if (FileName[0] == 0 && DirName[0] == 0)
return STATUS_SUCCESS; //root : nothing to do ? return STATUS_SUCCESS; //root : nothing to do ?
memset (&FileObject, 0, sizeof (FILE_OBJECT)); memset (&FileObject, 0, sizeof (FILE_OBJECT));
DPRINT("open directory \'%S\' for update of entry \'%S\'\n",DirName,FileName); DPRINT ("open directory \'%S\' for update of entry \'%S\'\n", DirName,
FileName);
status = FsdOpenFile (DeviceExt, &FileObject, DirName); status = FsdOpenFile (DeviceExt, &FileObject, DirName);
if (!NT_SUCCESS (status)) if (!NT_SUCCESS (status))
{ {
@ -146,15 +149,14 @@ NTSTATUS updEntry(PDEVICE_EXTENSION DeviceExt,PFILE_OBJECT pFileObject)
VFATWriteSectors (DeviceExt->StorageDevice, Sector, 1, Buffer); VFATWriteSectors (DeviceExt->StorageDevice, Sector, 1, Buffer);
ExFreePool (Buffer); ExFreePool (Buffer);
} }
FsdCloseFile(DeviceExt,&FileObject); VfatCloseFile (DeviceExt, &FileObject);
return status; return status;
} }
NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt, NTSTATUS
PFILE_OBJECT pFileObject, addEntry (PDEVICE_EXTENSION DeviceExt,
ULONG RequestedOptions, PFILE_OBJECT pFileObject, ULONG RequestedOptions, UCHAR ReqAttr)
UCHAR ReqAttr)
/* /*
create a new FAT entry create a new FAT entry
*/ */
@ -181,7 +183,8 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
//find last \ in PathFileName //find last \ in PathFileName
posCar = -1; posCar = -1;
for (i = 0; PathFileName[i]; i++) for (i = 0; PathFileName[i]; i++)
if(PathFileName[i]=='\\')posCar=i; if (PathFileName[i] == '\\')
posCar = i;
if (posCar == -1) if (posCar == -1)
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
FileName = &PathFileName[posCar + 1]; FileName = &PathFileName[posCar + 1];
@ -194,7 +197,8 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
status = FsdOpenFile (DeviceExt, &FileObject, DirName); status = FsdOpenFile (DeviceExt, &FileObject, DirName);
nbSlots = (NameLen + 12) / 13 + 1; //nb of entry needed for long name+normal entry nbSlots = (NameLen + 12) / 13 + 1; //nb of entry needed for long name+normal entry
DPRINT ("NameLen= %d, nbSlots =%d\n", NameLen, nbSlots); DPRINT ("NameLen= %d, nbSlots =%d\n", NameLen, nbSlots);
Buffer=ExAllocatePool(NonPagedPool,(nbSlots+1)*sizeof(FATDirEntry)); Buffer =
ExAllocatePool (NonPagedPool, (nbSlots + 1) * sizeof (FATDirEntry));
memset (Buffer, 0, (nbSlots + 1) * sizeof (FATDirEntry)); memset (Buffer, 0, (nbSlots + 1) * sizeof (FATDirEntry));
pEntry = (FATDirEntry *) (Buffer + (nbSlots - 1) * sizeof (FATDirEntry)); pEntry = (FATDirEntry *) (Buffer + (nbSlots - 1) * sizeof (FATDirEntry));
pSlots = (slot *) Buffer; pSlots = (slot *) Buffer;
@ -203,9 +207,12 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
// find last point in name // find last point in name
posCar = 0; posCar = 0;
for (i = 0; FileName[i]; i++) for (i = 0; FileName[i]; i++)
if(FileName[i]=='.')posCar=i; if (FileName[i] == '.')
if(!posCar) posCar=i; posCar = i;
if(posCar>8) needTilde=TRUE; if (!posCar)
posCar = i;
if (posCar > 8)
needTilde = TRUE;
//copy 8 characters max //copy 8 characters max
memset (pEntry, ' ', 11); memset (pEntry, ' ', 11);
for (i = 0, j = 0; j < 8 && i < posCar; i++) for (i = 0, j = 0; j < 8 && i < posCar; i++)
@ -216,10 +223,7 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
&& FileName[i] != '+' && FileName[i] != '+'
&& FileName[i] != ',' && FileName[i] != ','
&& FileName[i] != ';' && FileName[i] != ';'
&& FileName[i]!='=' && FileName[i] != '=' && FileName[i] != '[' && FileName[i] != ']')
&& FileName[i]!='['
&& FileName[i]!=']'
)
pEntry->Filename[j++] = toupper ((char) FileName[i]); pEntry->Filename[j++] = toupper ((char) FileName[i]);
else else
needTilde = TRUE; needTilde = TRUE;
@ -250,9 +254,10 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
{ {
DirName[7] = '0' + i; DirName[7] = '0' + i;
pEntry->Filename[7] = '0' + i; pEntry->Filename[7] = '0' + i;
status=FindFile(DeviceExt,&FileFcb status =
,&DirFcb,DirName,NULL,NULL); FindFile (DeviceExt, &FileFcb, &DirFcb, DirName, NULL, NULL);
if(status!=STATUS_SUCCESS)break; if (status != STATUS_SUCCESS)
break;
} }
//try second with xxxxx~yy.zzz //try second with xxxxx~yy.zzz
if (i == 10) if (i == 10)
@ -262,14 +267,15 @@ NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt,
{ {
DirName[7] = '0' + i; DirName[7] = '0' + i;
pEntry->Filename[7] = '0' + i; pEntry->Filename[7] = '0' + i;
status=FindFile(DeviceExt,&FileFcb status =
,&DirFcb,DirName,NULL,NULL); FindFile (DeviceExt, &FileFcb, &DirFcb, DirName, NULL, NULL);
if(status!=STATUS_SUCCESS)break; if (status != STATUS_SUCCESS)
break;
} }
} }
if (i == 100) //FIXME : what to do after 99 tilde ? if (i == 100) //FIXME : what to do after 99 tilde ?
{ {
FsdCloseFile(DeviceExt,&FileObject); VfatCloseFile (DeviceExt, &FileObject);
ExFreePool (Buffer); ExFreePool (Buffer);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -289,7 +295,8 @@ DPRINT("i=%d,%d,%d\n",i,pEntry->Filename[i],FileName[i]);
for (j = 0, i = posCar + 1; FileName[i] && i < posCar + 4; i++) for (j = 0, i = posCar + 1; FileName[i] && i < posCar + 4; i++)
if ((USHORT) pEntry->Ext[j++] != FileName[i]) if ((USHORT) pEntry->Ext[j++] != FileName[i])
{ {
DPRINT("i=%d,j=%d,%d,%d\n",i,j,pEntry->Filename[i],FileName[i]); DPRINT ("i=%d,j=%d,%d,%d\n", i, j, pEntry->Filename[i],
FileName[i]);
needLong = TRUE; needLong = TRUE;
} }
} }
@ -316,11 +323,9 @@ DPRINT("i=%d,j=%d,%d,%d\n",i,j,pEntry->Filename[i],FileName[i]);
/* set dates and times */ /* set dates and times */
KeQuerySystemTime (&SystemTime); KeQuerySystemTime (&SystemTime);
ExSystemTimeToLocalTime (&SystemTime, ExSystemTimeToLocalTime (&SystemTime, &LocalTime);
&LocalTime);
FsdFileTimeToDosDateTime ((TIME *) & LocalTime, FsdFileTimeToDosDateTime ((TIME *) & LocalTime,
&pEntry->CreationDate, &pEntry->CreationDate, &pEntry->CreationTime);
&pEntry->CreationTime);
pEntry->UpdateDate = pEntry->CreationDate; pEntry->UpdateDate = pEntry->CreationDate;
pEntry->UpdateTime = pEntry->CreationTime; pEntry->UpdateTime = pEntry->CreationTime;
pEntry->AccessDate = pEntry->CreationDate; pEntry->AccessDate = pEntry->CreationDate;
@ -349,18 +354,19 @@ DPRINT("i=%d,j=%d,%d,%d\n",i,j,pEntry->Filename[i],FileName[i]);
//try to find nbSlots contiguous entries frees in directory //try to find nbSlots contiguous entries frees in directory
for (i = 0, status = STATUS_SUCCESS; status == STATUS_SUCCESS; i++) for (i = 0, status = STATUS_SUCCESS; status == STATUS_SUCCESS; i++)
{ {
status=FsdReadFile(DeviceExt,&FileObject,&FatEntry status =
,sizeof(FATDirEntry),i*sizeof(FATDirEntry),&LengthRead); VfatReadFile (DeviceExt, &FileObject, &FatEntry, sizeof (FATDirEntry),
i * sizeof (FATDirEntry), &LengthRead);
if (status == STATUS_END_OF_FILE) if (status == STATUS_END_OF_FILE)
break; break;
if (!NT_SUCCESS (status)) if (!NT_SUCCESS (status))
{ {
DPRINT1( "FsdReadFile failed to read the directory entry\n" ); DPRINT1 ("VfatReadFile failed to read the directory entry\n");
break; break;
} }
if (LengthRead != sizeof (FATDirEntry)) if (LengthRead != sizeof (FATDirEntry))
{ {
DPRINT1( "FsdReadFile did not read a complete directory entry\n" ); DPRINT1 ("VfatReadFile did not read a complete directory entry\n");
break; break;
} }
if (IsDeletedEntry (&FatEntry, 0)) if (IsDeletedEntry (&FatEntry, 0))
@ -392,15 +398,17 @@ DPRINT("i=%d,j=%d,%d,%d\n",i,j,pEntry->Filename[i],FileName[i]);
if (nbFree == nbSlots) if (nbFree == nbSlots)
{ //use old slots { //use old slots
Offset = (i - nbSlots + 1) * sizeof (FATDirEntry); Offset = (i - nbSlots + 1) * sizeof (FATDirEntry);
status=FsdWriteFile(DeviceExt,&FileObject,Buffer status =
,sizeof(FATDirEntry)*nbSlots,Offset); VfatWriteFile (DeviceExt, &FileObject, Buffer,
DPRINT( "FsdWriteFile() returned: %x\n", status ); sizeof (FATDirEntry) * nbSlots, Offset);
DPRINT ("VfatWriteFile() returned: %x\n", status);
} }
else else
{ //write at end of directory { //write at end of directory
Offset = (i - nbFree) * sizeof (FATDirEntry); Offset = (i - nbFree) * sizeof (FATDirEntry);
status=FsdWriteFile(DeviceExt,&FileObject,Buffer status =
,sizeof(FATDirEntry)*(nbSlots+1),Offset); VfatWriteFile (DeviceExt, &FileObject, Buffer,
sizeof (FATDirEntry) * (nbSlots + 1), Offset);
} }
DPRINT ("write entry offset %d status=%x\n", Offset, status); DPRINT ("write entry offset %d status=%x\n", Offset, status);
newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB)); newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB));
@ -425,25 +433,27 @@ DPRINT("new : entry=%11.11s\n",pEntry->Filename);
vfat_wcsncpy (newFCB->PathName, PathFileName, MAX_PATH); vfat_wcsncpy (newFCB->PathName, PathFileName, MAX_PATH);
newFCB->ObjectName = newFCB->PathName + (PathFileName - FileName); newFCB->ObjectName = newFCB->PathName + (PathFileName - FileName);
newFCB->pDevExt = DeviceExt; newFCB->pDevExt = DeviceExt;
pFileObject->FsContext =(PVOID) &newFCB->NTRequiredFCB; pFileObject->FsContext = (PVOID)&newFCB->RFCB;
pFileObject->FsContext2 = newCCB; pFileObject->FsContext2 = newCCB;
if (RequestedOptions & FILE_DIRECTORY_FILE) if (RequestedOptions & FILE_DIRECTORY_FILE)
{ {
// create . and .. // create . and ..
memcpy (pEntry->Filename, ". ", 11); memcpy (pEntry->Filename, ". ", 11);
status=FsdWriteFile(DeviceExt,pFileObject,pEntry status =
,sizeof(FATDirEntry),0L); VfatWriteFile (DeviceExt, pFileObject, pEntry, sizeof (FATDirEntry),
pEntry->FirstCluster 0L);
=((VFATCCB *)(FileObject.FsContext2))->pFcb->entry.FirstCluster; pEntry->FirstCluster =
pEntry->FirstClusterHigh ((VFATCCB *) (FileObject.FsContext2))->pFcb->entry.FirstCluster;
=((VFATCCB *)(FileObject.FsContext2))->pFcb->entry.FirstClusterHigh; pEntry->FirstClusterHigh =
((VFATCCB *) (FileObject.FsContext2))->pFcb->entry.FirstClusterHigh;
memcpy (pEntry->Filename, ".. ", 11); memcpy (pEntry->Filename, ".. ", 11);
if (pEntry->FirstCluster == 1 && DeviceExt->FatType != FAT32) if (pEntry->FirstCluster == 1 && DeviceExt->FatType != FAT32)
pEntry->FirstCluster = 0; pEntry->FirstCluster = 0;
status=FsdWriteFile(DeviceExt,pFileObject,pEntry status =
,sizeof(FATDirEntry),sizeof(FATDirEntry)); VfatWriteFile (DeviceExt, pFileObject, pEntry, sizeof (FATDirEntry),
sizeof (FATDirEntry));
} }
FsdCloseFile(DeviceExt,&FileObject); VfatCloseFile (DeviceExt, &FileObject);
ExFreePool (Buffer); ExFreePool (Buffer);
DPRINT ("addentry ok\n"); DPRINT ("addentry ok\n");
return STATUS_SUCCESS; return STATUS_SUCCESS;

73
reactos/drivers/fs/vfat/fat.c
View file

@ -1,5 +1,5 @@
/* /*
* $Id: fat.c,v 1.8 2000/12/28 03:38:08 dwelch Exp $ * $Id: fat.c,v 1.9 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -13,7 +13,6 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <wchar.h> #include <wchar.h>
#include <ddk/cctypes.h>
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
@ -36,8 +35,9 @@ Fat32GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
Block = ExAllocatePool (NonPagedPool, 1024); Block = ExAllocatePool (NonPagedPool, 1024);
FATsector = CurrentCluster / (512 / sizeof (ULONG)); FATsector = CurrentCluster / (512 / sizeof (ULONG));
FATeis = CurrentCluster - (FATsector * (512 / sizeof (ULONG))); FATeis = CurrentCluster - (FATsector * (512 / sizeof (ULONG)));
VFATReadSectors(DeviceExt->StorageDevice VFATReadSectors (DeviceExt->StorageDevice,
,(ULONG)(DeviceExt->FATStart+FATsector), 1,(UCHAR*) Block); (ULONG) (DeviceExt->FATStart + FATsector), 1,
(UCHAR *) Block);
CurrentCluster = Block[FATeis]; CurrentCluster = Block[FATeis];
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff) if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
CurrentCluster = 0xffffffff; CurrentCluster = 0xffffffff;
@ -178,12 +178,13 @@ FAT32FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
PULONG Block; PULONG Block;
int i; int i;
Block = ExAllocatePool (NonPagedPool, BLOCKSIZE); Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
for(sector=0 for (sector = 0;
;sector< ((struct _BootSector32*)(DeviceExt->Boot))->FATSectors32 sector < ((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32;
;sector++) sector++)
{ {
VFATReadSectors(DeviceExt->StorageDevice VFATReadSectors (DeviceExt->StorageDevice,
,(ULONG)(DeviceExt->FATStart+sector), 1,(UCHAR*) Block); (ULONG) (DeviceExt->FATStart + sector), 1,
(UCHAR *) Block);
for (i = 0; i < 512; i++) for (i = 0; i < 512; i++)
{ {
@ -273,12 +274,13 @@ FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE); ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
Block = ExAllocatePool (NonPagedPool, BLOCKSIZE); Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
for(sector=0 for (sector = 0;
;sector< ((struct _BootSector32*)(DeviceExt->Boot))->FATSectors32 sector < ((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32;
;sector++) sector++)
{ {
VFATReadSectors(DeviceExt->StorageDevice VFATReadSectors (DeviceExt->StorageDevice,
,(ULONG)(DeviceExt->FATStart+sector), 1,(UCHAR*) Block); (ULONG) (DeviceExt->FATStart + sector), 1,
(UCHAR *) Block);
for (i = 0; i < 512; i++) for (i = 0; i < 512; i++)
{ {
@ -308,14 +310,12 @@ FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
{ {
CBlock[FATOffset] = NewValue; CBlock[FATOffset] = NewValue;
CBlock[FATOffset + 1] &= 0xf0; CBlock[FATOffset + 1] &= 0xf0;
CBlock[FATOffset + 1] CBlock[FATOffset + 1] |= (NewValue & 0xf00) >> 8;
|= (NewValue&0xf00)>>8;
} }
else else
{ {
CBlock[FATOffset] &= 0x0f; CBlock[FATOffset] &= 0x0f;
CBlock[FATOffset] CBlock[FATOffset] |= (NewValue & 0xf) << 4;
|= (NewValue&0xf)<<4;
CBlock[FATOffset + 1] = NewValue >> 4; CBlock[FATOffset + 1] = NewValue >> 4;
} }
/* Write the changed FAT sector(s) to disk */ /* Write the changed FAT sector(s) to disk */
@ -327,16 +327,14 @@ FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
DeviceExt->FATStart + FATsector DeviceExt->FATStart + FATsector
+ i * DeviceExt->Boot->FATSectors, + i * DeviceExt->Boot->FATSectors,
2, 2, CBlock + FATsector * 512);
CBlock+FATsector*512);
} }
else else
{ {
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
DeviceExt->FATStart + FATsector DeviceExt->FATStart + FATsector
+ i * DeviceExt->Boot->FATSectors, + i * DeviceExt->Boot->FATSectors,
1, 1, CBlock + FATsector * 512);
CBlock+FATsector*512);
} }
} }
} }
@ -366,9 +364,7 @@ FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
for (i = 0; i < DeviceExt->Boot->FATCount; i++) for (i = 0; i < DeviceExt->Boot->FATCount; i++)
{ {
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
Start, Start, 1, ((UCHAR *) Block) + FATsector * 512);
1,
((UCHAR *)Block)+FATsector*512);
Start += DeviceExt->Boot->FATSectors; Start += DeviceExt->Boot->FATSectors;
} }
} }
@ -392,19 +388,14 @@ DbgPrint("FAT32WriteCluster %u : %u\n",ClusterToWrite,NewValue);
FATeis = ClusterToWrite - (FATsector * 128); FATeis = ClusterToWrite - (FATsector * 128);
/* load sector, change value, then rewrite sector */ /* load sector, change value, then rewrite sector */
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
DeviceExt->FATStart+FATsector, DeviceExt->FATStart + FATsector, 1, (UCHAR *) Block);
1,
(UCHAR *)Block);
Block[FATeis] = NewValue; Block[FATeis] = NewValue;
/* Write the changed FAT sector to disk (all FAT's) */ /* Write the changed FAT sector to disk (all FAT's) */
Start = DeviceExt->FATStart + FATsector; Start = DeviceExt->FATStart + FATsector;
pBoot = (struct _BootSector32 *) DeviceExt->Boot; pBoot = (struct _BootSector32 *) DeviceExt->Boot;
for (i = 0; i < pBoot->FATCount; i++) for (i = 0; i < pBoot->FATCount; i++)
{ {
VFATWriteSectors(DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice, Start, 1, (UCHAR *) Block);
Start,
1,
(UCHAR *)Block);
Start += pBoot->FATSectors; Start += pBoot->FATSectors;
} }
ExFreePool (Block); ExFreePool (Block);
@ -444,8 +435,7 @@ GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
DeviceExt, CurrentCluster); DeviceExt, CurrentCluster);
/* Find out what was happening in the last cluster's AU */ /* Find out what was happening in the last cluster's AU */
LastCluster=GetNextCluster(DeviceExt, LastCluster = GetNextCluster (DeviceExt, CurrentCluster);
CurrentCluster);
/* Check to see if we must append or overwrite */ /* Check to see if we must append or overwrite */
if (LastCluster == 0xffffffff) if (LastCluster == 0xffffffff)
{ {
@ -490,14 +480,14 @@ GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
} }
ULONG ULONG
ClusterToSector(PDEVICE_EXTENSION DeviceExt, ClusterToSector (PDEVICE_EXTENSION DeviceExt, unsigned long Cluster)
unsigned long Cluster)
/* /*
* FUNCTION: Converts the cluster number to a sector number for this physical * FUNCTION: Converts the cluster number to a sector number for this physical
* device * device
*/ */
{ {
return DeviceExt->dataStart+((Cluster-2)*DeviceExt->Boot->SectorsPerCluster); return DeviceExt->dataStart +
((Cluster - 2) * DeviceExt->Boot->SectorsPerCluster);
} }
VOID VOID
@ -514,9 +504,7 @@ VFATLoadCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
Sector = ClusterToSector (DeviceExt, Cluster); Sector = ClusterToSector (DeviceExt, Cluster);
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
Sector, Sector, DeviceExt->Boot->SectorsPerCluster, Buffer);
DeviceExt->Boot->SectorsPerCluster,
Buffer);
DPRINT ("Finished VFATReadSectors\n"); DPRINT ("Finished VFATReadSectors\n");
} }
@ -533,8 +521,5 @@ VFATWriteCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
Sector = ClusterToSector (DeviceExt, Cluster); Sector = ClusterToSector (DeviceExt, Cluster);
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
Sector, Sector, DeviceExt->Boot->SectorsPerCluster, Buffer);
DeviceExt->Boot->SectorsPerCluster,
Buffer);
} }

73
reactos/drivers/fs/vfat/finfo.c
View file

@ -1,4 +1,4 @@
/* $Id: finfo.c,v 1.4 2000/09/12 10:12:13 jean Exp $ /* $Id: finfo.c,v 1.5 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -12,7 +12,6 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <wchar.h> #include <wchar.h>
#include <ddk/cctypes.h>
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
@ -21,7 +20,8 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
NTSTATUS FsdGetStandardInformation(PVFATFCB FCB, PDEVICE_OBJECT DeviceObject, NTSTATUS
VfatGetStandardInformation (PVFATFCB FCB, PDEVICE_OBJECT DeviceObject,
PFILE_STANDARD_INFORMATION StandardInfo) PFILE_STANDARD_INFORMATION StandardInfo)
/* /*
* FUNCTION: Retrieve the standard file information * FUNCTION: Retrieve the standard file information
@ -45,19 +45,24 @@ NTSTATUS FsdGetStandardInformation(PVFATFCB FCB, PDEVICE_OBJECT DeviceObject,
DeviceExtension->BytesPerCluster; DeviceExtension->BytesPerCluster;
StandardInfo->AllocationSize = RtlConvertUlongToLargeInteger (AllocSize); StandardInfo->AllocationSize = RtlConvertUlongToLargeInteger (AllocSize);
StandardInfo->EndOfFile = RtlConvertUlongToLargeInteger(FCB->entry.FileSize); StandardInfo->EndOfFile =
RtlConvertUlongToLargeInteger (FCB->entry.FileSize);
StandardInfo->NumberOfLinks = 0; StandardInfo->NumberOfLinks = 0;
StandardInfo->DeletePending = FALSE; StandardInfo->DeletePending = FALSE;
if((FCB->entry.Attrib & 0x10)>0) { if ((FCB->entry.Attrib & 0x10) > 0)
{
StandardInfo->Directory = TRUE; StandardInfo->Directory = TRUE;
} else { }
else
{
StandardInfo->Directory = FALSE; StandardInfo->Directory = FALSE;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS FsdSetPositionInformation(PFILE_OBJECT FileObject, NTSTATUS
VfatSetPositionInformation (PFILE_OBJECT FileObject,
PVFATFCB FCB, PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject, PDEVICE_OBJECT DeviceObject,
PFILE_POSITION_INFORMATION PositionInfo) PFILE_POSITION_INFORMATION PositionInfo)
@ -72,12 +77,13 @@ NTSTATUS FsdSetPositionInformation(PFILE_OBJECT FileObject,
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS FsdGetPositionInformation(PFILE_OBJECT FileObject, NTSTATUS
VfatGetPositionInformation (PFILE_OBJECT FileObject,
PVFATFCB FCB, PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject, PDEVICE_OBJECT DeviceObject,
PFILE_POSITION_INFORMATION PositionInfo) PFILE_POSITION_INFORMATION PositionInfo)
{ {
DPRINT("FsdGetPositionInformation()\n"); DPRINT ("VfatGetPositionInformation()\n");
memcpy (&PositionInfo->CurrentByteOffset, &FileObject->CurrentByteOffset, memcpy (&PositionInfo->CurrentByteOffset, &FileObject->CurrentByteOffset,
sizeof (LARGE_INTEGER)); sizeof (LARGE_INTEGER));
@ -85,12 +91,13 @@ NTSTATUS FsdGetPositionInformation(PFILE_OBJECT FileObject,
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS FsdGetBasicInformation(PFILE_OBJECT FileObject, NTSTATUS
VfatGetBasicInformation (PFILE_OBJECT FileObject,
PVFATFCB FCB, PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject, PDEVICE_OBJECT DeviceObject,
PFILE_BASIC_INFORMATION BasicInfo) PFILE_BASIC_INFORMATION BasicInfo)
{ {
DPRINT("FsdGetBasicInformation()\n"); DPRINT ("VfatGetBasicInformation()\n");
FsdDosDateTimeToFileTime (FCB->entry.CreationDate, FCB->entry.CreationTime, FsdDosDateTimeToFileTime (FCB->entry.CreationDate, FCB->entry.CreationTime,
&BasicInfo->CreationTime); &BasicInfo->CreationTime);
@ -109,7 +116,8 @@ NTSTATUS FsdGetBasicInformation(PFILE_OBJECT FileObject,
} }
NTSTATUS FsdSetDispositionInformation(PFILE_OBJECT FileObject, NTSTATUS
VfatSetDispositionInformation (PFILE_OBJECT FileObject,
PVFATFCB FCB, PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject, PDEVICE_OBJECT DeviceObject,
PFILE_DISPOSITION_INFORMATION DispositionInfo) PFILE_DISPOSITION_INFORMATION DispositionInfo)
@ -122,7 +130,8 @@ NTSTATUS FsdSetDispositionInformation(PFILE_OBJECT FileObject,
} }
NTSTATUS STDCALL FsdQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatQueryInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Retrieve the specified file information * FUNCTION: Retrieve the specified file information
*/ */
@ -156,21 +165,18 @@ NTSTATUS STDCALL FsdQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
SystemBuffer = Irp->UserBuffer; SystemBuffer = Irp->UserBuffer;
// SystemBuffer = Irp->AssociatedIrp.SystemBuffer; // SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
switch(FileInformationClass) { switch (FileInformationClass)
{
case FileStandardInformation: case FileStandardInformation:
RC = FsdGetStandardInformation(FCB, DeviceObject, SystemBuffer); RC = VfatGetStandardInformation (FCB, DeviceObject, SystemBuffer);
break; break;
case FilePositionInformation: case FilePositionInformation:
RC = FsdGetPositionInformation(FileObject, RC = VfatGetPositionInformation (FileObject,
FCB, FCB, DeviceObject, SystemBuffer);
DeviceObject,
SystemBuffer);
break; break;
case FileBasicInformation: case FileBasicInformation:
RC = FsdGetBasicInformation(FileObject, RC = VfatGetBasicInformation (FileObject,
FCB, FCB, DeviceObject, SystemBuffer);
DeviceObject,
SystemBuffer);
break; break;
default: default:
RC = STATUS_NOT_IMPLEMENTED; RC = STATUS_NOT_IMPLEMENTED;
@ -183,7 +189,8 @@ NTSTATUS STDCALL FsdQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
return RC; return RC;
} }
NTSTATUS STDCALL VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatSetInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Retrieve the specified file information * FUNCTION: Retrieve the specified file information
*/ */
@ -200,8 +207,7 @@ NTSTATUS STDCALL VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
assert (DeviceObject != NULL); assert (DeviceObject != NULL);
assert (Irp != NULL); assert (Irp != NULL);
DPRINT("FsdSetInformation(DeviceObject %x, Irp %x)\n", DPRINT ("VfatSetInformation(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
DeviceObject,Irp);
/* INITIALIZATION */ /* INITIALIZATION */
Stack = IoGetCurrentIrpStackLocation (Irp); Stack = IoGetCurrentIrpStackLocation (Irp);
@ -222,16 +228,12 @@ NTSTATUS STDCALL VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
switch (FileInformationClass) switch (FileInformationClass)
{ {
case FilePositionInformation: case FilePositionInformation:
RC = FsdSetPositionInformation(FileObject, RC = VfatSetPositionInformation (FileObject,
FCB, FCB, DeviceObject, SystemBuffer);
DeviceObject,
SystemBuffer);
break; break;
case FileDispositionInformation: case FileDispositionInformation:
RC = FsdSetDispositionInformation(FileObject, RC = VfatSetDispositionInformation (FileObject,
FCB, FCB, DeviceObject, SystemBuffer);
DeviceObject,
SystemBuffer);
break; break;
default: default:
RC = STATUS_NOT_IMPLEMENTED; RC = STATUS_NOT_IMPLEMENTED;
@ -243,6 +245,3 @@ NTSTATUS STDCALL VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
return RC; return RC;
} }

79
reactos/drivers/fs/vfat/iface.c
View file

@ -1,4 +1,4 @@
/* $Id: iface.c,v 1.44 2000/12/29 13:45:01 ekohl Exp $ /* $Id: iface.c,v 1.45 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -8,11 +8,15 @@
* UPDATE HISTORY: * UPDATE HISTORY:
* ?? Created * ?? Created
* 24-10-1998 Fixed bugs in long filename support * 24-10-1998 Fixed bugs in long filename support
* Fixed a bug that prevented unsuccessful file open requests being reported * Fixed a bug that prevented unsuccessful file open requests
* Now works with long filenames that span over a sector boundary * being reported
* Now works with long filenames that span over a sector
* boundary
* 28-10-1998 Reads entire FAT into memory * 28-10-1998 Reads entire FAT into memory
* VFatReadSector modified to read in more than one sector at a time * VFatReadSector modified to read in more than one sector at a
* 7-11-1998 Fixed bug that assumed that directory data could be fragmented * time
* 7-11-1998 Fixed bug that assumed that directory data could be
* fragmented
* 8-12-1998 Added FAT32 support * 8-12-1998 Added FAT32 support
* Added initial writability functions * Added initial writability functions
* WARNING: DO NOT ATTEMPT TO TEST WRITABILITY FUNCTIONS!!! * WARNING: DO NOT ATTEMPT TO TEST WRITABILITY FUNCTIONS!!!
@ -36,7 +40,8 @@ static PDRIVER_OBJECT VfatDriverObject;
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
BOOLEAN FsdHasFileSystem(PDEVICE_OBJECT DeviceToMount) BOOLEAN
VfatHasFileSystem (PDEVICE_OBJECT DeviceToMount)
/* /*
* FUNCTION: Tests if the device contains a filesystem that can be mounted * FUNCTION: Tests if the device contains a filesystem that can be mounted
* by this fsd * by this fsd
@ -60,8 +65,8 @@ BOOLEAN FsdHasFileSystem(PDEVICE_OBJECT DeviceToMount)
return (FALSE); return (FALSE);
} }
NTSTATUS FsdMountDevice(PDEVICE_EXTENSION DeviceExt, NTSTATUS
PDEVICE_OBJECT DeviceToMount) VfatMountDevice (PDEVICE_EXTENSION DeviceExt, PDEVICE_OBJECT DeviceToMount)
/* /*
* FUNCTION: Mounts the device * FUNCTION: Mounts the device
*/ */
@ -79,8 +84,10 @@ NTSTATUS FsdMountDevice(PDEVICE_EXTENSION DeviceExt,
DeviceExt->rootDirectorySectors = DeviceExt->rootDirectorySectors =
(DeviceExt->Boot->RootEntries * 32) / DeviceExt->Boot->BytesPerSector; (DeviceExt->Boot->RootEntries * 32) / DeviceExt->Boot->BytesPerSector;
DeviceExt->rootStart = DeviceExt->rootStart =
DeviceExt->FATStart+DeviceExt->Boot->FATCount*DeviceExt->Boot->FATSectors; DeviceExt->FATStart +
DeviceExt->dataStart=DeviceExt->rootStart+DeviceExt->rootDirectorySectors; DeviceExt->Boot->FATCount * DeviceExt->Boot->FATSectors;
DeviceExt->dataStart =
DeviceExt->rootStart + DeviceExt->rootDirectorySectors;
DeviceExt->FATEntriesPerSector = DeviceExt->Boot->BytesPerSector / 32; DeviceExt->FATEntriesPerSector = DeviceExt->Boot->BytesPerSector / 32;
DeviceExt->BytesPerCluster = DeviceExt->Boot->SectorsPerCluster * DeviceExt->BytesPerCluster = DeviceExt->Boot->SectorsPerCluster *
DeviceExt->Boot->BytesPerSector; DeviceExt->Boot->BytesPerSector;
@ -89,7 +96,10 @@ NTSTATUS FsdMountDevice(PDEVICE_EXTENSION DeviceExt,
{ {
DeviceExt->FatType = FAT12; DeviceExt->FatType = FAT12;
} }
else if (strncmp(((struct _BootSector32 *)(DeviceExt->Boot))->SysType,"FAT32",5)==0) else
if (strncmp
(((struct _BootSector32 *) (DeviceExt->Boot))->SysType, "FAT32",
5) == 0)
{ {
DeviceExt->FatType = FAT32; DeviceExt->FatType = FAT32;
DeviceExt->rootDirectorySectors = DeviceExt->Boot->SectorsPerCluster; DeviceExt->rootDirectorySectors = DeviceExt->Boot->SectorsPerCluster;
@ -107,13 +117,17 @@ NTSTATUS FsdMountDevice(PDEVICE_EXTENSION DeviceExt,
// because on a 8GB partition with 2 KO clusters, the fat = 8 MO // because on a 8GB partition with 2 KO clusters, the fat = 8 MO
if (DeviceExt->FatType != FAT32) if (DeviceExt->FatType != FAT32)
{ {
DeviceExt->FAT = ExAllocatePool(NonPagedPool, BLOCKSIZE*DeviceExt->Boot->FATSectors); DeviceExt->FAT =
VFATReadSectors(DeviceToMount, DeviceExt->FATStart, DeviceExt->Boot->FATSectors, (UCHAR *)DeviceExt->FAT); ExAllocatePool (NonPagedPool,
BLOCKSIZE * DeviceExt->Boot->FATSectors);
VFATReadSectors (DeviceToMount, DeviceExt->FATStart,
DeviceExt->Boot->FATSectors, (UCHAR *) DeviceExt->FAT);
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS FsdMount(PDEVICE_OBJECT DeviceToMount) NTSTATUS
VfatMount (PDEVICE_OBJECT DeviceToMount)
/* /*
* FUNCTION: Mount the filesystem * FUNCTION: Mount the filesystem
*/ */
@ -123,16 +137,12 @@ NTSTATUS FsdMount(PDEVICE_OBJECT DeviceToMount)
IoCreateDevice (VfatDriverObject, IoCreateDevice (VfatDriverObject,
sizeof (DEVICE_EXTENSION), sizeof (DEVICE_EXTENSION),
NULL, NULL, FILE_DEVICE_FILE_SYSTEM, 0, FALSE, &DeviceObject);
FILE_DEVICE_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO; DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO;
DeviceExt = (PVOID) DeviceObject->DeviceExtension; DeviceExt = (PVOID) DeviceObject->DeviceExtension;
// use same vpb as device disk // use same vpb as device disk
DeviceObject->Vpb = DeviceToMount->Vpb; DeviceObject->Vpb = DeviceToMount->Vpb;
FsdMountDevice(DeviceExt,DeviceToMount); VfatMountDevice (DeviceExt, DeviceToMount);
DeviceObject->Vpb->Flags |= VPB_MOUNTED; DeviceObject->Vpb->Flags |= VPB_MOUNTED;
DeviceExt->StorageDevice = IoAttachDeviceToDeviceStack (DeviceObject, DeviceExt->StorageDevice = IoAttachDeviceToDeviceStack (DeviceObject,
DeviceToMount); DeviceToMount);
@ -156,7 +166,8 @@ NTSTATUS FsdMount(PDEVICE_OBJECT DeviceToMount)
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS STDCALL FsdFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatFileSystemControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: File system control * FUNCTION: File system control
*/ */
@ -171,10 +182,10 @@ NTSTATUS STDCALL FsdFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* FIXME: should make sure that this is actually a mount request! */ /* FIXME: should make sure that this is actually a mount request! */
if (FsdHasFileSystem(DeviceToMount)) if (VfatHasFileSystem (DeviceToMount))
{ {
DPRINT ("VFAT: Recognized volume\n"); DPRINT ("VFAT: Recognized volume\n");
Status = FsdMount(DeviceToMount); Status = VfatMount (DeviceToMount);
} }
else else
{ {
@ -189,8 +200,8 @@ NTSTATUS STDCALL FsdFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
return (Status); return (Status);
} }
NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT _DriverObject, NTSTATUS STDCALL
PUNICODE_STRING RegistryPath) DriverEntry (PDRIVER_OBJECT _DriverObject, PUNICODE_STRING RegistryPath)
/* /*
* FUNCTION: Called by the system to initalize the driver * FUNCTION: Called by the system to initalize the driver
* ARGUMENTS: * ARGUMENTS:
@ -216,22 +227,21 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT _DriverObject,
} }
DeviceObject->Flags = DO_DIRECT_IO; DeviceObject->Flags = DO_DIRECT_IO;
VfatDriverObject->MajorFunction[IRP_MJ_CLOSE] = FsdClose; VfatDriverObject->MajorFunction[IRP_MJ_CLOSE] = VfatClose;
VfatDriverObject->MajorFunction[IRP_MJ_CREATE] = FsdCreate; VfatDriverObject->MajorFunction[IRP_MJ_CREATE] = VfatCreate;
VfatDriverObject->MajorFunction[IRP_MJ_READ] = FsdRead; VfatDriverObject->MajorFunction[IRP_MJ_READ] = VfatRead;
VfatDriverObject->MajorFunction[IRP_MJ_WRITE] = FsdWrite; VfatDriverObject->MajorFunction[IRP_MJ_WRITE] = VfatWrite;
VfatDriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = VfatDriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
FsdFileSystemControl; VfatFileSystemControl;
VfatDriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = VfatDriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
FsdQueryInformation; VfatQueryInformation;
VfatDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = VfatDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
VfatSetInformation; VfatSetInformation;
VfatDriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = VfatDriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
FsdDirectoryControl; VfatDirectoryControl;
VfatDriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = VfatDriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
VfatQueryVolumeInformation; VfatQueryVolumeInformation;
VfatDriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = VfatDriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = VfatShutdown;
VfatShutdown;
VfatDriverObject->DriverUnload = NULL; VfatDriverObject->DriverUnload = NULL;
@ -239,4 +249,3 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT _DriverObject,
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }

77
reactos/drivers/fs/vfat/rw.c
View file

@ -1,4 +1,4 @@
/* $Id: rw.c,v 1.11 2000/12/05 17:12:16 jean Exp $ /* $Id: rw.c,v 1.12 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -12,7 +12,6 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <wchar.h> #include <wchar.h>
#include <ddk/cctypes.h>
#include <ntos/minmax.h> #include <ntos/minmax.h>
#define NDEBUG #define NDEBUG
@ -22,9 +21,9 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
NTSTATUS FsdReadFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
PVOID Buffer, ULONG Length, ULONG ReadOffset, VfatReadFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PULONG LengthRead) PVOID Buffer, ULONG Length, ULONG ReadOffset, PULONG LengthRead)
/* /*
* FUNCTION: Reads data from a file * FUNCTION: Reads data from a file
*/ */
@ -70,15 +69,16 @@ CHECKPOINT;
*LengthRead = 0; *LengthRead = 0;
/* FIXME: optimize by remembering the last cluster read and using if possible */ /* FIXME: optimize by remembering the last cluster read and using if possible */
Temp = ExAllocatePool (NonPagedPool, DeviceExt->BytesPerCluster); Temp = ExAllocatePool (NonPagedPool, DeviceExt->BytesPerCluster);
if(!Temp) return STATUS_UNSUCCESSFUL; if (!Temp)
return STATUS_UNSUCCESSFUL;
if (FirstCluster == 1) if (FirstCluster == 1)
{ //root of FAT16 or FAT12 { //root of FAT16 or FAT12
CurrentCluster = DeviceExt->rootStart + ReadOffset CurrentCluster = DeviceExt->rootStart + ReadOffset
/ (DeviceExt->BytesPerCluster) * DeviceExt->Boot->SectorsPerCluster; / (DeviceExt->BytesPerCluster) * DeviceExt->Boot->SectorsPerCluster;
} }
else else
for (FileOffset=0; FileOffset < ReadOffset / DeviceExt->BytesPerCluster for (FileOffset = 0; FileOffset < ReadOffset / DeviceExt->BytesPerCluster;
; FileOffset++) FileOffset++)
{ {
CurrentCluster = GetNextCluster (DeviceExt, CurrentCluster); CurrentCluster = GetNextCluster (DeviceExt, CurrentCluster);
} }
@ -89,8 +89,7 @@ CHECKPOINT;
{ {
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
CurrentCluster += DeviceExt->Boot->SectorsPerCluster; CurrentCluster += DeviceExt->Boot->SectorsPerCluster;
} }
else else
@ -115,8 +114,7 @@ CHECKPOINT;
{ {
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Buffer);
Buffer);
CurrentCluster += DeviceExt->Boot->SectorsPerCluster; CurrentCluster += DeviceExt->Boot->SectorsPerCluster;
} }
else else
@ -142,8 +140,7 @@ CHECKPOINT;
{ {
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
CurrentCluster += DeviceExt->Boot->SectorsPerCluster; CurrentCluster += DeviceExt->Boot->SectorsPerCluster;
} }
else else
@ -157,7 +154,8 @@ CHECKPOINT;
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
VfatWriteFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PVOID Buffer, ULONG Length, ULONG WriteOffset) PVOID Buffer, ULONG Length, ULONG WriteOffset)
/* /*
* FUNCTION: Writes data to file * FUNCTION: Writes data to file
@ -224,7 +222,8 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
FileOffset < WriteOffset / DeviceExt->BytesPerCluster; FileOffset < WriteOffset / DeviceExt->BytesPerCluster;
FileOffset++) FileOffset++)
{ {
CurrentCluster = GetNextWriteCluster(DeviceExt,CurrentCluster); CurrentCluster =
GetNextWriteCluster (DeviceExt, CurrentCluster);
} }
} }
CHECKPOINT; CHECKPOINT;
@ -245,8 +244,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
{ {
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
} }
else else
{ {
@ -255,8 +253,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
/* Overwrite the last parts of the data as necessary */ /* Overwrite the last parts of the data as necessary */
memcpy (Temp + (WriteOffset % DeviceExt->BytesPerCluster), memcpy (Temp + (WriteOffset % DeviceExt->BytesPerCluster),
Buffer, Buffer, TempLength);
TempLength);
/* Write the cluster back */ /* Write the cluster back */
Length2 -= TempLength; Length2 -= TempLength;
@ -264,8 +261,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
{ {
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
CurrentCluster += DeviceExt->Boot->SectorsPerCluster; CurrentCluster += DeviceExt->Boot->SectorsPerCluster;
} }
else else
@ -293,8 +289,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
{ {
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Buffer);
Buffer);
CurrentCluster += DeviceExt->Boot->SectorsPerCluster; CurrentCluster += DeviceExt->Boot->SectorsPerCluster;
} }
else else
@ -323,8 +318,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
{ {
VFATReadSectors (DeviceExt->StorageDevice, VFATReadSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
} }
else else
{ {
@ -336,8 +330,7 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
{ {
VFATWriteSectors (DeviceExt->StorageDevice, VFATWriteSectors (DeviceExt->StorageDevice,
CurrentCluster, CurrentCluster,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster, Temp);
Temp);
} }
else else
{ {
@ -350,11 +343,9 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
/* set dates and times */ /* set dates and times */
KeQuerySystemTime (&SystemTime); KeQuerySystemTime (&SystemTime);
ExSystemTimeToLocalTime (&SystemTime, ExSystemTimeToLocalTime (&SystemTime, &LocalTime);
&LocalTime);
FsdFileTimeToDosDateTime ((TIME *) & LocalTime, FsdFileTimeToDosDateTime ((TIME *) & LocalTime,
&Fcb->entry.UpdateDate, &Fcb->entry.UpdateDate, &Fcb->entry.UpdateTime);
&Fcb->entry.UpdateTime);
Fcb->entry.AccessDate = Fcb->entry.UpdateDate; Fcb->entry.AccessDate = Fcb->entry.UpdateDate;
if (Fcb->entry.FileSize < WriteOffset + Length if (Fcb->entry.FileSize < WriteOffset + Length
@ -371,7 +362,8 @@ NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS STDCALL FsdWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatWrite (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Write to a file * FUNCTION: Write to a file
*/ */
@ -384,13 +376,13 @@ NTSTATUS STDCALL FsdWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
PDEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension; PDEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
NTSTATUS Status; NTSTATUS Status;
DPRINT("FsdWrite(DeviceObject %x Irp %x)\n",DeviceObject,Irp); DPRINT ("VfatWrite(DeviceObject %x Irp %x)\n", DeviceObject, Irp);
Length = Stack->Parameters.Write.Length; Length = Stack->Parameters.Write.Length;
Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress); Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
Offset = Stack->Parameters.Write.ByteOffset.u.LowPart; Offset = Stack->Parameters.Write.ByteOffset.u.LowPart;
Status = FsdWriteFile(DeviceExt,FileObject,Buffer,Length,Offset); Status = VfatWriteFile (DeviceExt, FileObject, Buffer, Length, Offset);
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = Length; Irp->IoStatus.Information = Length;
@ -399,7 +391,8 @@ NTSTATUS STDCALL FsdWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
return (Status); return (Status);
} }
NTSTATUS STDCALL FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatRead (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Read from a file * FUNCTION: Read from a file
*/ */
@ -414,7 +407,7 @@ NTSTATUS STDCALL FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
ULONG LengthRead; ULONG LengthRead;
PVFATFCB Fcb; PVFATFCB Fcb;
DPRINT("FsdRead(DeviceObject %x, Irp %x)\n",DeviceObject,Irp); DPRINT ("VfatRead(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
/* Precondition / Initialization */ /* Precondition / Initialization */
assert (Irp != NULL); assert (Irp != NULL);
@ -437,12 +430,8 @@ NTSTATUS STDCALL FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
} }
else else
{ {
Status = FsdReadFile(DeviceExt, Status = VfatReadFile (DeviceExt,
FileObject, FileObject, Buffer, Length, Offset, &LengthRead);
Buffer,
Length,
Offset,
&LengthRead);
} }
Irp->IoStatus.Status = Status; Irp->IoStatus.Status = Status;
@ -451,5 +440,3 @@ NTSTATUS STDCALL FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
return (Status); return (Status);
} }

3
reactos/drivers/fs/vfat/string.c
View file

@ -1,4 +1,4 @@
/* $Id: string.c,v 1.3 2000/06/29 23:35:51 dwelch Exp $ /* $Id: string.c,v 1.4 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -12,7 +12,6 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <wchar.h> #include <wchar.h>
#include <ddk/cctypes.h>
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>

175
reactos/drivers/fs/vfat/vfat.h
View file

@ -1,4 +1,6 @@
/* $Id: vfat.h,v 1.18 2000/12/29 13:45:01 ekohl Exp $ */ /* $Id: vfat.h,v 1.19 2000/12/29 23:17:12 dwelch Exp $ */
#include <ddk/ntifs.h>
struct _BootSector { struct _BootSector {
unsigned char magic0, res0, magic1; unsigned char magic0, res0, magic1;
@ -85,34 +87,17 @@ typedef struct
ULONG BytesPerCluster; ULONG BytesPerCluster;
ULONG FatType; ULONG FatType;
unsigned char* FAT; unsigned char* FAT;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION; } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
typedef struct _FSRTL_COMMON_FCB_HEADER{
char IsFastIoPossible;//is char the realtype ?
ERESOURCE Resource;
ERESOURCE PagingIoResource;
ULONG Flags;// is long the real type ?
LARGE_INTEGER AllocationSize;
LARGE_INTEGER FileSize;
LARGE_INTEGER ValidDataLength;
// other fields ??
} FSRTL_COMMON_FCB_HEADER;
typedef struct _SFsdNTRequiredFCB {
FSRTL_COMMON_FCB_HEADER CommonFCBHeader;
SECTION_OBJECT_POINTERS SectionObject;
ERESOURCE MainResource;
ERESOURCE PagingIoResource;
} SFsdNTRequiredFCB, *PtrSFsdNTRequiredFCB;
typedef struct _VFATFCB typedef struct _VFATFCB
{ {
SFsdNTRequiredFCB NTRequiredFCB; REACTOS_COMMON_FCB_HEADER RFCB;
FATDirEntry entry; FATDirEntry entry;
WCHAR *ObjectName; // point on filename (250 chars max) in PathName /* point on filename (250 chars max) in PathName */
WCHAR PathName[MAX_PATH];// path+filename 260 max WCHAR *ObjectName;
long RefCount; /* path+filename 260 max */
WCHAR PathName[MAX_PATH];
LONG RefCount;
PDEVICE_EXTENSION pDevExt; PDEVICE_EXTENSION pDevExt;
LIST_ENTRY FcbListEntry; LIST_ENTRY FcbListEntry;
struct _VFATFCB* parentFcb; struct _VFATFCB* parentFcb;
@ -124,8 +109,10 @@ typedef struct _VFATCCB
LIST_ENTRY NextCCB; LIST_ENTRY NextCCB;
PFILE_OBJECT PtrFileObject; PFILE_OBJECT PtrFileObject;
LARGE_INTEGER CurrentByteOffset; LARGE_INTEGER CurrentByteOffset;
ULONG StartSector; // for DirectoryControl /* for DirectoryControl */
ULONG StartEntry; //for DirectoryControl ULONG StartSector;
/* for DirectoryControl */
ULONG StartEntry;
// PSTRING DirectorySearchPattern;// for DirectoryControl ? // PSTRING DirectorySearchPattern;// for DirectoryControl ?
} VFATCCB, *PVFATCCB; } VFATCCB, *PVFATCCB;
@ -147,97 +134,135 @@ typedef struct __DOSDATE
WORD Year:5; WORD Year:5;
} DOSDATE, *PDOSDATE; } DOSDATE, *PDOSDATE;
// functions called by i/o manager : /* functions called by i/o manager : */
NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT _DriverObject,PUNICODE_STRING RegistryPath); NTSTATUS STDCALL
NTSTATUS STDCALL FsdDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp); DriverEntry(PDRIVER_OBJECT _DriverObject,PUNICODE_STRING RegistryPath);
NTSTATUS STDCALL FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL
NTSTATUS STDCALL FsdWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp); VfatDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL FsdCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL
NTSTATUS STDCALL FsdClose(PDEVICE_OBJECT DeviceObject, PIRP Irp); VfatRead(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL FsdFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL
NTSTATUS STDCALL FsdQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp); VfatWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL
VfatCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL
VfatClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL
VfatFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS STDCALL
VfatQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);
// internal functions in blockdev.c /* internal functions in blockdev.c */
BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN
VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN ULONG SectorCount, IN ULONG SectorCount,
IN UCHAR* Buffer); IN UCHAR* Buffer);
BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN
VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN ULONG SectorCount, IN ULONG SectorCount,
IN UCHAR* Buffer); IN UCHAR* Buffer);
//internal functions in dir.c : /* internal functions in dir.c : */
BOOL FsdDosDateTimeToFileTime(WORD wDosDate,WORD wDosTime, TIME *FileTime); BOOL FsdDosDateTimeToFileTime(WORD wDosDate,WORD wDosTime, TIME *FileTime);
BOOL FsdFileTimeToDosDateTime(TIME *FileTime,WORD *pwDosDate,WORD *pwDosTime); BOOL FsdFileTimeToDosDateTime(TIME *FileTime,WORD *pwDosDate,WORD *pwDosTime);
//internal functions in iface.c : /* internal functions in iface.c : */
NTSTATUS FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb, NTSTATUS
FindFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb,
PVFATFCB Parent, PWSTR FileToFind,ULONG *StartSector,ULONG *Entry); PVFATFCB Parent, PWSTR FileToFind,ULONG *StartSector,ULONG *Entry);
NTSTATUS FsdCloseFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject); NTSTATUS
NTSTATUS FsdGetStandardInformation(PVFATFCB FCB, PDEVICE_OBJECT DeviceObject, VfatCloseFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject);
NTSTATUS
VfatGetStandardInformation(PVFATFCB FCB, PDEVICE_OBJECT DeviceObject,
PFILE_STANDARD_INFORMATION StandardInfo); PFILE_STANDARD_INFORMATION StandardInfo);
NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
VfatOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PWSTR FileName); PWSTR FileName);
NTSTATUS FsdReadFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
VfatReadFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PVOID Buffer, ULONG Length, ULONG ReadOffset, PVOID Buffer, ULONG Length, ULONG ReadOffset,
PULONG LengthRead); PULONG LengthRead);
NTSTATUS FsdWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, NTSTATUS
VfatWriteFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
PVOID Buffer, ULONG Length, ULONG WriteOffset); PVOID Buffer, ULONG Length, ULONG WriteOffset);
ULONG GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster); ULONG
BOOLEAN IsDeletedEntry(PVOID Block, ULONG Offset); GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster);
BOOLEAN IsLastEntry(PVOID Block, ULONG Offset); BOOLEAN
wchar_t * vfat_wcsncpy(wchar_t * dest, const wchar_t *src,size_t wcount); IsDeletedEntry(PVOID Block, ULONG Offset);
void VFATWriteCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster); BOOLEAN
IsLastEntry(PVOID Block, ULONG Offset);
//internal functions in dirwr.c wchar_t*
NTSTATUS addEntry(PDEVICE_EXTENSION DeviceExt vfat_wcsncpy(wchar_t * dest, const wchar_t *src,size_t wcount);
,PFILE_OBJECT pFileObject,ULONG RequestedOptions,UCHAR ReqAttr); VOID
NTSTATUS updEntry(PDEVICE_EXTENSION DeviceExt,PFILE_OBJECT pFileObject); VFATWriteCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster);
/* internal functions in dirwr.c */
NTSTATUS
addEntry(PDEVICE_EXTENSION DeviceExt,
PFILE_OBJECT pFileObject,ULONG RequestedOptions,UCHAR ReqAttr);
NTSTATUS
updEntry(PDEVICE_EXTENSION DeviceExt,PFILE_OBJECT pFileObject);
/* /*
* String functions * String functions
*/ */
void RtlAnsiToUnicode(PWSTR Dest, PCH Source, ULONG Length); VOID
void RtlCatAnsiToUnicode(PWSTR Dest, PCH Source, ULONG Length); RtlAnsiToUnicode(PWSTR Dest, PCH Source, ULONG Length);
void vfat_initstr(wchar_t *wstr, ULONG wsize); VOID
wchar_t * vfat_wcsncat(wchar_t * dest, const wchar_t * src,size_t wstart, size_t wcount); RtlCatAnsiToUnicode(PWSTR Dest, PCH Source, ULONG Length);
wchar_t * vfat_wcsncpy(wchar_t * dest, const wchar_t *src,size_t wcount); VOID
wchar_t * vfat_movstr(wchar_t *src, ULONG dpos, ULONG spos, ULONG len); vfat_initstr(wchar_t *wstr, ULONG wsize);
BOOLEAN wstrcmpi(PWSTR s1, PWSTR s2); wchar_t*
BOOLEAN wstrcmpjoki(PWSTR s1, PWSTR s2); vfat_wcsncat(wchar_t * dest, const wchar_t * src,size_t wstart, size_t wcount);
wchar_t*
vfat_wcsncpy(wchar_t * dest, const wchar_t *src,size_t wcount);
wchar_t*
vfat_movstr(wchar_t *src, ULONG dpos, ULONG spos, ULONG len);
BOOLEAN
wstrcmpi(PWSTR s1, PWSTR s2);
BOOLEAN
wstrcmpjoki(PWSTR s1, PWSTR s2);
/* /*
* functions from fat.c * functions from fat.c
*/ */
ULONG ClusterToSector(PDEVICE_EXTENSION DeviceExt, ULONG Cluster); ULONG
ULONG GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster); ClusterToSector(PDEVICE_EXTENSION DeviceExt, ULONG Cluster);
VOID VFATLoadCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster); ULONG
ULONG FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt); GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster);
ULONG FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt); VOID
ULONG FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt); VFATLoadCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster);
ULONG
FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt);
ULONG
FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt);
ULONG
FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt);
/* /*
* functions from volume.c * functions from volume.c
*/ */
NTSTATUS STDCALL VfatQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL
VfatQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);
/* /*
* functions from finfo.c * functions from finfo.c
*/ */
NTSTATUS STDCALL VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL
VfatSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);
/* /*
* From create.c * From create.c
*/ */
NTSTATUS ReadVolumeLabel(PDEVICE_EXTENSION DeviceExt, PVPB Vpb); NTSTATUS
ReadVolumeLabel(PDEVICE_EXTENSION DeviceExt, PVPB Vpb);
/* /*
* functions from shutdown.c * functions from shutdown.c
*/ */
NTSTATUS STDCALL VfatShutdown(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS STDCALL VfatShutdown(PDEVICE_OBJECT DeviceObject, PIRP Irp);

24
reactos/drivers/fs/vfat/volume.c
View file

@ -1,4 +1,4 @@
/* $Id: volume.c,v 1.4 2000/09/12 10:12:13 jean Exp $ /* $Id: volume.c,v 1.5 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -11,7 +11,6 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <wchar.h> #include <wchar.h>
#include <ddk/cctypes.h>
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
@ -20,7 +19,8 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
NTSTATUS FsdGetFsVolumeInformation(PFILE_OBJECT FileObject, NTSTATUS
FsdGetFsVolumeInformation (PFILE_OBJECT FileObject,
PVFATFCB FCB, PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject, PDEVICE_OBJECT DeviceObject,
PFILE_FS_VOLUME_INFORMATION FsVolumeInfo) PFILE_FS_VOLUME_INFORMATION FsVolumeInfo)
@ -47,7 +47,8 @@ NTSTATUS FsdGetFsVolumeInformation(PFILE_OBJECT FileObject,
} }
NTSTATUS FsdGetFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo) NTSTATUS
FsdGetFsAttributeInformation (PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo)
{ {
DPRINT ("FsdGetFsAttributeInformation()\n"); DPRINT ("FsdGetFsAttributeInformation()\n");
DPRINT ("FsAttributeInfo = %p\n", FsAttributeInfo); DPRINT ("FsAttributeInfo = %p\n", FsAttributeInfo);
@ -65,7 +66,8 @@ NTSTATUS FsdGetFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttribute
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
NTSTATUS FsdGetFsSizeInformation(PDEVICE_OBJECT DeviceObject, NTSTATUS
FsdGetFsSizeInformation (PDEVICE_OBJECT DeviceObject,
PFILE_FS_SIZE_INFORMATION FsSizeInfo) PFILE_FS_SIZE_INFORMATION FsSizeInfo)
{ {
PDEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension; PDEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
@ -78,7 +80,8 @@ NTSTATUS FsdGetFsSizeInformation(PDEVICE_OBJECT DeviceObject,
if (DeviceExt->FatType == FAT32) if (DeviceExt->FatType == FAT32)
{ {
struct _BootSector32 *BootSect = (struct _BootSector32 *)DeviceExt->Boot; struct _BootSector32 *BootSect =
(struct _BootSector32 *) DeviceExt->Boot;
if (BootSect->Sectors) if (BootSect->Sectors)
FsSizeInfo->TotalAllocationUnits.QuadPart = BootSect->Sectors; FsSizeInfo->TotalAllocationUnits.QuadPart = BootSect->Sectors;
@ -117,7 +120,8 @@ NTSTATUS FsdGetFsSizeInformation(PDEVICE_OBJECT DeviceObject,
} }
NTSTATUS STDCALL VfatQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS STDCALL
VfatQueryVolumeInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/* /*
* FUNCTION: Retrieve the specified file information * FUNCTION: Retrieve the specified file information
*/ */
@ -161,9 +165,7 @@ NTSTATUS STDCALL VfatQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, PIRP Ir
{ {
case FileFsVolumeInformation: case FileFsVolumeInformation:
RC = FsdGetFsVolumeInformation (FileObject, RC = FsdGetFsVolumeInformation (FileObject,
FCB, FCB, DeviceObject, SystemBuffer);
DeviceObject,
SystemBuffer);
break; break;
case FileFsAttributeInformation: case FileFsAttributeInformation:
@ -184,5 +186,3 @@ NTSTATUS STDCALL VfatQueryVolumeInformation(PDEVICE_OBJECT DeviceObject, PIRP Ir
return RC; return RC;
} }

5
reactos/include/ddk/cctypes.h
View file

@ -73,4 +73,9 @@ typedef struct _SECTION_OBJECT_POINTERS
typedef VOID (*PFLUSH_TO_LSN)(IN PVOID LogHandle, IN LARGE_INTEGER Lsn); typedef VOID (*PFLUSH_TO_LSN)(IN PVOID LogHandle, IN LARGE_INTEGER Lsn);
typedef struct _REACTOS_COMMON_FCB_HEADER
{
PBCB Bcb;
} REACTOS_COMMON_FCB_HEADER;
#endif /* __INCLUDE_DDK_CCTYPES_H */ #endif /* __INCLUDE_DDK_CCTYPES_H */

7
reactos/include/ddk/iotypes.h
View file

@ -1,4 +1,4 @@
/* $Id: iotypes.h,v 1.20 2000/10/06 22:53:21 ekohl Exp $ /* $Id: iotypes.h,v 1.21 2000/12/29 23:17:11 dwelch Exp $
* *
*/ */
@ -267,6 +267,11 @@ typedef struct _IO_COMPLETION_CONTEXT
#define FO_HANDLE_CREATED 0x00040000 #define FO_HANDLE_CREATED 0x00040000
#define FO_FILE_FAST_IO_READ 0x00080000 #define FO_FILE_FAST_IO_READ 0x00080000
#define FO_DIRECT_CACHE_READ 0x72000001
#define FO_DIRECT_CACHE_WRITE 0x72000002
#define FO_DIRECT_CACHE_PAGING_READ 0x72000004
#define FO_DIRECT_CACHE_PAGING_WRITE 0x72000008
typedef struct _FILE_OBJECT typedef struct _FILE_OBJECT
{ {
CSHORT Type; CSHORT Type;

43
reactos/include/ddk/ntifs.h
View file

@ -34,39 +34,24 @@ typedef struct _CACHE_SEGMENT
PBCB Bcb; PBCB Bcb;
} CACHE_SEGMENT, *PCACHE_SEGMENT; } CACHE_SEGMENT, *PCACHE_SEGMENT;
NTSTATUS NTSTATUS STDCALL
STDCALL CcFlushCachePage (PCACHE_SEGMENT CacheSeg);
CcFlushCachePage ( NTSTATUS STDCALL
PCACHE_SEGMENT CacheSeg CcReleaseCachePage (PBCB Bcb,
);
NTSTATUS
STDCALL
CcReleaseCachePage (
PBCB Bcb,
PCACHE_SEGMENT CacheSeg, PCACHE_SEGMENT CacheSeg,
BOOLEAN Valid BOOLEAN Valid);
); NTSTATUS STDCALL
NTSTATUS CcRequestCachePage (PBCB Bcb,
STDCALL
CcRequestCachePage (
PBCB Bcb,
ULONG FileOffset, ULONG FileOffset,
PVOID* BaseAddress, PVOID* BaseAddress,
PBOOLEAN UptoDate, PBOOLEAN UptoDate,
PCACHE_SEGMENT * CacheSeg PCACHE_SEGMENT* CacheSeg);
); NTSTATUS STDCALL
NTSTATUS CcInitializeFileCache (PFILE_OBJECT FileObject,
STDCALL PBCB* Bcb);
CcInitializeFileCache ( NTSTATUS STDCALL
PFILE_OBJECT FileObject, CcReleaseFileCache (PFILE_OBJECT FileObject,
PBCB * Bcb PBCB Bcb);
);
NTSTATUS
STDCALL
CcReleaseFileCache (
PFILE_OBJECT FileObject,
PBCB Bcb
);
#include <ddk/cctypes.h> #include <ddk/cctypes.h>

3
reactos/ntoskrnl/include/internal/mm.h
View file

@ -304,6 +304,9 @@ NTSTATUS MmSafeCopyFromUser(PVOID Dest, PVOID Src, ULONG Count);
NTSTATUS MmSafeCopyToUser(PVOID Dest, PVOID Src, ULONG Count); NTSTATUS MmSafeCopyToUser(PVOID Dest, PVOID Src, ULONG Count);
NTSTATUS NTSTATUS
MmCreatePhysicalMemorySection(VOID); MmCreatePhysicalMemorySection(VOID);
PVOID
MmGetContinuousPages(ULONG NumberOfBytes,
PHYSICAL_ADDRESS HighestAcceptableAddress);
#define MM_PHYSICAL_PAGE_MPW_PENDING (0x8) #define MM_PHYSICAL_PAGE_MPW_PENDING (0x8)

44
reactos/ntoskrnl/mm/cont.c
View file

@ -1,4 +1,4 @@
/* $Id: cont.c,v 1.4 2000/03/29 13:11:54 dwelch Exp $ /* $Id: cont.c,v 1.5 2000/12/29 23:17:12 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -12,6 +12,7 @@
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <internal/mm.h>
#include <internal/debug.h> #include <internal/debug.h>
@ -44,11 +45,38 @@
* REVISIONS * REVISIONS
* *
*/ */
PVOID STDCALL MmAllocateContiguousMemory ( PVOID STDCALL
IN ULONG NumberOfBytes, MmAllocateContiguousMemory (IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS HighestAcceptableAddress) IN PHYSICAL_ADDRESS HighestAcceptableAddress)
{ {
UNIMPLEMENTED; PMEMORY_AREA MArea;
NTSTATUS Status;
PVOID BaseAddress;
PVOID PBase;
ULONG i;
Status = MmCreateMemoryArea(NULL,
MmGetKernelAddressSpace(),
MEMORY_AREA_CONTINUOUS_MEMORY,
&BaseAddress,
NumberOfBytes,
0,
&MArea);
if (!NT_SUCCESS(Status))
{
return(NULL);
}
PBase = MmGetContinuousPages(NumberOfBytes,
HighestAcceptableAddress);
for (i = 0; i < (PAGE_ROUND_UP(NumberOfBytes) / 4096); i++)
{
MmCreateVirtualMapping(NULL,
BaseAddress + (i * 4096),
PAGE_EXECUTE_READWRITE,
(ULONG)(PBase + (i * 4096)));
}
return(BaseAddress);
} }
@ -74,9 +102,13 @@ PVOID STDCALL MmAllocateContiguousMemory (
* REVISIONS * REVISIONS
* *
*/ */
VOID STDCALL MmFreeContiguousMemory(IN PVOID BaseAddress) VOID STDCALL
MmFreeContiguousMemory(IN PVOID BaseAddress)
{ {
UNIMPLEMENTED; MmFreeMemoryArea(MmGetKernelAddressSpace(),
BaseAddress,
0,
TRUE);
} }

56
reactos/ntoskrnl/mm/freelist.c
View file

@ -48,6 +48,62 @@ static LIST_ENTRY BiosPageListHead;
/* FUNCTIONS *************************************************************/ /* FUNCTIONS *************************************************************/
PVOID
MmGetContinuousPages(ULONG NumberOfBytes,
PHYSICAL_ADDRESS HighestAcceptableAddress)
{
ULONG NrPages;
ULONG i;
ULONG start;
ULONG length;
KIRQL oldIrql;
NrPages = PAGE_ROUND_UP(NumberOfBytes) / PAGESIZE;
KeAcquireSpinLock(&PageListLock, &oldIrql);
start = -1;
length = 0;
for (i = 0; i < (HighestAcceptableAddress.QuadPart / PAGESIZE); i++)
{
if (MmPageArray[i].Flags & MM_PHYSICAL_PAGE_FREE)
{
if (start == -1)
{
start = i;
length = 1;
}
else
{
length++;
}
if (length == NrPages)
{
break;
}
}
else if (start != -1)
{
start = -1;
}
}
if (start == -1)
{
KeReleaseSpinLock(&PageListLock, oldIrql);
return(NULL);
}
for (i = start; i < (start + length); i++)
{
RemoveEntryList(&MmPageArray[i].ListEntry);
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED;
MmPageArray[i].ReferenceCount = 1;
MmPageArray[i].LockCount = 0;
MmPageArray[i].SavedSwapEntry = 0;
InsertTailList(&UsedPageListHead, &MmPageArray[i].ListEntry);
}
return((PVOID)(start * 4096));
}
PVOID MmInitializePageList(PVOID FirstPhysKernelAddress, PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
PVOID LastPhysKernelAddress, PVOID LastPhysKernelAddress,
ULONG MemorySizeInPages, ULONG MemorySizeInPages,