Re: [ros-dev] [ros-diffs] [reactos] 01/01: [FASTFAT_NEW] This is not permitted by WDK license. We should rather import from MS GitHub and backport to NT5.2.

24 Nov 2017

XP did not have a WDK. Did you mean XP IFS?
Best regards,
Alex Ionescu
On Thu, Nov 23, 2017 at 4:04 AM, Pierre Schweitzer pierre@reactos.org
wrote:
...
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=
a913501626e599fba9d702149896f36046832deb
commit a913501626e599fba9d702149896f36046832deb
Author: Pierre Schweitzer pierre@reactos.org
AuthorDate: Thu Nov 23 15:04:05 2017 +0100
[FASTFAT_NEW] This is not permitted by WDK license.
We should rather import from MS GitHub and backport to NT5.2.


drivers/filesystems/fastfat_new/CMakeLists.txt |   44 -
 drivers/filesystems/fastfat_new/acchksup.c     |  374 --
 drivers/filesystems/fastfat_new/allocsup.c     | 5001 ------------------
 drivers/filesystems/fastfat_new/cachesup.c     | 1814 -------
 drivers/filesystems/fastfat_new/cleanup.c      | 1027 ----
 drivers/filesystems/fastfat_new/close.c        | 1224 -----
 drivers/filesystems/fastfat_new/create.c       | 5684

drivers/filesystems/fastfat_new/devctrl.c      |  308 --
 drivers/filesystems/fastfat_new/deviosup.c     | 3284 ------------
 drivers/filesystems/fastfat_new/dirctrl.c      | 1526 ------
 drivers/filesystems/fastfat_new/dirsup.c       | 3647 -------------
 drivers/filesystems/fastfat_new/dumpsup.c      |  381 --
 drivers/filesystems/fastfat_new/ea.c           | 2013 -------
 drivers/filesystems/fastfat_new/easup.c        | 3811 --------------
 drivers/filesystems/fastfat_new/fastfat.rc     |    5 -
 drivers/filesystems/fastfat_new/fat.h          |  729 ---
 drivers/filesystems/fastfat_new/fatdata.c      | 1424 -----
 drivers/filesystems/fastfat_new/fatdata.h      |  328 --
 drivers/filesystems/fastfat_new/fatinit.c      |  675 ---
 drivers/filesystems/fastfat_new/fatprocs.h     | 2817 ----------
 drivers/filesystems/fastfat_new/fatprocssrc.c  |    1 -
 drivers/filesystems/fastfat_new/fatstruc.h     | 1614 ------
 drivers/filesystems/fastfat_new/fileinfo.c     | 4635 ----------------
 drivers/filesystems/fastfat_new/filobsup.c     |  547 --
 drivers/filesystems/fastfat_new/flush.c        | 1261 -----
 drivers/filesystems/fastfat_new/fsctrl.c       | 6726

drivers/filesystems/fastfat_new/fspdisp.c      |  472 --
 drivers/filesystems/fastfat_new/lfn.h          |   56 -
 drivers/filesystems/fastfat_new/lockctrl.c     |  726 ---
 drivers/filesystems/fastfat_new/namesup.c      | 1021 ----
 drivers/filesystems/fastfat_new/nodetype.h     |  193 -
 drivers/filesystems/fastfat_new/pnp.c          |  815 ---
 drivers/filesystems/fastfat_new/read.c         | 1649 ------
 drivers/filesystems/fastfat_new/resrcsup.c     |  807 ---
 drivers/filesystems/fastfat_new/shutdown.c     |  304 --
 drivers/filesystems/fastfat_new/sources        |   45 -
 drivers/filesystems/fastfat_new/splaysup.c     |  504 --
 drivers/filesystems/fastfat_new/strucsup.c     | 3626 -------------
 drivers/filesystems/fastfat_new/timesup.c      |  364 --
 drivers/filesystems/fastfat_new/verfysup.c     | 1853 -------
 drivers/filesystems/fastfat_new/volinfo.c      | 1272 -----
 drivers/filesystems/fastfat_new/workque.c      |  362 --
 drivers/filesystems/fastfat_new/write.c        | 2830 ----------
 43 files changed, 67799 deletions(-)

diff --git a/drivers/filesystems/fastfat_new/CMakeLists.txt
b/drivers/filesystems/fastfat_new/CMakeLists.txt
deleted file mode 100644
index f21d829e63..0000000000
--- a/drivers/filesystems/fastfat_new/CMakeLists.txt
+++ /dev/null
@@ -1,44 +0,0 @@



-list(APPEND SOURCE

acchksup.c
allocsup.c
cachesup.c
cleanup.c
close.c
create.c
devctrl.c
deviosup.c
dirctrl.c
dirsup.c
dumpsup.c
ea.c
easup.c
fatdata.c
fatinit.c
fatprocssrc.c
fileinfo.c
filobsup.c
flush.c
fsctrl.c
fspdisp.c
lockctrl.c
namesup.c
pnp.c
read.c
resrcsup.c
shutdown.c
splaysup.c
strucsup.c
timesup.c
verfysup.c
volinfo.c
workque.c
write.c
fatprocs.h)


-add_library(fastfat SHARED ${SOURCE} fastfat.rc)
-set_module_type(fastfat kernelmodedriver)
-target_link_libraries(fastfat ${PSEH_LIB} memcmp)
-add_importlibs(fastfat ntoskrnl hal)
-add_pch(fastfat fatprocs.h SOURCE)
-add_cd_file(TARGET fastfat DESTINATION reactos/system32/drivers NO_CAB
FOR all)
diff --git a/drivers/filesystems/fastfat_new/acchksup.c
b/drivers/filesystems/fastfat_new/acchksup.c
deleted file mode 100644
index b0c78a81a4..0000000000
--- a/drivers/filesystems/fastfat_new/acchksup.c
+++ /dev/null
@@ -1,374 +0,0 @@
-/*++



-Copyright (c) 1989-2000 Microsoft Corporation



-Module Name:


AcChkSup.c


-Abstract:


This module implements the FAT access checking routine



---*/



-#include "fatprocs.h"



-//
-//  Our debug trace level
-//



-#define Dbg                              (DEBUG_TRACE_ACCHKSUP)



-NTSTATUS
-FatCreateRestrictEveryoneToken(

IN PACCESS_TOKEN Token,
OUT PACCESS_TOKEN *RestrictedToken
);


-#ifdef ALLOC_PRAGMA
-#pragma alloc_text(PAGE, FatCheckFileAccess)
-#pragma alloc_text(PAGE, FatCreateRestrictEveryoneToken)
-#pragma alloc_text(PAGE, FatExplicitDeviceAccessGranted)
-#endif




-BOOLEAN
-FatCheckFileAccess (

PIRP_CONTEXT IrpContext,
IN UCHAR DirentAttributes,
IN PACCESS_MASK DesiredAccess
)


-/*++



-Routine Description:


This routine checks if a desired access is allowed to a file

represented

by the specified DirentAttriubutes.


-Arguments:


DirentAttributes - Supplies the Dirent attributes to check access for

DesiredAccess - Supplies the desired access mask that we are checking

for



-Return Value:


BOOLEAN - TRUE if access is allowed and FALSE otherwise


---*/



-{

BOOLEAN Result;

DebugTrace(+1, Dbg, "FatCheckFileAccess\n", 0);
DebugTrace( 0, Dbg, "DirentAttributes = %8lx\n", DirentAttributes);
DebugTrace( 0, Dbg, "DesiredAccess    = %8lx\n", *DesiredAccess);

//
//  This procedures is programmed like a string of filters each
//  filter checks to see if some access is allowed,  if it is not

allowed

//  the filter return FALSE to the user without further checks

otherwise

//  it moves on to the next filter.  The filter check is to check for
//  desired access flags that are not allowed for a particular dirent
//

Result = TRUE;

_SEH2_TRY {

   //


   //  Check for Volume ID or Device Dirents, these are not allowed



user

   //  access at all


   //



   if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_VOLUME_ID) ||


       FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DEVICE)) {



       DebugTrace(0, Dbg, "Cannot access volume id or device\n", 0);



       try_return( Result = FALSE );


   }



   //


   //  Check the desired access for the object - we only blackball



that

   //  we do not understand.  The model of filesystems using ACLs is



that

   //  they do not type the ACL to the object the ACL is on.



Permissions

   //  are not checked for consistency vs. the object type -



dir/file.

   //



   if (FlagOn(*DesiredAccess, ~(DELETE |


                                READ_CONTROL |


                                WRITE_OWNER |


                                WRITE_DAC |


                                SYNCHRONIZE |


                                ACCESS_SYSTEM_SECURITY |


                                FILE_WRITE_DATA |


                                FILE_READ_EA |


                                FILE_WRITE_EA |


                                FILE_READ_ATTRIBUTES |


                                FILE_WRITE_ATTRIBUTES |


                                FILE_LIST_DIRECTORY |


                                FILE_TRAVERSE |


                                FILE_DELETE_CHILD |


                                FILE_APPEND_DATA))) {



       DebugTrace(0, Dbg, "Cannot open object\n", 0);



       try_return( Result = FALSE );


   }



   //


   //  Check for a read-only Dirent


   //



   if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_READ_ONLY)) {



       //


       //  Check the desired access for a read-only dirent, we



blackball

       //  WRITE, FILE_APPEND_DATA, FILE_ADD_FILE,


       //  FILE_ADD_SUBDIRECTORY, and FILE_DELETE_CHILD


       //



       if (FlagOn(*DesiredAccess, ~(DELETE |


                                    READ_CONTROL |


                                    WRITE_OWNER |


                                    WRITE_DAC |


                                    SYNCHRONIZE |


                                    ACCESS_SYSTEM_SECURITY |


                                    FILE_READ_DATA |


                                    FILE_READ_EA |


                                    FILE_WRITE_EA |


                                    FILE_READ_ATTRIBUTES |


                                    FILE_WRITE_ATTRIBUTES |


                                    FILE_EXECUTE |


                                    FILE_LIST_DIRECTORY |


                                    FILE_TRAVERSE))) {



           DebugTrace(0, Dbg, "Cannot open readonly\n", 0);



           try_return( Result = FALSE );


       }


   }



try_exit: NOTHING;
} _SEH2_FINALLY {

   DebugUnwind( FatCheckFileAccess );



   DebugTrace(-1, Dbg, "FatCheckFileAccess -> %08lx\n", Result);


} _SEH2_END;

UNREFERENCED_PARAMETER( IrpContext );

return Result;

-}




-NTSTATUS
-FatExplicitDeviceAccessGranted (

IN PIRP_CONTEXT IrpContext,
IN PDEVICE_OBJECT DeviceObject,
IN PACCESS_STATE AccessState,
IN KPROCESSOR_MODE ProcessorMode
)


-/*++



-Routine Description:


This function asks whether the SID described in the input access

state has

been granted any explicit access to the given device object.  It does

this

by acquiring a token stripped of its ability to acquire access via the
Everyone SID and re-doing the access check.


-Arguments:


DeviceObject - the device whose ACL will be checked

AccessState - the access state describing the security context to be

checked


ProcessorMode - the mode this check should occur against


-Return Value:


NTSTATUS - Indicating whether explicit access was granted.


---*/



-{

NTSTATUS Status;

-#ifndef __REACTOS__

BOOLEAN Result;

-#endif


PACCESS_TOKEN OriginalAccessToken;
PACCESS_TOKEN RestrictedAccessToken;

PACCESS_TOKEN *EffectiveToken;

PRIVILEGE_SET PrivilegeSet;

ACCESS_MASK GrantedAccess;

//
//  If the access state indicates that specific access other
//  than traverse was acquired, either Everyone does have such
//  access or explicit access was granted.  In both cases, we're
//  happy to let this proceed.
//

if (AccessState->PreviouslyGrantedAccess & (SPECIFIC_RIGHTS_ALL ^
                                           FILE_TRAVERSE)) {



   return STATUS_SUCCESS;


}

//
//  If the manage volume privilege is held, this also permits access.
//

PrivilegeSet.PrivilegeCount = 1;
PrivilegeSet.Control = PRIVILEGE_SET_ALL_NECESSARY;
PrivilegeSet.Privilege[0].Luid = RtlConvertLongToLuid(

SE_MANAGE_VOLUME_PRIVILEGE );

PrivilegeSet.Privilege[0].Attributes = 0;

if (SePrivilegeCheck( &PrivilegeSet,
                     &AccessState->SubjectSecurityContext,


                     ProcessorMode )) {



   return STATUS_SUCCESS;


}

//
//  Capture the subject context as a prelude to everything below.
//

SeLockSubjectContext( &AccessState->SubjectSecurityContext );

//
//  Convert the token in the subject context into one which does not
//  acquire access through the Everyone SID.
//
//  The logic for deciding which token is effective comes from
//  SeQuerySubjectContextToken; since there is no natural way
//  of getting a pointer to it, do it by hand.
//

if (ARGUMENT_PRESENT( AccessState->SubjectSecurityContext.ClientToken

)) {

   EffectiveToken = &AccessState->SubjectSecurityContext.



ClientToken;

} else {
   EffectiveToken = &AccessState->SubjectSecurityContext.



PrimaryToken;

}

OriginalAccessToken = *EffectiveToken;
Status = FatCreateRestrictEveryoneToken( OriginalAccessToken,

&RestrictedAccessToken );


if (!NT_SUCCESS(Status)) {

   SeReleaseSubjectContext( &AccessState->SubjectSecurityContext );


   return Status;


}

//
//  Now see if the resulting context has access to the device through
//  its explicitly granted access.  We swap in our restricted token
//  for this check as the effective client token.
//

*EffectiveToken = RestrictedAccessToken;


-#ifndef __REACTOS__

Result = SeAccessCheck( DeviceObject->SecurityDescriptor,

-#else

SeAccessCheck( DeviceObject->SecurityDescriptor,

-#endif

                       &AccessState->SubjectSecurityContext,


                       FALSE,


                       AccessState->OriginalDesiredAccess,


                       0,


                       NULL,


                       IoGetFileObjectGenericMapping(),


                       ProcessorMode,


                       &GrantedAccess,


                       &Status );



*EffectiveToken = OriginalAccessToken;

//
//  Cleanup and return.
//

SeUnlockSubjectContext( &AccessState->SubjectSecurityContext );
ObDereferenceObject( RestrictedAccessToken );

return Status;

-}




-NTSTATUS
-FatCreateRestrictEveryoneToken (

IN PACCESS_TOKEN Token,
OUT PACCESS_TOKEN *RestrictedToken
)


-/*++



-Routine Description:


This function takes a token as the input and returns a new restricted

token

from which Everyone sid has been disabled.  The resulting token may

be used

to find out if access is available to a user-sid by explicit means.


-Arguments:


Token - Input token from which Everyone sid needs to be deactivated.

RestrictedToken - Receives the the new restricted token.
   This must be released using ObDereferenceObject(*



RestrictedToken);



-Return Value:


NTSTATUS - Returned by SeFilterToken.


---*/



-{

//
// Array of sids to disable.
//

TOKEN_GROUPS SidsToDisable;

NTSTATUS Status = STATUS_SUCCESS;

//
//  Restricted token will contain the original sids with one change:
//  If Everyone sid is present in the token, it will be marked for

DenyOnly.

//

*RestrictedToken = NULL;

//
//  Put Everyone sid in the array of sids to disable. This will mark

it

//  for SE_GROUP_USE_FOR_DENY_ONLY and it'll only be applicable for

Deny aces.

//

SidsToDisable.GroupCount = 1;
SidsToDisable.Groups[0].Attributes = 0;
SidsToDisable.Groups[0].Sid = SeExports->SeWorldSid;

Status = SeFilterToken(
            Token,            // Token that needs to be restricted.


            0,                // No flags


            &SidsToDisable,   // Disable everyone sid


            NULL,             // Do not create any restricted sids


            NULL,             // Do not delete any privileges


            RestrictedToken   // Restricted token


            );



return Status;

-}



diff --git a/drivers/filesystems/fastfat_new/allocsup.c
b/drivers/filesystems/fastfat_new/allocsup.c
deleted file mode 100644
index 79a9e7865a..0000000000
--- a/drivers/filesystems/fastfat_new/allocsup.c
+++ /dev/null
@@ -1,5001 +0,0 @@
-/*++



-Copyright (c) 1990-2000 Microsoft Corporation



-Module Name:


AllocSup.c


-Abstract:


This module implements the Allocation support routines for Fat.



---*/



-#include "fatprocs.h"



-//
-//  The Bug check file id for this module
-//



-#define BugCheckFileId                   (FAT_BUG_CHECK_ALLOCSUP)



-//
-//  Local debug trace level
-//



-#define Dbg                              (DEBUG_TRACE_ALLOCSUP)



-#define FatMin(a, b)    ((a) < (b) ? (a) : (b))



-//
-//  This strucure is used by FatLookupFatEntry to remember a pinned page
-//  of fat.
-//



-typedef struct _FAT_ENUMERATION_CONTEXT {


VBO VboOfPinnedPage;
PBCB Bcb;
PVOID PinnedPage;


-} FAT_ENUMERATION_CONTEXT, *PFAT_ENUMERATION_CONTEXT;



-//
-//  Local support routine prototypes
-//



-VOID
-FatLookupFatEntry(

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG FatIndex,
IN OUT PULONG FatEntry,
IN OUT PFAT_ENUMERATION_CONTEXT Context
);


-VOID
-FatSetFatRun(

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG StartingFatIndex,
IN ULONG ClusterCount,
IN BOOLEAN ChainTogether
);


-UCHAR
-FatLogOf(

IN ULONG Value
);


-//
-//  Note that the KdPrint below will ONLY fire when the assert does.
Leave it
-//  alone.
-//



-#if DBG
-#define ASSERT_CURRENT_WINDOW_GOOD(VCB) {
               \

ULONG FreeClusterBitMapClear;
          \
ASSERT( (VCB)->FreeClusterBitMap.Buffer != NULL );
           \
FreeClusterBitMapClear = RtlNumberOfClearBits(&(VCB)->FreeClusterBitMap);
    \
if ((VCB)->CurrentWindow->ClustersFree != FreeClusterBitMapClear) {
          \
   KdPrint(("FAT: ClustersFree %x h != FreeClusterBitMapClear %x



h\n",             \

            (VCB)->CurrentWindow->ClustersFree,
          \


            FreeClusterBitMapClear));
        \


}
          \
ASSERT( (VCB)->CurrentWindow->ClustersFree == FreeClusterBitMapClear

);             \
-}
-#else
-#define ASSERT_CURRENT_WINDOW_GOOD(VCB)
-#endif



-//
-//  The following macros provide a convenient way of hiding the details
-//  of bitmap allocation schemes.
-//




-//
-//  VOID
-//  FatLockFreeClusterBitMap (
-//      IN PVCB Vcb
-//      );
-//



-#define FatLockFreeClusterBitMap(VCB) {                         \

ASSERT(KeAreApcsDisabled());                                \
ExAcquireFastMutexUnsafe( &(VCB)->FreeClusterBitMapMutex ); \
ASSERT_CURRENT_WINDOW_GOOD(VCB)                             \

-}



-//
-//  VOID
-//  FatUnlockFreeClusterBitMap (
-//      IN PVCB Vcb
-//      );
-//



-#define FatUnlockFreeClusterBitMap(VCB) {                       \

ASSERT_CURRENT_WINDOW_GOOD(VCB)                             \
ASSERT(KeAreApcsDisabled());                                \
ExReleaseFastMutexUnsafe( &(VCB)->FreeClusterBitMapMutex ); \

-}



-//
-//  BOOLEAN
-//  FatIsClusterFree (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG FatIndex
-//      );
-//



-#define FatIsClusterFree(IRPCONTEXT,VCB,FAT_INDEX)
      \

(RtlCheckBit(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2) == 0)


-//
-//  VOID
-//  FatFreeClusters  (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG FatIndex,
-//      IN ULONG ClusterCount
-//      );
-//



-#define FatFreeClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) {
     \

if ((CLUSTER_COUNT) == 1) {
\
   FatSetFatEntry((IRPCONTEXT),(VCB),(FAT_INDEX),FAT_CLUSTER_AVAILABLE);



\

} else {
\
   FatSetFatRun((IRPCONTEXT),(VCB),(FAT_INDEX),(CLUSTER_COUNT),FALSE);



\

}
\

-}



-//
-//  VOID
-//  FatAllocateClusters  (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG FatIndex,
-//      IN ULONG ClusterCount
-//      );
-//



-#define FatAllocateClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) {
  \

if ((CLUSTER_COUNT) == 1) {
\
   FatSetFatEntry((IRPCONTEXT),(VCB),(FAT_INDEX),FAT_CLUSTER_LAST);



\

} else {

\

   FatSetFatRun((IRPCONTEXT),(VCB),(FAT_INDEX),(CLUSTER_COUNT),TRUE);



\

}
\

-}



-//
-//  VOID
-//  FatUnreserveClusters  (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG FatIndex,
-//      IN ULONG ClusterCount
-//      );
-//



-#define FatUnreserveClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) {
                    \

ASSERT( (FAT_INDEX) + (CLUSTER_COUNT) - 2 <= (VCB)->FreeClusterBitMap.SizeOfBitMap

);   \

ASSERT( (FAT_INDEX) >= 2);
             \
RtlClearBits(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2,(CLUSTER_COUNT));
           \
if ((FAT_INDEX) < (VCB)->ClusterHint) {
              \
   (VCB)->ClusterHint = (FAT_INDEX);
             \


}
              \

-}



-//
-//  VOID
-//  FatReserveClusters  (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG FatIndex,
-//      IN ULONG ClusterCount
-//      );
-//
-//  Handle wrapping the hint back to the front.
-//



-#define FatReserveClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) {
                    \

ULONG _AfterRun = (FAT_INDEX) + (CLUSTER_COUNT);
             \
ASSERT( (FAT_INDEX) + (CLUSTER_COUNT) - 2 <= (VCB)->FreeClusterBitMap.SizeOfBitMap

);   \

ASSERT( (FAT_INDEX) >= 2);
             \
RtlSetBits(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2,(CLUSTER_COUNT));
             \
            \


if (_AfterRun - 2 >= (VCB)->FreeClusterBitMap.SizeOfBitMap) {
              \
   _AfterRun = 2;
            \


}
              \
if (RtlCheckBit(&(VCB)->FreeClusterBitMap, _AfterRun - 2))  {
                      \
   (VCB)->ClusterHint = RtlFindClearBits( &(VCB)->FreeClusterBitMap,



1, _AfterRun - 2) + 2;    \

   if (1 == (VCB)->ClusterHint)  {
                     \


       (VCB)->ClusterHint = 2;
             \


   }
             \


}
              \
else {
             \
   (VCB)->ClusterHint = _AfterRun;
             \


}
              \

-}



-//
-//  ULONG
-//  FatFindFreeClusterRun (
-//      IN PIRP_CONTEXT IrpContext,
-//      IN PVCB Vcb,
-//      IN ULONG ClusterCount,
-//      IN ULONG AlternateClusterHint
-//      );
-//
-//  Do a special check if only one cluster is desired.
-//



-#define FatFindFreeClusterRun(IRPCONTEXT,VCB,CLUSTER_COUNT,CLUSTER_HINT)
( \

(CLUSTER_COUNT == 1) &&
\
FatIsClusterFree((IRPCONTEXT), (VCB), (CLUSTER_HINT)) ?
\
   (CLUSTER_HINT) :



\

   RtlFindClearBits( &(VCB)->FreeClusterBitMap,



\

                     (CLUSTER_COUNT),



\

                     (CLUSTER_HINT) - 2) + 2

\

-)



-//
-//  FAT32: Define the maximum size of the FreeClusterBitMap to be the
-//  maximum size of a FAT16 FAT.  If there are more clusters on the
-//  volume than can be represented by this many bytes of bitmap, the
-//  FAT will be split into "buckets", each of which does fit.
-//
-//  Note this count is in clusters/bits of bitmap.
-//



-#define MAX_CLUSTER_BITMAP_SIZE         (1 << 16)



-//
-//  Calculate the window a given cluster number is in.
-//



-#define FatWindowOfCluster(C)           (((C) - 2) /
MAX_CLUSTER_BITMAP_SIZE)



-#ifdef ALLOC_PRAGMA
-#pragma alloc_text(PAGE, FatAddFileAllocation)
-#pragma alloc_text(PAGE, FatAllocateDiskSpace)
-#pragma alloc_text(PAGE, FatDeallocateDiskSpace)
-#pragma alloc_text(PAGE, FatExamineFatEntries)
-#pragma alloc_text(PAGE, FatInterpretClusterType)
-#pragma alloc_text(PAGE, FatLogOf)
-#pragma alloc_text(PAGE, FatLookupFatEntry)
-#pragma alloc_text(PAGE, FatLookupFileAllocation)
-#pragma alloc_text(PAGE, FatLookupFileAllocationSize)
-#pragma alloc_text(PAGE, FatMergeAllocation)
-#pragma alloc_text(PAGE, FatSetFatEntry)
-#pragma alloc_text(PAGE, FatSetFatRun)
-#pragma alloc_text(PAGE, FatSetupAllocationSupport)
-#pragma alloc_text(PAGE, FatSplitAllocation)
-#pragma alloc_text(PAGE, FatTearDownAllocationSupport)
-#pragma alloc_text(PAGE, FatTruncateFileAllocation)
-#endif




-INLINE
-ULONG
-FatSelectBestWindow(

IN PVCB Vcb
)

-/*++



-Routine Description:


Choose a window to allocate clusters from.   Order of preference is:


First window with >50% free clusters



First empty window



Window with greatest number of free clusters.




-Arguments:


Vcb - Supplies the Vcb for the volume


-Return Value:


'Best window' number (index into Vcb->Windows[])


---*/
-{

ULONG i, Fave = 0;
ULONG MaxFree = 0;
ULONG FirstEmpty = -1;
ULONG ClustersPerWindow = MAX_CLUSTER_BITMAP_SIZE;

ASSERT( 1 != Vcb->NumberOfWindows);

for (i = 0; i < Vcb->NumberOfWindows; i++) {

   if (Vcb->Windows[i].ClustersFree == ClustersPerWindow)  {



       if (-1 == FirstEmpty)  {



           //


           //  Keep note of the first empty window on the disc


           //



           FirstEmpty = i;


       }


   }


   else if (Vcb->Windows[i].ClustersFree > MaxFree)  {



       //


       //  This window has the most free clusters,  so far


       //



       MaxFree = Vcb->Windows[i].ClustersFree;


       Fave = i;



       //


       //  If this window has >50% free clusters,  then we will take



it,

       //  so don't bother considering more windows.


       //



       if (MaxFree >= (ClustersPerWindow >> 1))  {



           break;


       }


   }


}

//
//  If there were no windows with 50% or more freespace,  then select

the

//  first empty window on the disc,  if any - otherwise we'll just go

with

//  the one with the most free clusters.
//

if ((MaxFree < (ClustersPerWindow >> 1)) && (-1 != FirstEmpty))  {

   Fave = FirstEmpty;


}

return Fave;

-}




-VOID
-FatSetupAllocationSupport (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb
)


-/*++



-Routine Description:


This routine fills in the Allocation Support structure in the Vcb.
Most entries are computed using fat.h macros supplied with data from
the Bios Parameter Block.  The free cluster count, however, requires
going to the Fat and actually counting free sectors.  At the same time
the free cluster bit map is initalized.


-Arguments:


Vcb - Supplies the Vcb to fill in.


---*/



-{
-#ifndef __REACTOS__

ULONG BitMapSize;
PVOID BitMapBuffer;

-#endif

ULONG BitIndex;


-#ifndef __REACTOS__

PBCB Bcb;

ULONG Page;
ULONG Offset;
ULONG FatIndexBitSize;

-#endif

ULONG ClustersDescribableByFat;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatSetupAllocationSupport\n", 0);
DebugTrace( 0, Dbg, "  Vcb = %8lx\n", Vcb);

//
//  Compute a number of fields for Vcb.AllocationSupport
//

Vcb->AllocationSupport.RootDirectoryLbo = FatRootDirectoryLbo(

&Vcb->Bpb );

Vcb->AllocationSupport.RootDirectorySize = FatRootDirectorySize(

&Vcb->Bpb );


Vcb->AllocationSupport.FileAreaLbo = FatFileAreaLbo( &Vcb->Bpb );

Vcb->AllocationSupport.NumberOfClusters = FatNumberOfClusters(

&Vcb->Bpb );


Vcb->AllocationSupport.FatIndexBitSize = FatIndexBitSize( &Vcb->Bpb

);


Vcb->AllocationSupport.LogOfBytesPerSector = FatLogOf(Vcb->Bpb.

BytesPerSector);

Vcb->AllocationSupport.LogOfBytesPerCluster =

FatLogOf(FatBytesPerCluster( &Vcb->Bpb ));

Vcb->AllocationSupport.NumberOfFreeClusters = 0;

//
//  Deal with a bug in DOS 5 format, if the Fat is not big enough to
//  describe all the clusters on the disk, reduce this number.  We

expect

//  that fat32 volumes will not have this problem.
//
//  Turns out this was not a good assumption.  We have to do this

always now.

//

ClustersDescribableByFat = ( ((FatIsFat32(Vcb)?

Vcb->Bpb.LargeSectorsPerFat :



Vcb->Bpb.SectorsPerFat) *

                             Vcb->Bpb.BytesPerSector * 8)


                            / FatIndexBitSize(&Vcb->Bpb) ) - 2;



if (Vcb->AllocationSupport.NumberOfClusters >

ClustersDescribableByFat) {


   Vcb->AllocationSupport.NumberOfClusters =



ClustersDescribableByFat;

}

//
//  Extend the virtual volume file to include the Fat
//

{
   CC_FILE_SIZES FileSizes;



   FileSizes.AllocationSize.QuadPart =


   FileSizes.FileSize.QuadPart = (FatReservedBytes( &Vcb->Bpb ) +


                                  FatBytesPerFat( &Vcb->Bpb ));


   FileSizes.ValidDataLength = FatMaxLarge;



   if ( Vcb->VirtualVolumeFile->PrivateCacheMap == NULL ) {



       CcInitializeCacheMap( Vcb->VirtualVolumeFile,


                             &FileSizes,


                             TRUE,


                             &FatData.CacheManagerNoOpCallbacks,


                             Vcb );



   } else {



       CcSetFileSizes( Vcb->VirtualVolumeFile, &FileSizes );


   }


}

_SEH2_TRY {

   if (FatIsFat32(Vcb) &&


       Vcb->AllocationSupport.NumberOfClusters >



MAX_CLUSTER_BITMAP_SIZE) {


       Vcb->NumberOfWindows = (Vcb->AllocationSupport.NumberOfClusters







                               MAX_CLUSTER_BITMAP_SIZE - 1) /


                              MAX_CLUSTER_BITMAP_SIZE;




-#ifndef __REACTOS__

       BitMapSize = MAX_CLUSTER_BITMAP_SIZE;



-#endif


   } else {



       Vcb->NumberOfWindows = 1;



-#ifndef __REACTOS__

       BitMapSize = Vcb->AllocationSupport.NumberOfClusters;



-#endif

   }



   Vcb->Windows = FsRtlAllocatePoolWithTag( PagedPool,


                                            Vcb->NumberOfWindows *



sizeof(FAT_WINDOW),

                                            TAG_FAT_WINDOW );



   RtlInitializeBitMap( &Vcb->FreeClusterBitMap,


                        NULL,


                        0 );



   //


   //  Chose a FAT window to begin operation in.


   //



   if (Vcb->NumberOfWindows > 1) {



       //


       //  Read the fat and count up free clusters.  We bias by the



two reserved

       //  entries in the FAT.


       //



       FatExamineFatEntries( IrpContext, Vcb,


                             2,


                             Vcb->AllocationSupport.NumberOfClusters




2 - 1,


                             TRUE,


                             NULL,


                             NULL);




       //


       //  Pick a window to begin allocating from


       //



       Vcb->CurrentWindow = &Vcb->Windows[ FatSelectBestWindow(



Vcb)];


   } else {



       Vcb->CurrentWindow = &Vcb->Windows[0];



       //


       //  Carefully bias ourselves by the two reserved entries in



the FAT.

       //



       Vcb->CurrentWindow->FirstCluster = 2;


       Vcb->CurrentWindow->LastCluster = Vcb->AllocationSupport.NumberOfClusters




2 - 1;


   }



   //


   //  Now transition to the FAT window we have chosen.


   //



   FatExamineFatEntries( IrpContext, Vcb,


                         0,


                         0,


                         FALSE,


                         Vcb->CurrentWindow,


                         NULL);



   //


   //  Now set the ClusterHint to the first free bit in our favorite


   //  window (except the ClusterHint is off by two).


   //



   Vcb->ClusterHint =


       (BitIndex = RtlFindClearBits( &Vcb->FreeClusterBitMap, 1, 0



)) != -1 ?

           BitIndex + 2 : 2;



} _SEH2_FINALLY {

   DebugUnwind( FatSetupAllocationSupport );



   //


   //  If we hit an exception, back out.


   //



   if (_SEH2_AbnormalTermination()) {



       FatTearDownAllocationSupport( IrpContext, Vcb );


   }


} _SEH2_END;

return;

-}




-VOID
-FatTearDownAllocationSupport (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb
)


-/*++



-Routine Description:


This routine prepares the volume for closing.  Specifically, we must
release the free fat bit map buffer, and uninitialize the dirty fat
Mcb.


-Arguments:


Vcb - Supplies the Vcb to fill in.


-Return Value:


VOID


---*/



-{

DebugTrace(+1, Dbg, "FatTearDownAllocationSupport\n", 0);
DebugTrace( 0, Dbg, "  Vcb = %8lx\n", Vcb);

PAGED_CODE();

//
//  If there are FAT buckets, free them.
//

if ( Vcb->Windows != NULL ) {

   ExFreePool( Vcb->Windows );


   Vcb->Windows = NULL;


}

//
//  Free the memory associated with the free cluster bitmap.
//

if ( Vcb->FreeClusterBitMap.Buffer != NULL ) {

   ExFreePool( Vcb->FreeClusterBitMap.Buffer );



   //


   //  NULL this field as an flag.


   //



   Vcb->FreeClusterBitMap.Buffer = NULL;


}

//
//  And remove all the runs in the dirty fat Mcb
//

FatRemoveMcbEntry( Vcb, &Vcb->DirtyFatMcb, 0, 0xFFFFFFFF );

DebugTrace(-1, Dbg, "FatTearDownAllocationSupport -> (VOID)\n", 0);

UNREFERENCED_PARAMETER( IrpContext );

return;

-}




-VOID
-FatLookupFileAllocation (

IN PIRP_CONTEXT IrpContext,
IN PFCB FcbOrDcb,
IN VBO Vbo,
OUT PLBO Lbo,
OUT PULONG ByteCount,
OUT PBOOLEAN Allocated,
OUT PBOOLEAN EndOnMax,
OUT PULONG Index
)


-/*++



-Routine Description:


This routine looks up the existing mapping of VBO to LBO for a
file/directory.  The information it queries is either stored in the
mcb field of the fcb/dcb or it is stored on in the fat table and
needs to be retrieved and decoded, and updated in the mcb.


-Arguments:


FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being queried

Vbo - Supplies the VBO whose LBO we want returned

Lbo - Receives the LBO corresponding to the input Vbo if one exists

ByteCount - Receives the number of bytes within the run the run
           that correpond between the input vbo and output lbo.



Allocated - Receives TRUE if the Vbo does have a corresponding Lbo
           and FALSE otherwise.



EndOnMax - Receives TRUE if the run ends in the maximal FAT cluster,
           which results in a fractional bytecount.



Index - Receives the Index of the run


---*/



-{

VBO CurrentVbo;
LBO CurrentLbo;
LBO PriorLbo;

VBO FirstVboOfCurrentRun;
LBO FirstLboOfCurrentRun;

BOOLEAN LastCluster;
ULONG Runs;

PVCB Vcb;
FAT_ENTRY FatEntry;
ULONG BytesPerCluster;
ULARGE_INTEGER BytesOnVolume;

FAT_ENUMERATION_CONTEXT Context;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatLookupFileAllocation\n", 0);
DebugTrace( 0, Dbg, "  FcbOrDcb  = %8lx\n", FcbOrDcb);
DebugTrace( 0, Dbg, "  Vbo       = %8lx\n", Vbo);
DebugTrace( 0, Dbg, "  Lbo       = %8lx\n", Lbo);
DebugTrace( 0, Dbg, "  ByteCount = %8lx\n", ByteCount);
DebugTrace( 0, Dbg, "  Allocated = %8lx\n", Allocated);

Context.Bcb = NULL;

Vcb = FcbOrDcb->Vcb;

*EndOnMax = FALSE;

//
//  Check the trivial case that the mapping is already in our
//  Mcb.
//

if ( FatLookupMcbEntry(Vcb, &FcbOrDcb->Mcb, Vbo, Lbo, ByteCount,

Index) ) {


   *Allocated = TRUE;



   ASSERT( ByteCount != 0);



   //


   //  Detect the overflow case, trim and claim the condition.


   //



   if (Vbo + *ByteCount == 0) {



       *EndOnMax = TRUE;


   }



   DebugTrace( 0, Dbg, "Found run in Mcb.\n", 0);


   DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0);


   return;


}

//
//  Initialize the Vcb, the cluster size, LastCluster, and
//  FirstLboOfCurrentRun (to be used as an indication of the first
//  iteration through the following while loop).
//

BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;

BytesOnVolume.QuadPart = UInt32x32To64( Vcb->AllocationSupport.NumberOfClusters,

BytesPerCluster );


LastCluster = FALSE;
FirstLboOfCurrentRun = 0;

//
//  Discard the case that the request extends beyond the end of
//  allocation.  Note that if the allocation size if not known
//  AllocationSize is set to 0xffffffff.
//

if ( Vbo >= FcbOrDcb->Header.AllocationSize.LowPart ) {

   *Allocated = FALSE;



   DebugTrace( 0, Dbg, "Vbo beyond end of file.\n", 0);


   DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0);


   return;


}

//
//  The Vbo is beyond the last Mcb entry.  So we adjust Current

Vbo/Lbo

//  and FatEntry to describe the beginning of the last entry in the

Mcb.

//  This is used as initialization for the following loop.
//
//  If the Mcb was empty, we start at the beginning of the file with
//  CurrentVbo set to 0 to indicate a new run.
//

if (FatLookupLastMcbEntry( Vcb, &FcbOrDcb->Mcb, &CurrentVbo,

&CurrentLbo, &Runs )) {


   DebugTrace( 0, Dbg, "Current Mcb size = %8lx.\n", CurrentVbo + 1);



   CurrentVbo -= (BytesPerCluster - 1);


   CurrentLbo -= (BytesPerCluster - 1);



   //


   //  Convert an index to a count.


   //



   Runs += 1;



} else {

   DebugTrace( 0, Dbg, "Mcb empty.\n", 0);



   //


   //  Check for an FcbOrDcb that has no allocation


   //



   if (FcbOrDcb->FirstClusterOfFile == 0) {



       *Allocated = FALSE;



       DebugTrace( 0, Dbg, "File has no allocation.\n", 0);


       DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0);


       return;



   } else {



       CurrentVbo = 0;


       CurrentLbo = FatGetLboFromIndex( Vcb,



FcbOrDcb->FirstClusterOfFile );

       FirstVboOfCurrentRun = CurrentVbo;


       FirstLboOfCurrentRun = CurrentLbo;



       Runs = 0;



       DebugTrace( 0, Dbg, "First Lbo of file = %8lx\n", CurrentLbo);


   }


}

//
//  Now we know that we are looking up a valid Vbo, but it is
//  not in the Mcb, which is a monotonically increasing list of
//  Vbo's.  Thus we have to go to the Fat, and update
//  the Mcb as we go.  We use a try-finally to unpin the page
//  of fat hanging around.  Also we mark *Allocated = FALSE, so that
//  the caller wont try to use the data if we hit an exception.
//

*Allocated = FALSE;

_SEH2_TRY {

   FatEntry = (FAT_ENTRY)FatGetIndexFromLbo( Vcb, CurrentLbo );



   //


   //  ASSERT that CurrentVbo and CurrentLbo are now cluster



alligned.

   //  The assumption here, is that only whole clusters of Vbos and



Lbos

   //  are mapped in the Mcb.


   //



   ASSERT( ((CurrentLbo - Vcb->AllocationSupport.FileAreaLbo)


                                               % BytesPerCluster ==




&&


           (CurrentVbo % BytesPerCluster == 0) );



   //


   //  Starting from the first Vbo after the last Mcb entry, scan



through

   //  the Fat looking for our Vbo. We continue through the Fat



until we

   //  hit a noncontiguity beyond the desired Vbo, or the last



cluster.

   //



   while ( !LastCluster ) {



       //


       //  Get the next fat entry, and update our Current variables.


       //




-#ifndef __REACTOS__

       FatLookupFatEntry( IrpContext, Vcb, FatEntry, &FatEntry,



&Context );
-#else

       FatLookupFatEntry( IrpContext, Vcb, FatEntry,



(PULONG)&FatEntry, &Context );
-#endif


       PriorLbo = CurrentLbo;


       CurrentLbo = FatGetLboFromIndex( Vcb, FatEntry );


       CurrentVbo += BytesPerCluster;



       switch ( FatInterpretClusterType( Vcb, FatEntry )) {



       //


       //  Check for a break in the Fat allocation chain.


       //



       case FatClusterAvailable:


       case FatClusterReserved:


       case FatClusterBad:



           DebugTrace( 0, Dbg, "Break in allocation chain, entry =



%d\n", FatEntry);

           DebugTrace(-1, Dbg, "FatLookupFileAllocation -> Fat



Corrupt.  Raise Status.\n", 0);


           FatPopUpFileCorrupt( IrpContext, FcbOrDcb );


           FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );


           break;



       //


       //  If this is the last cluster, we must update the Mcb and


       //  exit the loop.


       //



       case FatClusterLast:



           //


           //  Assert we know where the current run started.  If the


           //  Mcb was empty when we were called,



thenFirstLboOfCurrentRun

           //  was set to the start of the file.  If the Mcb



contained an

           //  entry, then FirstLboOfCurrentRun was set on the first


           //  iteration through the loop.  Thus if



FirstLboOfCurrentRun

           //  is 0, then there was an Mcb entry and we are on our



first

           //  iteration, meaing that the last cluster in the Mcb was


           //  really the last allocated cluster, but we checked Vbo


           //  against AllocationSize, and found it OK, thus



AllocationSize

           //  must be too large.


           //


           //  Note that, when we finally arrive here, CurrentVbo is



actually

           //  the first Vbo beyond the file allocation and



CurrentLbo is

           //  meaningless.


           //



           DebugTrace( 0, Dbg, "Read last cluster of file.\n", 0);



           //


           //  Detect the case of the maximal file.  Note that this



really isn't

           //  a proper Vbo - those are zero-based, and this is a



one-based number.

           //  The maximal file, of 2^32 - 1 bytes, has a maximum



byte offset of

           //  2^32 - 2.


           //


           //  Just so we don't get confused here.


           //



           if (CurrentVbo == 0) {



               *EndOnMax = TRUE;


               CurrentVbo -= 1;


           }



           LastCluster = TRUE;



           if (FirstLboOfCurrentRun != 0 ) {



               DebugTrace( 0, Dbg, "Adding a run to the Mcb.\n", 0);


               DebugTrace( 0, Dbg, "  Vbo    = %08lx.\n",



FirstVboOfCurrentRun);

               DebugTrace( 0, Dbg, "  Lbo    = %08lx.\n",



FirstLboOfCurrentRun);

               DebugTrace( 0, Dbg, "  Length = %08lx.\n", CurrentVbo


FirstVboOfCurrentRun);

               (VOID)FatAddMcbEntry( Vcb,


                                     &FcbOrDcb->Mcb,


                                     FirstVboOfCurrentRun,


                                     FirstLboOfCurrentRun,


                                     CurrentVbo -



FirstVboOfCurrentRun );


               Runs += 1;


           }



           //


           //  Being at the end of allocation, make sure we have



found

           //  the Vbo.  If we haven't, seeing as we checked VBO


           //  against AllocationSize, the real disk allocation is



less

           //  than that of AllocationSize.  This comes about when



the

           //  real allocation is not yet known, and AllocaitonSize


           //  contains MAXULONG.


           //


           //  KLUDGE! - If we were called by



FatLookupFileAllocationSize

           //  Vbo is set to MAXULONG - 1, and AllocationSize to the



lookup

           //  hint. Thus we merrily go along looking for a match



that isn't

           //  there, but in the meantime building an Mcb.  If this



is

           //  the case, fill in AllocationSize and return.


           //



           if ( Vbo == MAXULONG - 1 ) {



               *Allocated = FALSE;


               FcbOrDcb->Header.AllocationSize.QuadPart =



CurrentVbo;


               DebugTrace( 0, Dbg, "New file allocation size =



%08lx.\n", CurrentVbo);

               try_return ( NOTHING );


           }



           //


           //  We will lie ever so slightly if we really terminated



on the

           //  maximal byte of a file.  It is really allocated.


           //



           if (Vbo >= CurrentVbo && !*EndOnMax) {



               *Allocated = FALSE;


               try_return ( NOTHING );


           }



           break;



       //


       //  This is a continuation in the chain.  If the run has a


       //  discontiguity at this point, update the Mcb, and if we



are beyond

       //  the desired Vbo, this is the end of the run, so set



LastCluster

       //  and exit the loop.


       //



       case FatClusterNext:



           //


           //  This is the loop check.  The Vbo must not be bigger



than the size of

           //  the volume, and the Vbo must not have a) wrapped and



b) not been at the

           //  very last cluster in the chain, for the case of the



maximal file.

           //



           if ( CurrentVbo == 0 ||


                (BytesOnVolume.HighPart == 0 && CurrentVbo >



BytesOnVolume.LowPart)) {


               FatPopUpFileCorrupt( IrpContext, FcbOrDcb );


               FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR



);

           }



           if ( PriorLbo + BytesPerCluster != CurrentLbo ) {



               //


               //  Note that on the first time through the loop


               //  (FirstLboOfCurrentRun == 0), we don't add the


               //  run to the Mcb since it curresponds to the last


               //  run already stored in the Mcb.


               //



               if ( FirstLboOfCurrentRun != 0 ) {



                   DebugTrace( 0, Dbg, "Adding a run to the Mcb.\n",



0);

                   DebugTrace( 0, Dbg, "  Vbo    = %08lx.\n",



FirstVboOfCurrentRun);

                   DebugTrace( 0, Dbg, "  Lbo    = %08lx.\n",



FirstLboOfCurrentRun);

                   DebugTrace( 0, Dbg, "  Length = %08lx.\n",



CurrentVbo - FirstVboOfCurrentRun);


                   FatAddMcbEntry( Vcb,


                                   &FcbOrDcb->Mcb,


                                   FirstVboOfCurrentRun,


                                   FirstLboOfCurrentRun,


                                   CurrentVbo - FirstVboOfCurrentRun



);


                   Runs += 1;


               }



               //


               //  Since we are at a run boundry, with CurrentLbo and


               //  CurrentVbo being the first cluster of the next



run,

               //  we see if the run we just added encompases the



desired

               //  Vbo, and if so exit.  Otherwise we set up two new


               //  First*boOfCurrentRun, and continue.


               //



               if (CurrentVbo > Vbo) {



                   LastCluster = TRUE;



               } else {



                   FirstVboOfCurrentRun = CurrentVbo;


                   FirstLboOfCurrentRun = CurrentLbo;


               }


           }


           break;



       default:



           DebugTrace(0, Dbg, "Illegal Cluster Type.\n", FatEntry);



           FatBugCheck( 0, 0, 0 );



           break;



       } // switch()


   } // while()



   //


   //  Load up the return parameters.


   //


   //  On exit from the loop, Vbo still contains the desired Vbo, and


   //  CurrentVbo is the first byte after the run that contained the


   //  desired Vbo.


   //



   *Allocated = TRUE;



   *Lbo = FirstLboOfCurrentRun + (Vbo - FirstVboOfCurrentRun);



   *ByteCount = CurrentVbo - Vbo;



   if (ARGUMENT_PRESENT(Index)) {



       //


       //  Note that Runs only needs to be accurate with respect to



where we

       //  ended.  Since partial-lookup cases will occur without



exclusive

       //  synchronization, the Mcb itself may be much bigger by now.


       //



       *Index = Runs - 1;


   }



try_exit: NOTHING;

} _SEH2_FINALLY {

   DebugUnwind( FatLookupFileAllocation );



   //


   //  We are done reading the Fat, so unpin the last page of fat


   //  that is hanging around


   //



   FatUnpinBcb( IrpContext, Context.Bcb );



   DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-VOID
-FatAddFileAllocation (

IN PIRP_CONTEXT IrpContext,
IN PFCB FcbOrDcb,
IN PFILE_OBJECT FileObject OPTIONAL,
IN ULONG DesiredAllocationSize
)


-/*++



-Routine Description:


This routine adds additional allocation to the specified

file/directory.

Additional allocation is added by appending clusters to the

file/directory.


If the file already has a sufficient allocation then this procedure
is effectively a noop.


-Arguments:


FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified.
          This parameter must not specify the root dcb.



FileObject - If supplied inform the cache manager of the change.

DesiredAllocationSize - Supplies the minimum size, in bytes, that we

want

                       allocated to the file/directory.




---*/



-{

PVCB Vcb;
LARGE_MCB NewMcb;
PLARGE_MCB McbToCleanup = NULL;
PDIRENT Dirent = NULL;
ULONG NewAllocation;
PBCB Bcb = NULL;
BOOLEAN UnwindWeAllocatedDiskSpace = FALSE;
BOOLEAN UnwindAllocationSizeSet = FALSE;
BOOLEAN UnwindCacheManagerInformed = FALSE;
BOOLEAN UnwindWeInitializedMcb = FALSE;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatAddFileAllocation\n", 0);
DebugTrace( 0, Dbg, "  FcbOrDcb  =             %8lx\n", FcbOrDcb);
DebugTrace( 0, Dbg, "  DesiredAllocationSize = %8lx\n",

DesiredAllocationSize);


//
//  If we haven't yet set the correct AllocationSize, do so.
//

if (FcbOrDcb->Header.AllocationSize.QuadPart ==

FCB_LOOKUP_ALLOCATIONSIZE_HINT)  {


   FatLookupFileAllocationSize( IrpContext, FcbOrDcb );


}

//
//  Check for the benign case that the desired allocation is already
//  within the allocation size.
//

if (DesiredAllocationSize <= FcbOrDcb->Header.AllocationSize.LowPart)

{


   DebugTrace(0, Dbg, "Desired size within current allocation.\n",



0);


   DebugTrace(-1, Dbg, "FatAddFileAllocation -> (VOID)\n", 0);


   return;


}

DebugTrace( 0, Dbg, "InitialAllocation = %08lx.\n", FcbOrDcb->Header.

AllocationSize.LowPart);


//
//  Get a chunk of disk space that will fullfill our needs.  If there
//  was no initial allocation, start from the hint in the Vcb,

otherwise

//  try to allocate from the cluster after the initial allocation.
//
//  If there was no initial allocation to the file, we can just use

the

//  Mcb in the FcbOrDcb, otherwise we have to use a new one, and merge
//  it to the one in the FcbOrDcb.
//

Vcb = FcbOrDcb->Vcb;

_SEH2_TRY {

   if (FcbOrDcb->Header.AllocationSize.LowPart == 0) {



       LBO FirstLboOfFile;



       ASSERT( FcbOrDcb->FcbCondition == FcbGood );



       FatGetDirentFromFcbOrDcb( IrpContext,


                                 FcbOrDcb,


                                 &Dirent,


                                 &Bcb );



       ASSERT( Bcb != NULL );



       //


       //  Set this dirty right now since this call can fail.


       //



       FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE );




       FatAllocateDiskSpace( IrpContext,


                             Vcb,


                             0,


                             &DesiredAllocationSize,


                             FALSE,


                             &FcbOrDcb->Mcb );



       UnwindWeAllocatedDiskSpace = TRUE;


       McbToCleanup = &FcbOrDcb->Mcb;



       //


       //  We have to update the dirent and FcbOrDcb copies of


       //  FirstClusterOfFile since before it was 0


       //



       FatLookupMcbEntry( FcbOrDcb->Vcb,


                          &FcbOrDcb->Mcb,


                          0,


                          &FirstLboOfFile,


                          (PULONG)NULL,


                          NULL );



       DebugTrace( 0, Dbg, "First Lbo of file will be %08lx.\n",



FirstLboOfFile );


       FcbOrDcb->FirstClusterOfFile = FatGetIndexFromLbo( Vcb,



FirstLboOfFile );


       Dirent->FirstClusterOfFile = (USHORT)FcbOrDcb->



FirstClusterOfFile;


       if ( FatIsFat32(Vcb) ) {



           Dirent->FirstClusterOfFileHi = (USHORT)(FcbOrDcb->FirstClusterOfFile



...
...
16);

       }



       //


       //   Note the size of the allocation we need to tell the



cache manager about.

       //



       NewAllocation = DesiredAllocationSize;



   } else {



       LBO LastAllocatedLbo;


       VBO DontCare;



       //


       //  Get the first cluster following the current allocation.



It is possible

       //  the Mcb is empty (or short, etc.) so we need to be



slightly careful

       //  about making sure we don't lie with the hint.


       //



       (void)FatLookupLastMcbEntry( FcbOrDcb->Vcb, &FcbOrDcb->Mcb,



&DontCare, &LastAllocatedLbo, NULL );


       //


       //  Try to get some disk space starting from there.


       //



       NewAllocation = DesiredAllocationSize - FcbOrDcb->Header.



AllocationSize.LowPart;


       FsRtlInitializeLargeMcb( &NewMcb, PagedPool );


       UnwindWeInitializedMcb = TRUE;


       McbToCleanup = &NewMcb;



       FatAllocateDiskSpace( IrpContext,


                             Vcb,


                             (LastAllocatedLbo != ~0  ?


                              FatGetIndexFromLbo(Vcb,LastAllocatedLbo





:




                              0),


                             &NewAllocation,


                             FALSE,


                             &NewMcb );



       UnwindWeAllocatedDiskSpace = TRUE;


   }



   //


   //  Now that we increased the allocation of the file, mark it in



the

   //  FcbOrDcb.  Carefully prepare to handle an inability to grow



the cache

   //  structures.


   //



   FcbOrDcb->Header.AllocationSize.LowPart += NewAllocation;



   //


   //  Handle the maximal file case, where we may have just



wrapped.  Note

   //  that this must be the precise boundary case wrap, i.e. by one



byte,

   //  so that the new allocation is actually one byte "less" as far



as we're

   //  concerned.  This is important for the extension case.


   //



   if (FcbOrDcb->Header.AllocationSize.LowPart == 0) {



       NewAllocation -= 1;


       FcbOrDcb->Header.AllocationSize.LowPart = 0xffffffff;


   }



   UnwindAllocationSizeSet = TRUE;



   //


   //  Inform the cache manager to increase the section size


   //



   if ( ARGUMENT_PRESENT(FileObject) && CcIsFileCached(FileObject) )



{


       CcSetFileSizes( FileObject,


                       (PCC_FILE_SIZES)&FcbOrDcb->Header.AllocationSize



);

       UnwindCacheManagerInformed = TRUE;


   }



   //


   //  In the extension case, we have held off actually gluing the



new

   //  allocation onto the file.  This simplifies exception cleanup



since

   //  if it was already added and the section grow failed, we'd



have to

   //  do extra work to unglue it.  This way, we can assume that if



we

   //  raise the only thing we need to do is deallocate the disk



space.

   //


   //  Merge the allocation now.


   //



   if (FcbOrDcb->Header.AllocationSize.LowPart != NewAllocation) {



       //


       //  Tack the new Mcb onto the end of the FcbOrDcb one.


       //



       FatMergeAllocation( IrpContext,


                           Vcb,


                           &FcbOrDcb->Mcb,


                           &NewMcb );


   }



} _SEH2_FINALLY {

   DebugUnwind( FatAddFileAllocation );



   //


   //  Give FlushFileBuffer a clue here.


   //



   SetFlag(FcbOrDcb->FcbState, FCB_STATE_FLUSH_FAT);



   //


   //  If we were dogged trying to complete this operation, we need



to go

   //  back various things out.


   //



   if (_SEH2_AbnormalTermination()) {



       //


       //  Pull off the allocation size we tried to add to this



object if

       //  we failed to grow cache structures or Mcb structures.


       //



       if (UnwindAllocationSizeSet) {



           FcbOrDcb->Header.AllocationSize.LowPart -= NewAllocation;


       }



       if (UnwindCacheManagerInformed) {



           CcSetFileSizes( FileObject,


                           (PCC_FILE_SIZES)&FcbOrDcb->Header.AllocationSize



);

       }



       //


       //  In the case of initial allocation, we used the Fcb's Mcb



and have

       //  to clean that up as well as the FAT chain references.


       //



       if (FcbOrDcb->Header.AllocationSize.LowPart == 0) {



           if (Dirent != NULL) {



               FcbOrDcb->FirstClusterOfFile = 0;


               Dirent->FirstClusterOfFile = 0;



               if ( FatIsFat32(Vcb) ) {



                   Dirent->FirstClusterOfFileHi = 0;


               }


           }


       }



       //


       //  ... and drop the dirent Bcb if we got it.  Do it now


       //  so we can afford to take the exception if we have to.


       //



       FatUnpinBcb( IrpContext, Bcb );



       _SEH2_TRY {



           //


           //  Note this can re-raise.


           //



           if ( UnwindWeAllocatedDiskSpace ) {



               FatDeallocateDiskSpace( IrpContext, Vcb, McbToCleanup



);

           }



       } _SEH2_FINALLY {



           //


           //  We always want to clean up the non-initial allocation



temporary Mcb,

           //  otherwise we have the Fcb's Mcb and we just truncate



it away.

           //



           if (UnwindWeInitializedMcb == TRUE) {



               //


               //  Note that we already know a raise is in



progress.  No danger

               //  of encountering the normal case code below and



doing this again.

               //



               FsRtlUninitializeLargeMcb( McbToCleanup );



           } else {



               if (McbToCleanup) {



                   FsRtlTruncateLargeMcb( McbToCleanup, 0 );


               }


           }


       } _SEH2_END;


   }



   DebugTrace(-1, Dbg, "FatAddFileAllocation -> (VOID)\n", 0);


} _SEH2_END;

//
//  Non-exceptional cleanup we always want to do.  In handling the

re-raise possibilities

//  during exceptions we had to make sure these two steps always

happened there beforehand.

//  So now we handle the usual case.
//

FatUnpinBcb( IrpContext, Bcb );

if (UnwindWeInitializedMcb == TRUE) {

   FsRtlUninitializeLargeMcb( &NewMcb );


}

-}




-VOID
-FatTruncateFileAllocation (

IN PIRP_CONTEXT IrpContext,
IN PFCB FcbOrDcb,
IN ULONG DesiredAllocationSize
)


-/*++



-Routine Description:


This routine truncates the allocation to the specified file/directory.

If the file is already smaller than the indicated size then this

procedure

is effectively a noop.



-Arguments:


FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified
          This parameter must not specify the root dcb.



DesiredAllocationSize - Supplies the maximum size, in bytes, that we

want

                       allocated to the file/directory.  It is



rounded

                       up to the nearest cluster.




-Return Value:


VOID - TRUE if the operation completed and FALSE if it had to
   block but could not.




---*/



-{

PVCB Vcb;
PBCB Bcb = NULL;
LARGE_MCB RemainingMcb;
ULONG BytesPerCluster;
PDIRENT Dirent = NULL;
BOOLEAN UpdatedDirent = FALSE;

ULONG UnwindInitialAllocationSize;
ULONG UnwindInitialFirstClusterOfFile;
BOOLEAN UnwindWeAllocatedMcb = FALSE;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatTruncateFileAllocation\n", 0);
DebugTrace( 0, Dbg, "  FcbOrDcb  =             %8lx\n", FcbOrDcb);
DebugTrace( 0, Dbg, "  DesiredAllocationSize = %8lx\n",

DesiredAllocationSize);


//
//  If the Fcb isn't in good condition, we have no business whacking

around on

//  the disk after "its" clusters.
//
//  Inspired by a Prefix complaint.
//

ASSERT( FcbOrDcb->FcbCondition == FcbGood );

//
//  If we haven't yet set the correct AllocationSize, do so.
//

if (FcbOrDcb->Header.AllocationSize.QuadPart ==

FCB_LOOKUP_ALLOCATIONSIZE_HINT)  {


   FatLookupFileAllocationSize( IrpContext, FcbOrDcb );


}

//
//  Round up the Desired Allocation Size to the next cluster size
//

Vcb = FcbOrDcb->Vcb;

BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;

//
//  Note if the desired allocation is zero, to distinguish this from
//  the wrap case below.
//

if (DesiredAllocationSize != 0) {

   DesiredAllocationSize = (DesiredAllocationSize + (BytesPerCluster


1)) &
                           ~(BytesPerCluster - 1);


   //


   //  Check for the benign case that the file is already smaller



than

   //  the desired truncation.  Note that if it wraps, then a) it was


   //  specifying an offset in the maximally allocatable cluster and


   //  b) we're not asking to extend the file, either.  So stop.


   //



   if (DesiredAllocationSize == 0 ||


       DesiredAllocationSize >= FcbOrDcb->Header.AllocationSize.LowPart)



{


       DebugTrace(0, Dbg, "Desired size within current



allocation.\n", 0);


       DebugTrace(-1, Dbg, "FatTruncateFileAllocation -> (VOID)\n",



0);

       return;


   }



}

UnwindInitialAllocationSize = FcbOrDcb->Header.

AllocationSize.LowPart;

UnwindInitialFirstClusterOfFile = FcbOrDcb->FirstClusterOfFile;

//
//  Update the FcbOrDcb allocation size.  If it is now zero, we have

the

//  additional task of modifying the FcbOrDcb and Dirent copies of
//  FirstClusterInFile.
//
//  Note that we must pin the dirent before actually deallocating the
//  disk space since, in unwind, it would not be possible to

reallocate

//  deallocated disk space as someone else may have reallocated it and
//  may cause an exception when you try to get some more disk space.
//  Thus FatDeallocateDiskSpace must be the final dangerous operation.
//

_SEH2_TRY {

   FcbOrDcb->Header.AllocationSize.QuadPart = DesiredAllocationSize;



   //


   //  Special case 0


   //



   if (DesiredAllocationSize == 0) {



       //


       //  We have to update the dirent and FcbOrDcb copies of


       //  FirstClusterOfFile since before it was 0


       //



       ASSERT( FcbOrDcb->FcbCondition == FcbGood );



       FatGetDirentFromFcbOrDcb( IrpContext, FcbOrDcb, &Dirent, &Bcb



);


       ASSERT( Dirent && Bcb );



       Dirent->FirstClusterOfFile = 0;



       if (FatIsFat32(Vcb)) {



           Dirent->FirstClusterOfFileHi = 0;


       }



       FcbOrDcb->FirstClusterOfFile = 0;



       FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE );


       UpdatedDirent = TRUE;



       FatDeallocateDiskSpace( IrpContext, Vcb, &FcbOrDcb->Mcb );



       FatRemoveMcbEntry( FcbOrDcb->Vcb, &FcbOrDcb->Mcb, 0,



0xFFFFFFFF );


   } else {



       //


       //  Split the existing allocation into two parts, one we will



keep, and

       //  one we will deallocate.


       //



       FsRtlInitializeLargeMcb( &RemainingMcb, PagedPool );


       UnwindWeAllocatedMcb = TRUE;



       FatSplitAllocation( IrpContext,


                           Vcb,


                           &FcbOrDcb->Mcb,


                           DesiredAllocationSize,


                           &RemainingMcb );



       FatDeallocateDiskSpace( IrpContext, Vcb, &RemainingMcb );



       FsRtlUninitializeLargeMcb( &RemainingMcb );


   }



} _SEH2_FINALLY {

   DebugUnwind( FatTruncateFileAllocation );



   //


   //  Is this really the right backout strategy?  It would be nice



if we could

   //  pretend the truncate worked if we knew that the file had



gotten into

   //  a consistent state.  Leaving dangled clusters is probably



quite preferable.

   //



   if ( _SEH2_AbnormalTermination() ) {



       FcbOrDcb->Header.AllocationSize.LowPart =



UnwindInitialAllocationSize;


       if ( (DesiredAllocationSize == 0) && (Dirent != NULL)) {



           if (UpdatedDirent)  {



               //


               //  If the dirent has been updated ok and marked



dirty,  then we

               //  failed in deallocatediscspace,  and don't know



what state

               //  the on disc fat chain is in.  So we throw away



the mcb,

               //  and potentially loose a few clusters until the



next

               //  chkdsk.  The operation has succeeded,  but the



exception

               //  will still propogate.  5.1


               //



               FatRemoveMcbEntry( Vcb, &FcbOrDcb->Mcb, 0, 0xFFFFFFFF



);

               FcbOrDcb->Header.AllocationSize.QuadPart = 0;


           }


           else  {



               Dirent->FirstClusterOfFile = (USHORT)



UnwindInitialFirstClusterOfFile;


               if ( FatIsFat32(Vcb) ) {



                   Dirent->FirstClusterOfFileHi =


                           (USHORT)(UnwindInitialFirstClusterOfFile



...
...
16);

               }



               FcbOrDcb->FirstClusterOfFile =



UnwindInitialFirstClusterOfFile;

           }


       }



       if ( UnwindWeAllocatedMcb ) {



           FsRtlUninitializeLargeMcb( &RemainingMcb );


       }



       //


       //  Note that in the non zero truncation case,  we will also


       //  leak clusters.  However, apart from this, the in memory



and on disc

       //  structures will agree.


   }



   FatUnpinBcb( IrpContext, Bcb );



   //


   //  Give FlushFileBuffer a clue here.


   //



   SetFlag(FcbOrDcb->FcbState, FCB_STATE_FLUSH_FAT);



   DebugTrace(-1, Dbg, "FatTruncateFileAllocation -> (VOID)\n", 0);


} _SEH2_END;

-}




-VOID
-FatLookupFileAllocationSize (

IN PIRP_CONTEXT IrpContext,
IN PFCB FcbOrDcb
)


-/*++



-Routine Description:


This routine retrieves the current file allocatio size for the
specified file/directory.


-Arguments:


FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified


---*/



-{

LBO Lbo;
ULONG ByteCount;
BOOLEAN DontCare;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatLookupAllocationSize\n", 0);
DebugTrace( 0, Dbg, "  FcbOrDcb  =      %8lx\n", FcbOrDcb);

//
//  We call FatLookupFileAllocation with Vbo of 0xffffffff - 1.
//

FatLookupFileAllocation( IrpContext,
                        FcbOrDcb,


                        MAXULONG - 1,


                        &Lbo,


                        &ByteCount,


                        &DontCare,


                        &DontCare,


                        NULL );



//
//  FileSize was set at Fcb creation time from the contents of the

directory entry,

//  and we are only now looking up the real length of the allocation

chain.  If it

//  cannot be contained, this is trash.  Probably more where that

came from.

//

if (FcbOrDcb->Header.FileSize.LowPart > FcbOrDcb->Header.AllocationSize.LowPart)

{


   FatPopUpFileCorrupt( IrpContext, FcbOrDcb );


   FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );


}

DebugTrace(-1, Dbg, "FatLookupFileAllocationSize -> (VOID)\n", 0);
return;

-}




-VOID
-FatAllocateDiskSpace (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG AbsoluteClusterHint,
IN PULONG ByteCount,
IN BOOLEAN ExactMatchRequired,
OUT PLARGE_MCB Mcb
)


-/*++



-Routine Description:


This procedure allocates additional disk space and builds an mcb
representing the newly allocated space.  If the space cannot be
allocated then this procedure raises an appropriate status.

Searching starts from the hint index in the Vcb unless an alternative
non-zero hint is given in AlternateClusterHint.  If we are using the
hint field in the Vcb, it is set to the cluster following our

allocation

when we are done.

Disk space can only be allocated in cluster units so this procedure
will round up any byte count to the next cluster boundary.

Pictorially what is done is the following (where ! denotes the end of
the fat chain (i.e., FAT_CLUSTER_LAST)):


   Mcb (empty)



becomes

   Mcb |--a--|--b--|--c--!



                       ^


   ByteCount ----------+




-Arguments:


Vcb - Supplies the VCB being modified

AbsoluteClusterHint  - Supplies an alternate hint index to start the
                      search from.  If this is zero we use, and



update,

                      the Vcb hint field.



ByteCount - Supplies the number of bytes that we are requesting, and
           receives the number of bytes that we got.



ExactMatchRequired - Caller should set this to TRUE if only the

precise run requested

            is acceptable.



Mcb - Receives the MCB describing the newly allocated disk space.  The
     caller passes in an initialized Mcb that is filled in by this



procedure.


Return Value:

TRUE  - Allocated ok
FALSE - Failed to allocate exactly as requested (=>

ExactMatchRequired was TRUE)



---*/



-{

UCHAR LogOfBytesPerCluster;
ULONG BytesPerCluster;
ULONG StartingCluster;
ULONG ClusterCount;
ULONG WindowRelativeHint;

-#if DBG
-#ifndef __REACTOS__

ULONG i;

-#endif

ULONG PreviousClear;

-#endif


PFAT_WINDOW Window;
BOOLEAN Wait;
BOOLEAN Result = TRUE;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatAllocateDiskSpace\n", 0);
DebugTrace( 0, Dbg, "  Vcb        = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  *ByteCount = %8lx\n", *ByteCount);
DebugTrace( 0, Dbg, "  Mcb        = %8lx\n", Mcb);
DebugTrace( 0, Dbg, "  Hint       = %8lx\n", AbsoluteClusterHint);

ASSERT((AbsoluteClusterHint <= Vcb->AllocationSupport.NumberOfClusters



&& (1 != AbsoluteClusterHint));





//
//  Make sure byte count is not zero
//

if (*ByteCount == 0) {

   DebugTrace(0, Dbg, "Nothing to allocate.\n", 0);



   DebugTrace(-1, Dbg, "FatAllocateDiskSpace -> (VOID)\n", 0);


   return;


}

//
//  Compute the cluster count based on the byte count, rounding up
//  to the next cluster if there is any remainder.  Note that the
//  pathalogical case BytesCount == 0 has been eliminated above.
//

LogOfBytesPerCluster = Vcb->AllocationSupport.LogOfBytesPerCluster;
BytesPerCluster = 1 << LogOfBytesPerCluster;

*ByteCount = (*ByteCount + (BytesPerCluster - 1))
                       & ~(BytesPerCluster - 1);



//
//  If ByteCount is NOW zero, then we were asked for the maximal
//  filesize (or at least for bytes in the last allocatable sector).
//

if (*ByteCount == 0) {

   *ByteCount = 0xffffffff;


   ClusterCount =  1 << (32 - LogOfBytesPerCluster);



} else {

   ClusterCount = (*ByteCount >> LogOfBytesPerCluster);


}

//
//  Make sure there are enough free clusters to start with, and
//  take them now so that nobody else takes them from us.
//

ExAcquireResourceSharedLite(&Vcb->ChangeBitMapResource, TRUE);
FatLockFreeClusterBitMap( Vcb );

if (ClusterCount <= Vcb->AllocationSupport.NumberOfFreeClusters) {

   Vcb->AllocationSupport.NumberOfFreeClusters -= ClusterCount;



} else {

   FatUnlockFreeClusterBitMap( Vcb );


   ExReleaseResourceLite(&Vcb->ChangeBitMapResource);



   DebugTrace(0, Dbg, "Disk Full.  Raise Status.\n", 0);


   FatRaiseStatus( IrpContext, STATUS_DISK_FULL );


}

//
//  Did the caller supply a hint?
//

if ((0 != AbsoluteClusterHint) && (AbsoluteClusterHint <

(Vcb->AllocationSupport.NumberOfClusters + 2)))  {


   if (Vcb->NumberOfWindows > 1)  {



       //


       //  If we're being called upon to allocate clusters outside



the

       //  current window (which happens only via MoveFile), it's a



problem.

       //  We address this by changing the current window to be the



one which

       //  contains the alternate cluster hint.  Note that if the



user's

       //  request would cross a window boundary, he doesn't really



get what

       //  he wanted.


       //



       if (AbsoluteClusterHint < Vcb->CurrentWindow->FirstCluster ||


           AbsoluteClusterHint > Vcb->CurrentWindow->LastCluster) {



           ULONG BucketNum = FatWindowOfCluster( AbsoluteClusterHint



);


           ASSERT( BucketNum < Vcb->NumberOfWindows);



           //


           //  Drop our shared lock on the ChangeBitMapResource,



and pick it up again

           //  exclusive in preparation for making the window swap.


           //



           FatUnlockFreeClusterBitMap(Vcb);


           ExReleaseResourceLite(&Vcb->ChangeBitMapResource);


           ExAcquireResourceExclusiveLite(&Vcb->ChangeBitMapResource,



TRUE);

           FatLockFreeClusterBitMap(Vcb);



           Window = &Vcb->Windows[BucketNum];



           //


           //  Again,  test the current window against the one we



want - some other

           //  thread could have sneaked in behind our backs and



kindly set it to the one

           //  we need,  when we dropped and reacquired the



ChangeBitMapResource above.

           //



           if (Window != Vcb->CurrentWindow)  {



               _SEH2_TRY {



                   Wait = BooleanFlagOn(IrpContext->Flags,



IRP_CONTEXT_FLAG_WAIT);

                   SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);



                   //


                   //  Change to the new window (update



Vcb->CurrentWindow) and scan it

                   //  to build up a freespace bitmap etc.


                   //



                   FatExamineFatEntries( IrpContext, Vcb,


                                         0,


                                         0,


                                         FALSE,


                                         Window,


                                         NULL);



               } _SEH2_FINALLY {



                   if (!Wait) {



                       ClearFlag(IrpContext->Flags,



IRP_CONTEXT_FLAG_WAIT);

                   }



                   if (_SEH2_AbnormalTermination()) {



                       //


                       //  We will have raised as a result of



failing to pick up the

                       //  chunk of the FAT for this window move.



Release our resources

                       //  and return the cluster count to the



volume.

                       //



                       Vcb->AllocationSupport.NumberOfFreeClusters



+= ClusterCount;


                       FatUnlockFreeClusterBitMap( Vcb );


                       ExReleaseResourceLite(&Vcb->



ChangeBitMapResource);

                   }


               } _SEH2_END;


           }


       }



       //


       //  Make the hint cluster number relative to the base of the



current window...

       //


       //  Currentwindow->Firstcluster is baised by +2 already,  so



we will lose the

       //  bias already in AbsoluteClusterHint.  Put it back....


       //



       WindowRelativeHint = AbsoluteClusterHint -



Vcb->CurrentWindow->FirstCluster + 2;

   }


   else {



       //


       //  Only one 'window',  ie fat16/12.  No modification



necessary.

       //



       WindowRelativeHint = AbsoluteClusterHint;


   }


}
else {

   //


   //  Either no hint supplied,  or it was out of range,  so grab



one from the Vcb

   //


   //  NOTE: Clusterhint in the Vcb is not guaranteed to be set (may



be -1)

   //



   WindowRelativeHint = Vcb->ClusterHint;


   AbsoluteClusterHint = 0;



   //


   //  Vcb hint may not have been initialized yet.  Force to valid



cluster.

   //



   if (-1 == WindowRelativeHint)  {



       WindowRelativeHint = 2;


   }


}

ASSERT((WindowRelativeHint >= 2) && (WindowRelativeHint <

Vcb->FreeClusterBitMap.SizeOfBitMap + 2));


//
//  Keep track of the window we're allocating from, so we can clean
//  up correctly if the current window changes after we unlock the
//  bitmap.
//

Window = Vcb->CurrentWindow;

//
//  Try to find a run of free clusters large enough for us.
//

StartingCluster = FatFindFreeClusterRun( IrpContext,
                                        Vcb,


                                        ClusterCount,


                                        WindowRelativeHint );


//
//  If the above call was successful, we can just update the fat
//  and Mcb and exit.  Otherwise we have to look for smaller free
//  runs.
//
//  This test is a bit funky. Note that the error return from
//  RtlFindClearBits is -1, and adding two to that is 1.
//

if ((StartingCluster != 1) &&
   ((0 == AbsoluteClusterHint) || (StartingCluster ==



WindowRelativeHint))

)  {


-#if DBG

   PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap );



-#endif // DBG


   //


   //  Take the clusters we found, and unlock the bit map.


   //



   FatReserveClusters(IrpContext, Vcb, StartingCluster,



ClusterCount);


   Window->ClustersFree -= ClusterCount;



   StartingCluster += Window->FirstCluster;


   StartingCluster -= 2;



   ASSERT( PreviousClear - ClusterCount == Window->ClustersFree );



   FatUnlockFreeClusterBitMap( Vcb );



   //


   //  Note that this call will never fail since there is always


   //  room for one entry in an empty Mcb.


   //



   FatAddMcbEntry( Vcb, Mcb,


                   0,


                   FatGetLboFromIndex( Vcb, StartingCluster ),


                   *ByteCount);


   _SEH2_TRY {



       //


       //  Update the fat.


       //



       FatAllocateClusters(IrpContext, Vcb,


                           StartingCluster,


                           ClusterCount);



   } _SEH2_FINALLY {



       DebugUnwind( FatAllocateDiskSpace );



       //


       //  If the allocate clusters failed, remove the run from the



Mcb,

       //  unreserve the clusters, and reset the free cluster count.


       //



       if (_SEH2_AbnormalTermination()) {



           FatRemoveMcbEntry( Vcb, Mcb, 0, *ByteCount );



           FatLockFreeClusterBitMap( Vcb );



           //  Only clear bits if the bitmap window is the same.



           if (Window == Vcb->CurrentWindow) {



               //  Both values (startingcluster and



window->firstcluster) are

               //  already biased by 2,  so will cancel,  so we need



to add in the 2 again.


               FatUnreserveClusters( IrpContext, Vcb,


                                     StartingCluster -



Window->FirstCluster + 2,

                                     ClusterCount );


           }



           Window->ClustersFree += ClusterCount;


           Vcb->AllocationSupport.NumberOfFreeClusters +=



ClusterCount;


           FatUnlockFreeClusterBitMap( Vcb );


       }



       ExReleaseResourceLite(&Vcb->ChangeBitMapResource);


   } _SEH2_END;



} else {

   //


   //  Note that Index is a zero-based window-relative number.  When



appropriate

   //  it'll get converted into a true cluster number and put in



Cluster, which

   //  will be a volume relative true cluster number.


   //



   ULONG Index;


   ULONG Cluster;


   ULONG CurrentVbo;


   ULONG PriorLastCluster;


   ULONG BytesFound;



   ULONG ClustersFound = 0;


   ULONG ClustersRemaining;



   BOOLEAN LockedBitMap = FALSE;


   BOOLEAN SelectNextContigWindow = FALSE;



   //


   //  Drop our shared lock on the ChangeBitMapResource,  and pick



it up again

   //  exclusive in preparation for making a window swap.


   //



   FatUnlockFreeClusterBitMap(Vcb);


   ExReleaseResourceLite(&Vcb->ChangeBitMapResource);


   ExAcquireResourceExclusiveLite(&Vcb->ChangeBitMapResource, TRUE);


   FatLockFreeClusterBitMap(Vcb);


   LockedBitMap = TRUE;



   _SEH2_TRY {



       if ( ExactMatchRequired && (1 == Vcb->NumberOfWindows))  {



           //


           //  Give up right now,  there are no more windows to



search!  RtlFindClearBits

           //  searchs the whole bitmap,  so we would have found any



contiguous run

           //  large enough.


           //



           try_leave( Result = FALSE);


       }



       //


       //  While the request is still incomplete, look for the



largest

       //  run of free clusters, mark them taken, allocate the run in


       //  the Mcb and Fat, and if this isn't the first time through


       //  the loop link it to prior run on the fat.  The Mcb will


       //  coalesce automatically.


       //



       ClustersRemaining = ClusterCount;


       CurrentVbo = 0;


       PriorLastCluster = 0;



       while (ClustersRemaining != 0) {



           //


           //  If we just entered the loop, the bit map is already



locked

           //



           if ( !LockedBitMap ) {



               FatLockFreeClusterBitMap( Vcb );


               LockedBitMap = TRUE;


           }



           //


           //  Find the largest run of free clusters.  If the run is


           //  bigger than we need, only use what we need.  Note that


           //  this will then be the last while() iteration.


           //



           // 12/3/95: need to bias bitmap by 2 bits for the defrag


           // hooks and the below macro became impossible to do



without in-line

           // procedures.


           //


           // ClustersFound = FatLongestFreeClusterRun( IrpContext,



Vcb, &Index );


           ClustersFound = 0;



           if (!SelectNextContigWindow)  {



               if ( 0 != WindowRelativeHint)  {



                   ULONG Desired = Vcb->FreeClusterBitMap.SizeOfBitMap


(WindowRelativeHint - 2);

                   //


                   //  We will try to allocate contiguously.  Try



from the current hint the to

                   //  end of current window.  Don't try for more



than we actually need.

                   //



                   if (Desired > ClustersRemaining)  {



                       Desired = ClustersRemaining;


                   }



                   if (RtlAreBitsClear(  &Vcb->FreeClusterBitMap,


                                         WindowRelativeHint - 2,


                                         Desired))


                   {


                       //


                       //  Clusters from hint->...windowend are



free.  Take them.

                       //



                       Index = WindowRelativeHint - 2;


                       ClustersFound = Desired;



                       if (FatIsFat32(Vcb))  {



                           //


                           //  We're now up against the end of the



current window,  so indicate that we

                           //  want the next window in the sequence



next time around.  (If we're not up

                           //  against the end of the window,  then



we got what we needed and won't be

                           //  coming around again anyway).


                           //



                           SelectNextContigWindow = TRUE;


                           WindowRelativeHint = 2;


                       }


                       else {



                           //


                           //  FAT 12/16 - we've run up against the



end of the volume.  Clear the

                           //  hint,  since we now have no idea



where to look.

                           //



                           WindowRelativeHint = 0;


                       }



-#if DBG

                       PreviousClear = RtlNumberOfClearBits(



&Vcb->FreeClusterBitMap );
-#endif // DBG

                   }


                   else  {



                       if (ExactMatchRequired)  {



                           //


                           //  If our caller required an exact



match,  then we're hosed.  Bail out now.

                           //



                           try_leave( Result = FALSE);


                       }



                       //


                       //  Hint failed,  drop back to pot luck


                       //



                       WindowRelativeHint = 0;


                   }


               }



               if ((0 == WindowRelativeHint) && (0 ==



ClustersFound)) {


                   if (ClustersRemaining <= Vcb->CurrentWindow->ClustersFree)



{


                       //


                       //  The remaining allocation could be



satisfied entirely from this

                       //  window.  We will ask only for what we



need,  to try and avoid

                       //  unnecessarily fragmenting large runs of



space by always using

                       //  (part of) the largest run we can find.



This call will return the

                       //  first run large enough.


                       //



                       Index = RtlFindClearBits(



&Vcb->FreeClusterBitMap,  ClustersRemaining,  0);


                       if (-1 != Index)  {



                           ClustersFound = ClustersRemaining;


                       }


                   }



                   if (0 == ClustersFound)  {



                       //


                       //  Still nothing,  so just take the largest



free run we can find.

                       //



                       ClustersFound = RtlFindLongestRunClear(



&Vcb->FreeClusterBitMap, &Index );


                   }



-#if DBG

                   PreviousClear = RtlNumberOfClearBits(



&Vcb->FreeClusterBitMap );
-#endif // DBG

                   if (ClustersFound >= ClustersRemaining) {



                       ClustersFound = ClustersRemaining;


                   }


                   else {



                       //


                       //  If we just ran up to the end of a



window,  set up a hint that

                       //  we'd like the next consecutive window



after this one. (FAT32 only)

                       //



                       if ( ((Index + ClustersFound) ==



Vcb->FreeClusterBitMap.SizeOfBitMap) &&

                            FatIsFat32( Vcb)


                          )  {



                           SelectNextContigWindow = TRUE;


                           WindowRelativeHint = 2;


                       }


                   }


               }


           }



           if (ClustersFound == 0) {



               ULONG FaveWindow = 0;


               BOOLEAN SelectedWindow;



               //


               //  If we found no free clusters on a single-window



FAT,

               //  there was a bad problem with the free cluster



count.

               //



               if (1 == Vcb->NumberOfWindows) {



                   FatBugCheck( 0, 5, 0 );


               }



               //


               //  Switch to a new bucket.  Possibly the next one if



we're

               //  currently on a roll (allocating contiguously)


               //



               SelectedWindow = FALSE;



               if ( SelectNextContigWindow)  {



                   ULONG NextWindow;



                   NextWindow = (((ULONG)((PUCHAR)Vcb->CurrentWindow


(PUCHAR)Vcb->Windows)) / sizeof( FAT_WINDOW)) + 1;

                   if ((NextWindow < Vcb->NumberOfWindows) &&


                       ( Vcb->Windows[ NextWindow].ClustersFree > 0)


                      )  {



                       FaveWindow = NextWindow;


                       SelectedWindow = TRUE;


                   }


                   else  {



                       if (ExactMatchRequired)  {



                           //


                           //  Some dope tried to allocate a run



past the end of the volume...

                           //



                           try_leave( Result = FALSE);


                       }



                       //


                       //  Give up on the contiguous allocation



attempts

                       //



                       WindowRelativeHint = 0;


                   }



                   SelectNextContigWindow = FALSE;


               }



               if (!SelectedWindow)  {



                   //


                   //  Select a new window to begin allocating from


                   //



                   FaveWindow = FatSelectBestWindow( Vcb);


               }



               //


               //  By now we'd better have found a window with some



free clusters

               //



               if (0 == Vcb->Windows[ FaveWindow].ClustersFree) {



                   FatBugCheck( 0, 5, 1 );


               }



               Wait = BooleanFlagOn(IrpContext->Flags,



IRP_CONTEXT_FLAG_WAIT);

               SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);



               FatExamineFatEntries( IrpContext, Vcb,


                                     0,


                                     0,


                                     FALSE,


                                     &Vcb->Windows[FaveWindow],


                                     NULL);



               if (!Wait) {



                   ClearFlag(IrpContext->Flags,



IRP_CONTEXT_FLAG_WAIT);

               }



               //


               //  Now we'll just go around the loop again, having



switched windows,

               //  and allocate....


               //



-#if DBG

               PreviousClear = RtlNumberOfClearBits(



&Vcb->FreeClusterBitMap );
-#endif //DBG

           }       // if (clustersfound == 0)


           else  {



               //


               //  Take the clusters we found, convert our index to



a cluster number

               //  and unlock the bit map.


               //



               Window = Vcb->CurrentWindow;



               FatReserveClusters( IrpContext, Vcb, (Index + 2),



ClustersFound );


               Cluster = Index + Window->FirstCluster;



               Window->ClustersFree -= ClustersFound;


               ASSERT( PreviousClear - ClustersFound ==



Window->ClustersFree );


               FatUnlockFreeClusterBitMap( Vcb );


               LockedBitMap = FALSE;



               //


               //  Add the newly alloced run to the Mcb.


               //



               BytesFound = ClustersFound << LogOfBytesPerCluster;



               FatAddMcbEntry( Vcb, Mcb,


                               CurrentVbo,


                               FatGetLboFromIndex( Vcb, Cluster ),


                               BytesFound );



               //


               //  Connect the last allocated run with this one, and



allocate

               //  this run on the Fat.


               //



               if (PriorLastCluster != 0) {



                   FatSetFatEntry( IrpContext,


                                   Vcb,


                                   PriorLastCluster,


                                   (FAT_ENTRY)Cluster );


               }



               //


               //  Update the fat


               //



               FatAllocateClusters( IrpContext, Vcb, Cluster,



ClustersFound );


               //


               //  Prepare for the next iteration.


               //



               CurrentVbo += BytesFound;


               ClustersRemaining -= ClustersFound;


               PriorLastCluster = Cluster + ClustersFound - 1;


           }


       }  // while (clustersremaining)



   } _SEH2_FINALLY {



       DebugUnwind( FatAllocateDiskSpace );



       ExReleaseResourceLite(&Vcb->ChangeBitMapResource);



       //


       //  Is there any unwinding to do?


       //



       if ( _SEH2_AbnormalTermination() || (FALSE == Result)) {



           //


           //  Flag to the caller that they're getting nothing


           //



           *ByteCount = 0;



           //


           //  There are three places we could have taken this



exception:

           //  when switching the window (FatExamineFatEntries),



adding

           //  a found run to the Mcb (FatAddMcbEntry), or when



writing

           //  the changes to the FAT (FatSetFatEntry).  In the



first case

           //  we don't have anything to unwind before deallocation,



and

           //  can detect this by seeing if we have the ClusterBitmap


           //  mutex out.



           if (!LockedBitMap) {



               FatLockFreeClusterBitMap( Vcb );



               //


               //  In these cases, we have the possiblity that the



FAT

               //  window is still in place and we need to clear the



bits.

               //  If the Mcb entry isn't there (we raised trying to



add

               //  it), the effect of trying to remove it is a noop.


               //



               if (Window == Vcb->CurrentWindow) {



                   //


                   //  Cluster reservation works on cluster 2 based



window-relative

                   //  numbers, so we must convert.  The subtraction



will lose the

                   //  cluster 2 base, so bias the result.


                   //



                   FatUnreserveClusters( IrpContext, Vcb,


                                         (Cluster -



Window->FirstCluster) + 2,

                                         ClustersFound );


               }



               //


               //  Note that FatDeallocateDiskSpace will take care



of adjusting

               //  to account for the entries in the Mcb.  All we



have to account

               //  for is the last run that didn't make it.


               //



               Window->ClustersFree += ClustersFound;


               Vcb->AllocationSupport.NumberOfFreeClusters +=



ClustersFound;


               FatUnlockFreeClusterBitMap( Vcb );



               FatRemoveMcbEntry( Vcb, Mcb, CurrentVbo, BytesFound );



           } else {



               //


               //  Just drop the mutex now - we didn't manage to do



anything

               //  that needs to be backed out.


               //



               FatUnlockFreeClusterBitMap( Vcb );


           }



           _SEH2_TRY {



               //


               //  Now we have tidied up, we are ready to just send



the Mcb

               //  off to deallocate disk space


               //



               FatDeallocateDiskSpace( IrpContext, Vcb, Mcb );



           } _SEH2_FINALLY {



               //


               //  Now finally (really), remove all the entries from



the mcb

               //



               FatRemoveMcbEntry( Vcb, Mcb, 0, 0xFFFFFFFF );


           } _SEH2_END;


       }



       DebugTrace(-1, Dbg, "FatAllocateDiskSpace -> (VOID)\n", 0);



   } _SEH2_END; // finally


}

return;

-}




-VOID
-FatDeallocateDiskSpace (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN PLARGE_MCB Mcb
)


-/*++



-Routine Description:


This procedure deallocates the disk space denoted by an input
mcb.  Note that the input MCB does not need to necessarily describe
a chain that ends with a FAT_CLUSTER_LAST entry.

Pictorially what is done is the following

   Fat |--a--|--b--|--c--|


   Mcb |--a--|--b--|--c--|



becomes

   Fat |--0--|--0--|--0--|


   Mcb |--a--|--b--|--c--|




-Arguments:


Vcb - Supplies the VCB being modified

Mcb - Supplies the MCB describing the disk space to deallocate.  Note
     that Mcb is unchanged by this procedure.





-Return Value:


None.


---*/



-{

LBO Lbo;
VBO Vbo;

ULONG RunsInMcb;
ULONG ByteCount;
ULONG ClusterCount;
ULONG ClusterIndex;
ULONG McbIndex;

UCHAR LogOfBytesPerCluster;

PFAT_WINDOW Window;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatDeallocateDiskSpace\n", 0);
DebugTrace( 0, Dbg, "  Vcb = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  Mcb = %8lx\n", Mcb);

LogOfBytesPerCluster = Vcb->AllocationSupport.LogOfBytesPerCluster;

RunsInMcb = FsRtlNumberOfRunsInLargeMcb( Mcb );

if ( RunsInMcb == 0 ) {

   DebugTrace(-1, Dbg, "FatDeallocateDiskSpace -> (VOID)\n", 0);


   return;


}

_SEH2_TRY {

   //


   //  Run though the Mcb, freeing all the runs in the fat.


   //


   //  We do this in two steps (first update the fat, then the bitmap


   //  (which can't fail)) to prevent other people from taking



clusters

   //  that we need to re-allocate in the event of unwind.


   //



   ExAcquireResourceSharedLite(&Vcb->ChangeBitMapResource, TRUE);



   RunsInMcb = FsRtlNumberOfRunsInLargeMcb( Mcb );



   for ( McbIndex = 0; McbIndex < RunsInMcb; McbIndex++ ) {



       FatGetNextMcbEntry( Vcb, Mcb, McbIndex, &Vbo, &Lbo,



&ByteCount );


       //


       //  Assert that Fat files have no holes.


       //



       ASSERT( Lbo != 0 );



       //


       //  Write FAT_CLUSTER_AVAILABLE to each cluster in the run.


       //



       ClusterCount = ByteCount >> LogOfBytesPerCluster;


       ClusterIndex = FatGetIndexFromLbo( Vcb, Lbo );



       FatFreeClusters( IrpContext, Vcb, ClusterIndex, ClusterCount



);

   }



   //


   //  From now on, nothing can go wrong .... (as in raise)


   //



   FatLockFreeClusterBitMap( Vcb );



   for ( McbIndex = 0; McbIndex < RunsInMcb; McbIndex++ ) {



       ULONG ClusterEnd;


       ULONG MyStart, MyLength, count;



-#if DBG
-#ifndef __REACTOS__

       ULONG PreviousClear, i;



-#else

       ULONG i;



-#endif
-#endif


       FatGetNextMcbEntry( Vcb, Mcb, McbIndex, &Vbo, &Lbo,



&ByteCount );


       //


       //  Mark the bits clear in the FreeClusterBitMap.


       //



       ClusterCount = ByteCount >> LogOfBytesPerCluster;


       ClusterIndex = FatGetIndexFromLbo( Vcb, Lbo );



       Window = Vcb->CurrentWindow;



       //


       //  If we've divided the bitmap, elide bitmap manipulation for


       //  runs that are outside the current bucket.


       //



       ClusterEnd = ClusterIndex + ClusterCount - 1;



       if (!(ClusterIndex > Window->LastCluster ||


             ClusterEnd  < Window->FirstCluster)) {



           //


           //  The run being freed overlaps the current bucket, so



we'll

           //  have to clear some bits.


           //



           if (ClusterIndex < Window->FirstCluster &&


               ClusterEnd > Window->LastCluster) {



               MyStart = Window->FirstCluster;


               MyLength = Window->LastCluster - Window->FirstCluster




1;



           } else if (ClusterIndex < Window->FirstCluster) {



               MyStart = Window->FirstCluster;


               MyLength = ClusterEnd - Window->FirstCluster + 1;



           } else {



               //


               //  The range being freed starts in the bucket, and



may possibly

               //  extend beyond the bucket.


               //



               MyStart = ClusterIndex;



               if (ClusterEnd <= Window->LastCluster) {



                   MyLength = ClusterCount;



               } else {



                   MyLength = Window->LastCluster - ClusterIndex + 1;


               }


           }



           if (MyLength == 0) {



               continue;


           }




-#if DBG
-#ifndef __REACTOS__

           PreviousClear = RtlNumberOfClearBits(



&Vcb->FreeClusterBitMap );
-#endif



           //


           //  Verify that the Bits are all really set.


           //



           ASSERT( MyStart + MyLength - Window->FirstCluster <=



Vcb->FreeClusterBitMap.SizeOfBitMap );


           for (i = 0; i < MyLength; i++) {



               ASSERT( RtlCheckBit(&Vcb->FreeClusterBitMap,


                       MyStart - Window->FirstCluster + i) == 1 );


           }



-#endif // DBG


           FatUnreserveClusters( IrpContext, Vcb,


                                 MyStart - Window->FirstCluster + 2,


                                 MyLength );


       }



       //


       //  Adjust the ClustersFree count for each bitmap window,



even the ones

       //  that are not the current window.


       //



       if (FatIsFat32(Vcb)) {



           Window = &Vcb->Windows[FatWindowOfCluster( ClusterIndex



)];


       } else {



           Window = &Vcb->Windows[0];


       }



       MyStart = ClusterIndex;



       for (MyLength = ClusterCount; MyLength > 0; MyLength -=



count) {


           count = FatMin(Window->LastCluster - MyStart + 1,



MyLength);

           Window->ClustersFree += count;



           //


           //  If this was not the last window this allocation



spanned,

           //  advance to the next.


           //



           if (MyLength != count) {



               Window++;


               MyStart = Window->FirstCluster;


           }


       }



       //


       //  Deallocation is now complete.  Adjust the free cluster



count.

       //



       Vcb->AllocationSupport.NumberOfFreeClusters += ClusterCount;


   }




-#if DBG

   if (Vcb->CurrentWindow->ClustersFree !=


          RtlNumberOfClearBits(&Vcb->FreeClusterBitMap)) {



       DbgPrint("%x vs %x\n",  Vcb->CurrentWindow->ClustersFree,


           RtlNumberOfClearBits(&Vcb->FreeClusterBitMap));



       DbgPrint("%x for %x\n", ClusterIndex, ClusterCount);


   }



-#endif


   FatUnlockFreeClusterBitMap( Vcb );




} _SEH2_FINALLY {

   DebugUnwind( FatDeallocateDiskSpace );



   //


   //  Is there any unwinding to do?


   //



   ExReleaseResourceLite(&Vcb->ChangeBitMapResource);



   if ( _SEH2_AbnormalTermination() ) {



       LBO Lbo;


       VBO Vbo;



       ULONG Index;


       ULONG Clusters;


       ULONG FatIndex;


       ULONG PriorLastIndex;



       //


       //  For each entry we already deallocated, reallocate it,


       //  chaining together as nessecary.  Note that we continue


       //  up to and including the last "for" iteration even though


       //  the SetFatRun could not have been successful.  This


       //  allows us a convienent way to re-link the final successful


       //  SetFatRun.


       //


       //  It is possible that the reason we got here will prevent us


       //  from succeeding in this operation.


       //



       PriorLastIndex = 0;



       for (Index = 0; Index <= McbIndex; Index++) {



           FatGetNextMcbEntry(Vcb, Mcb, Index, &Vbo, &Lbo,



&ByteCount);


           FatIndex = FatGetIndexFromLbo( Vcb, Lbo );


           Clusters = ByteCount >> LogOfBytesPerCluster;



           //


           //  We must always restore the prior iteration's last


           //  entry, pointing it to the first cluster of this run.


           //



           if (PriorLastIndex != 0) {



               FatSetFatEntry( IrpContext,


                               Vcb,


                               PriorLastIndex,


                               (FAT_ENTRY)FatIndex );


           }



           //


           //  If this is not the last entry (the one that failed)


           //  then reallocate the disk space on the fat.


           //



           if ( Index < McbIndex ) {



               FatAllocateClusters(IrpContext, Vcb, FatIndex,



Clusters);


               PriorLastIndex = FatIndex + Clusters - 1;


           }


       }


   }



   DebugTrace(-1, Dbg, "FatDeallocateDiskSpace -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-VOID
-FatSplitAllocation (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN OUT PLARGE_MCB Mcb,
IN VBO SplitAtVbo,
OUT PLARGE_MCB RemainingMcb
)


-/*++



-Routine Description:


This procedure takes a single mcb and splits its allocation into
two separate allocation units.  The separation must only be done
on cluster boundaries, otherwise we bugcheck.

On the disk this actually works by inserting a FAT_CLUSTER_LAST into
the last index of the first part being split out.

Pictorially what is done is the following (where ! denotes the end of
the fat chain (i.e., FAT_CLUSTER_LAST)):


   Mcb          |--a--|--b--|--c--|--d--|--e--|--f--|



                                   ^


   SplitAtVbo ---------------------+



   RemainingMcb (empty)



becomes

   Mcb          |--a--|--b--|--c--!




   RemainingMcb |--d--|--e--|--f--|




-Arguments:


Vcb - Supplies the VCB being modified

Mcb - Supplies the MCB describing the allocation being split into
     two parts.  Upon return this Mcb now contains the first chain.



SplitAtVbo - Supplies the VBO of the first byte for the second chain
            that we creating.



RemainingMcb - Receives the MCB describing the second chain of

allocated

              disk space.  The caller passes in an initialized Mcb



that

              is filled in by this procedure STARTING AT VBO 0.




-Return Value:


VOID - TRUE if the operation completed and FALSE if it had to
          block but could not.




---*/



-{

VBO SourceVbo;
VBO TargetVbo;
VBO DontCare;

LBO Lbo;

ULONG ByteCount;
ULONG BytesPerCluster;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatSplitAllocation\n", 0);
DebugTrace( 0, Dbg, "  Vcb          = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  Mcb          = %8lx\n", Mcb);
DebugTrace( 0, Dbg, "  SplitAtVbo   = %8lx\n", SplitAtVbo);
DebugTrace( 0, Dbg, "  RemainingMcb = %8lx\n", RemainingMcb);

BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;

//
//  Assert that the split point is cluster alligned
//

ASSERT( (SplitAtVbo & (BytesPerCluster - 1)) == 0 );

//
//  We should never be handed an empty source MCB and asked to split
//  at a non zero point.
//

ASSERT( !((0 != SplitAtVbo) && (0 == FsRtlNumberOfRunsInLargeMcb(

Mcb))));


//
//  Assert we were given an empty target Mcb.
//

//
//  This assert is commented out to avoid hitting in the Ea error
//  path.  In that case we will be using the same Mcb's to split the
//  allocation that we used to merge them.  The target Mcb will

contain

//  the runs that the split will attempt to insert.
//
//
//  ASSERT( FsRtlNumberOfRunsInMcb( RemainingMcb ) == 0 );
//

_SEH2_TRY {

   //


   //  Move the runs after SplitAtVbo from the souce to the target


   //



   SourceVbo = SplitAtVbo;


   TargetVbo = 0;



   while (FatLookupMcbEntry(Vcb, Mcb, SourceVbo, &Lbo, &ByteCount,



NULL)) {


       FatAddMcbEntry( Vcb, RemainingMcb, TargetVbo, Lbo, ByteCount



);


       FatRemoveMcbEntry( Vcb, Mcb, SourceVbo, ByteCount );



       TargetVbo += ByteCount;


       SourceVbo += ByteCount;



       //


       //  If SourceVbo overflows, we were actually snipping off the



end

       //  of the maximal file ... and are now done.


       //



       if (SourceVbo == 0) {



           break;


       }


   }



   //


   //  Mark the last pre-split cluster as a FAT_LAST_CLUSTER


   //



   if ( SplitAtVbo != 0 ) {



       FatLookupLastMcbEntry( Vcb, Mcb, &DontCare, &Lbo, NULL );



       FatSetFatEntry( IrpContext,


                       Vcb,


                       FatGetIndexFromLbo( Vcb, Lbo ),


                       FAT_CLUSTER_LAST );


   }



} _SEH2_FINALLY {

   DebugUnwind( FatSplitAllocation );



   //


   //  If we got an exception, we must glue back together the Mcbs


   //



   if ( _SEH2_AbnormalTermination() ) {



       TargetVbo = SplitAtVbo;


       SourceVbo = 0;



       while (FatLookupMcbEntry(Vcb, RemainingMcb, SourceVbo, &Lbo,



&ByteCount, NULL)) {


           FatAddMcbEntry( Vcb, Mcb, TargetVbo, Lbo, ByteCount );



           FatRemoveMcbEntry( Vcb, RemainingMcb, SourceVbo,



ByteCount );


           TargetVbo += ByteCount;


           SourceVbo += ByteCount;


       }


   }



   DebugTrace(-1, Dbg, "FatSplitAllocation -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-VOID
-FatMergeAllocation (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN OUT PLARGE_MCB Mcb,
IN PLARGE_MCB SecondMcb
)


-/*++



-Routine Description:


This routine takes two separate allocations described by two MCBs and
joins them together into one allocation.

Pictorially what is done is the following (where ! denotes the end of
the fat chain (i.e., FAT_CLUSTER_LAST)):


   Mcb       |--a--|--b--|--c--!



   SecondMcb |--d--|--e--|--f--|



becomes

   Mcb       |--a--|--b--|--c--|--d--|--e--|--f--|



   SecondMcb |--d--|--e--|--f--|





-Arguments:


Vcb - Supplies the VCB being modified

Mcb - Supplies the MCB of the first allocation that is being modified.
     Upon return this Mcb will also describe the newly enlarged


     allocation



SecondMcb - Supplies the ZERO VBO BASED MCB of the second allocation
           that is being appended to the first allocation.  This


           procedure leaves SecondMcb unchanged.




-Return Value:


VOID - TRUE if the operation completed and FALSE if it had to
   block but could not.




---*/



-{

VBO SpliceVbo;
LBO SpliceLbo;

VBO SourceVbo;
VBO TargetVbo;

LBO Lbo;

ULONG ByteCount;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatMergeAllocation\n", 0);
DebugTrace( 0, Dbg, "  Vcb       = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  Mcb       = %8lx\n", Mcb);
DebugTrace( 0, Dbg, "  SecondMcb = %8lx\n", SecondMcb);

_SEH2_TRY {

   //


   //  Append the runs from SecondMcb to Mcb


   //



   (void)FatLookupLastMcbEntry( Vcb, Mcb, &SpliceVbo, &SpliceLbo,



NULL );


   SourceVbo = 0;


   TargetVbo = SpliceVbo + 1;



   while (FatLookupMcbEntry(Vcb, SecondMcb, SourceVbo, &Lbo,



&ByteCount, NULL)) {


       FatAddMcbEntry( Vcb, Mcb, TargetVbo, Lbo, ByteCount );



       SourceVbo += ByteCount;


       TargetVbo += ByteCount;


   }



   //


   //  Link the last pre-merge cluster to the first cluster of



SecondMcb

   //



   FatLookupMcbEntry( Vcb, SecondMcb, 0, &Lbo, (PULONG)NULL, NULL );



   FatSetFatEntry( IrpContext,


                   Vcb,


                   FatGetIndexFromLbo( Vcb, SpliceLbo ),


                   (FAT_ENTRY)FatGetIndexFromLbo( Vcb, Lbo ) );



} _SEH2_FINALLY {

   DebugUnwind( FatMergeAllocation );



   //


   //  If we got an exception, we must remove the runs added to Mcb


   //



   if ( _SEH2_AbnormalTermination() ) {



       ULONG CutLength;



       if ((CutLength = TargetVbo - (SpliceVbo + 1)) != 0) {



           FatRemoveMcbEntry( Vcb, Mcb, SpliceVbo + 1, CutLength);


       }


   }



   DebugTrace(-1, Dbg, "FatMergeAllocation -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-//
-//  Internal support routine
-//



-CLUSTER_TYPE
-FatInterpretClusterType (

IN PVCB Vcb,
IN FAT_ENTRY Entry
)


-/*++



-Routine Description:


This procedure tells the caller how to interpret the input fat table
entry.  It will indicate if the fat cluster is available, resereved,
bad, the last one, or the another fat index.  This procedure can deal
with both 12 and 16 bit fat.


-Arguments:


Vcb - Supplies the Vcb to examine, yields 12/16 bit info

Entry - Supplies the fat entry to examine


-Return Value:


CLUSTER_TYPE - Is the type of the input Fat entry


---*/



-{

DebugTrace(+1, Dbg, "InterpretClusterType\n", 0);
DebugTrace( 0, Dbg, "  Vcb   = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  Entry = %8lx\n", Entry);

PAGED_CODE();

switch(Vcb->AllocationSupport.FatIndexBitSize ) {
case 32:
   Entry &= FAT32_ENTRY_MASK;


   break;



case 12:
   ASSERT( Entry <= 0xfff );


   if (Entry >= 0x0ff0) {


       Entry |= 0x0FFFF000;


   }


   break;



default:
case 16:
   ASSERT( Entry <= 0xffff );


   if (Entry >= 0x0fff0) {


       Entry |= 0x0FFF0000;


   }


   break;


}

if (Entry == FAT_CLUSTER_AVAILABLE) {

   DebugTrace(-1, Dbg, "FatInterpretClusterType ->



FatClusterAvailable\n", 0);


   return FatClusterAvailable;



} else if (Entry < FAT_CLUSTER_RESERVED) {

   DebugTrace(-1, Dbg, "FatInterpretClusterType ->



FatClusterNext\n", 0);


   return FatClusterNext;



} else if (Entry < FAT_CLUSTER_BAD) {

   DebugTrace(-1, Dbg, "FatInterpretClusterType ->



FatClusterReserved\n", 0);


   return FatClusterReserved;



} else if (Entry == FAT_CLUSTER_BAD) {

   DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterBad\n",



0);


   return FatClusterBad;



} else {

   DebugTrace(-1, Dbg, "FatInterpretClusterType ->



FatClusterLast\n", 0);


   return FatClusterLast;


}

-}




-//
-//  Internal support routine
-//



-VOID
-FatLookupFatEntry (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG FatIndex,
IN OUT PULONG FatEntry,
IN OUT PFAT_ENUMERATION_CONTEXT Context
)


-/*++



-Routine Description:


This routine takes an index into the fat and gives back the value
in the Fat at this index.  At any given time, for a 16 bit fat, this
routine allows only one page per volume of the fat to be pinned in
memory.  For a 12 bit bit fat, the entire fat (max 6k) is pinned.

This

extra layer of caching makes the vast majority of requests very
fast.  The context for this caching stored in a structure in the Vcb.


-Arguments:


Vcb - Supplies the Vcb to examine, yields 12/16 bit info,
     fat access context, etc.



FatIndex - Supplies the fat index to examine.

FatEntry - Receives the fat entry pointed to by FatIndex.  Note that
          it must point to non-paged pool.



Context - This structure keeps track of a page of pinned fat between

calls.



---*/



-{

PAGED_CODE();

DebugTrace(+1, Dbg, "FatLookupFatEntry\n", 0);
DebugTrace( 0, Dbg, "  Vcb      = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  FatIndex = %4x\n", FatIndex);
DebugTrace( 0, Dbg, "  FatEntry = %8lx\n", FatEntry);

//
//  Make sure they gave us a valid fat index.
//

FatVerifyIndexIsValid(IrpContext, Vcb, FatIndex);

//
//  Case on 12 or 16 bit fats.
//
//  In the 12 bit case (mostly floppies) we always have the whole fat
//  (max 6k bytes) pinned during allocation operations.  This is

possibly

//  a wee bit slower, but saves headaches over fat entries with 8 bits
//  on one page, and 4 bits on the next.
//
//  The 16 bit case always keeps the last used page pinned until all
//  operations are done and it is unpinned.
//

//
//  DEAL WITH 12 BIT CASE
//

if (Vcb->AllocationSupport.FatIndexBitSize == 12) {

   //


   //  Check to see if the fat is already pinned, otherwise pin it.


   //



   if (Context->Bcb == NULL) {



       FatReadVolumeFile( IrpContext,


                          Vcb,


                          FatReservedBytes( &Vcb->Bpb ),


                          FatBytesPerFat( &Vcb->Bpb ),


                          &Context->Bcb,


                          &Context->PinnedPage );


   }



   //


   //  Load the return value.


   //




   FatLookup12BitEntry( Context->PinnedPage, FatIndex, FatEntry );



} else if (Vcb->AllocationSupport.FatIndexBitSize == 32) {

   //


   //  DEAL WITH 32 BIT CASE


   //



   ULONG PageEntryOffset;


   ULONG OffsetIntoVolumeFile;



   //


   //  Initialize two local variables that help us.


   //


   OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex *



sizeof(FAT_ENTRY);

   PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) /



sizeof(FAT_ENTRY);


   //


   //  Check to see if we need to read in a new page of fat


   //



   if ((Context->Bcb == NULL) ||


       (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage



/ PAGE_SIZE)) {


       //


       //  The entry wasn't in the pinned page, so must we unpin the



current

       //  page (if any) and read in a new page.


       //



       FatUnpinBcb( IrpContext, Context->Bcb );



       FatReadVolumeFile( IrpContext,


                          Vcb,


                          OffsetIntoVolumeFile & ~(PAGE_SIZE - 1),


                          PAGE_SIZE,


                          &Context->Bcb,


                          &Context->PinnedPage );



       Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE


1);
   }



   //


   //  Grab the fat entry from the pinned page, and return


   //



   *FatEntry = ((PULONG)(Context->PinnedPage))[PageEntryOffset] &



FAT32_ENTRY_MASK;


} else {

   //


   //  DEAL WITH 16 BIT CASE


   //



   ULONG PageEntryOffset;


   ULONG OffsetIntoVolumeFile;



   //


   //  Initialize two local variables that help us.


   //



   OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex *



sizeof(USHORT);

   PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) /



sizeof(USHORT);


   //


   //  Check to see if we need to read in a new page of fat


   //



   if ((Context->Bcb == NULL) ||


       (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage



/ PAGE_SIZE)) {


       //


       //  The entry wasn't in the pinned page, so must we unpin the



current

       //  page (if any) and read in a new page.


       //



       FatUnpinBcb( IrpContext, Context->Bcb );



       FatReadVolumeFile( IrpContext,


                          Vcb,


                          OffsetIntoVolumeFile & ~(PAGE_SIZE - 1),


                          PAGE_SIZE,


                          &Context->Bcb,


                          &Context->PinnedPage );



       Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE


1);
   }



   //


   //  Grab the fat entry from the pinned page, and return


   //



   *FatEntry = ((PUSHORT)(Context->PinnedPage))[PageEntryOffset];


}

DebugTrace(-1, Dbg, "FatLookupFatEntry -> (VOID)\n", 0);
return;

-}




-VOID
-FatSetFatEntry (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG FatIndex,
IN FAT_ENTRY FatEntry
)


-/*++



-Routine Description:


This routine takes an index into the fat and puts a value in the Fat
at this index.  The routine special cases 12, 16 and 32 bit fats.  In
all cases we go to the cache manager for a piece of the fat.

We have a special form of this call for setting the DOS-style dirty

bit.

Unlike the dirty bit in the boot sector, we do not go to special

effort

to make sure that this hits the disk synchronously - if the system

goes

down in the window between the dirty bit being set in the boot sector
and the FAT index zero dirty bit being lazy written, then life is

tough.


The only possible scenario is that Win9x may see what it thinks is a

clean

volume that really isn't (hopefully Memphis will pay attention to our

dirty

bit as well). The dirty bit will get out quickly, and if heavy

activity is

occurring, then the dirty bit should actually be there virtually all

of the

time since the act of cleaning the volume is the "rare" occurance.

There are synchronization concerns that would crop up if we tried to

make

this synchronous. This thread may already own the Bcb shared for the

first

sector of the FAT (so we can't get it exclusive for a writethrough).

This

would require some more serious replumbing to work around than I want

to

consider at this time.

We can and do, however, synchronously set the bit clean.

At this point the reader should understand why the NT dirty bit is

where it is.



-Arguments:


Vcb - Supplies the Vcb to examine, yields 12/16/32 bit info, etc.

FatIndex - Supplies the destination fat index.

FatEntry - Supplies the source fat entry.


---*/



-{

LBO Lbo;
PBCB Bcb = NULL;
ULONG SectorSize;
ULONG OffsetIntoVolumeFile;
ULONG WasWait = TRUE;
BOOLEAN RegularOperation = TRUE;
BOOLEAN CleaningOperation = FALSE;
BOOLEAN ReleaseMutex = FALSE;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatSetFatEntry\n", 0);
DebugTrace( 0, Dbg, "  Vcb      = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  FatIndex = %4x\n", FatIndex);
DebugTrace( 0, Dbg, "  FatEntry = %4x\n", FatEntry);

//
//  Make sure they gave us a valid fat index if this isn't the special
//  clean-bit modifying call.
//

if (FatIndex == FAT_DIRTY_BIT_INDEX) {

   //


   //  We are setting the clean bit state.  Of course, we could


   //  have corruption that would cause us to try to fiddle the


   //  reserved index - we guard against this by having the


   //  special entry values use the reserved high 4 bits that


   //  we know that we'll never try to set.


   //



   //


   //  We don't want to repin the FAT pages involved here.  Just


   //  let the lazy writer hit them when it can.


   //



   RegularOperation = FALSE;



   switch (FatEntry) {


       case FAT_CLEAN_VOLUME:


           FatEntry = FAT_CLEAN_ENTRY;


           CleaningOperation = TRUE;


           break;



       case FAT_DIRTY_VOLUME:


           switch (Vcb->AllocationSupport.FatIndexBitSize) {


               case 12:


                   FatEntry = FAT12_DIRTY_ENTRY;


                   break;



               case 32:


                   FatEntry = FAT32_DIRTY_ENTRY;


                   break;



               default:


                   FatEntry = FAT16_DIRTY_ENTRY;


                   break;


           }


           break;



       default:


           FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );


           break;


   }



   //


   //  Disable dirtying semantics for the duration of this



operation.  Force this

   //  operation to wait for the duration.


   //



   WasWait = FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );


   SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT |



IRP_CONTEXT_FLAG_DISABLE_DIRTY );


} else {

   ASSERT( !(FatEntry & ~FAT32_ENTRY_MASK) );


   FatVerifyIndexIsValid(IrpContext, Vcb, FatIndex);


}

//
//  Set Sector Size
//

SectorSize = 1 << Vcb->AllocationSupport.LogOfBytesPerSector;

//
//  Case on 12 or 16 bit fats.
//
//  In the 12 bit case (mostly floppies) we always have the whole fat
//  (max 6k bytes) pinned during allocation operations.  This is

possibly

//  a wee bit slower, but saves headaches over fat entries with 8 bits
//  on one page, and 4 bits on the next.
//
//  In the 16 bit case we only read the page that we need to set the

fat

//  entry.
//

//
//  DEAL WITH 12 BIT CASE
//

_SEH2_TRY {

   if (Vcb->AllocationSupport.FatIndexBitSize == 12) {



       PVOID PinnedFat;



       //


       //  Make sure we have a valid entry


       //



       FatEntry &= 0xfff;



       //


       //  We read in the entire fat.  Note that using prepare write



marks

       //  the bcb pre-dirty, so we don't have to do it explicitly.


       //



       OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) +



FatIndex * 3 / 2;


       FatPrepareWriteVolumeFile( IrpContext,


                                  Vcb,


                                  FatReservedBytes( &Vcb->Bpb ),


                                  FatBytesPerFat( &Vcb->Bpb ),


                                  &Bcb,


                                  &PinnedFat,


                                  RegularOperation,


                                  FALSE );



       //


       //  Mark the sector(s) dirty in the DirtyFatMcb.  This call is


       //  complicated somewhat for the 12 bit case since a single


       //  entry write can span two sectors (and pages).


       //


       //  Get the Lbo for the sector where the entry starts, and



add it to

       //  the dirty fat Mcb.


       //



       Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1);



       FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize);


       //


       //  If the entry started on the last byte of the sector, it



continues

       //  to the next sector, so mark the next sector dirty as well.


       //


       //  Note that this entry will simply coalese with the last



entry,

       //  so this operation cannot fail.  Also if we get this far,



we have

       //  made it, so no unwinding will be needed.


       //



       if ( (OffsetIntoVolumeFile & (SectorSize - 1)) == (SectorSize



) {



           Lbo += SectorSize;



           FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize );

       }



       //


       //  Store the entry into the fat; we need a little



synchonization

       //  here and can't use a spinlock since the bytes might not be


       //  resident.


       //



       FatLockFreeClusterBitMap( Vcb );


       ReleaseMutex = TRUE;



       FatSet12BitEntry( PinnedFat, FatIndex, FatEntry );



       FatUnlockFreeClusterBitMap( Vcb );


       ReleaseMutex = FALSE;



   } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) {



       //


       //  DEAL WITH 32 BIT CASE


       //



       PULONG PinnedFatEntry32;



       //


       //  Read in a new page of fat


       //



       OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) +


                              FatIndex * sizeof( FAT_ENTRY );



       FatPrepareWriteVolumeFile( IrpContext,


                                  Vcb,


                                  OffsetIntoVolumeFile,


                                  sizeof(FAT_ENTRY),


                                  &Bcb,


                                  (PVOID *)&PinnedFatEntry32,


                                  RegularOperation,


                                  FALSE );


       //


       //  Mark the sector dirty in the DirtyFatMcb


       //



       Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1);



       FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize);


       //


       //  Store the FatEntry to the pinned page.


       //


       //  Preserve the reserved bits in FAT32 entries in the file



heap.

       //




-#ifdef ALPHA

       FatLockFreeClusterBitMap( Vcb );


       ReleaseMutex = TRUE;



-#endif // ALPHA


       if (FatIndex != FAT_DIRTY_BIT_INDEX) {



           *PinnedFatEntry32 = ((*PinnedFatEntry32 &



~FAT32_ENTRY_MASK) | FatEntry);


       } else {



           *PinnedFatEntry32 = FatEntry;


       }




-#ifdef ALPHA

       FatUnlockFreeClusterBitMap( Vcb );


       ReleaseMutex = FALSE;



-#endif // ALPHA


   } else {



       //


       //  DEAL WITH 16 BIT CASE


       //



       PUSHORT PinnedFatEntry;



       //


       //  Read in a new page of fat


       //



       OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) +


                              FatIndex * sizeof(USHORT);



       FatPrepareWriteVolumeFile( IrpContext,


                                  Vcb,


                                  OffsetIntoVolumeFile,


                                  sizeof(USHORT),


                                  &Bcb,


                                  (PVOID *)&PinnedFatEntry,


                                  RegularOperation,


                                  FALSE );


       //


       //  Mark the sector dirty in the DirtyFatMcb


       //



       Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1);



       FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize);


       //


       //  Store the FatEntry to the pinned page.


       //


       //  We need extra synchronization here for broken



architectures

       //  like the ALPHA that don't support atomic 16 bit writes.


       //




-#ifdef ALPHA

       FatLockFreeClusterBitMap( Vcb );


       ReleaseMutex = TRUE;



-#endif // ALPHA


       *PinnedFatEntry = (USHORT)FatEntry;




-#ifdef ALPHA

       FatUnlockFreeClusterBitMap( Vcb );


       ReleaseMutex = FALSE;



-#endif // ALPHA

   }



} _SEH2_FINALLY {

   DebugUnwind( FatSetFatEntry );



   //


   //  Re-enable volume dirtying in case this was a dirty bit



operation.

   //



   ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_DIRTY );



   //


   //  Make this operation asynchronous again if needed.


   //



   if (!WasWait) {



       ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );


   }



   //


   //  If we still somehow have the Mutex, release it.


   //



   if (ReleaseMutex) {



       ASSERT( _SEH2_AbnormalTermination() );



       FatUnlockFreeClusterBitMap( Vcb );


   }



   //


   //  Unpin the Bcb.  For cleaning operations, we make this



write-through.

   //



   if (CleaningOperation && Bcb) {



       IO_STATUS_BLOCK IgnoreStatus;



       CcRepinBcb( Bcb );


       CcUnpinData( Bcb );


       DbgDoit( IrpContext->PinCount -= 1 );


       CcUnpinRepinnedBcb( Bcb, TRUE, &IgnoreStatus );



   } else {



       FatUnpinBcb(IrpContext, Bcb);


   }



   DebugTrace(-1, Dbg, "FatSetFatEntry -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-//
-//  Internal support routine
-//



-VOID
-FatSetFatRun (

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG StartingFatIndex,
IN ULONG ClusterCount,
IN BOOLEAN ChainTogether
)


-/*++



-Routine Description:


This routine sets a continuous run of clusters in the fat.  If

ChainTogether

is TRUE, then the clusters are linked together as in normal Fat

fasion,

with the last cluster receiving FAT_CLUSTER_LAST.  If ChainTogether is
FALSE, all the entries are set to FAT_CLUSTER_AVAILABLE, effectively
freeing all the clusters in the run.


-Arguments:


Vcb - Supplies the Vcb to examine, yields 12/16 bit info, etc.

StartingFatIndex - Supplies the destination fat index.

ClusterCount - Supplies the number of contiguous clusters to work on.

ChainTogether - Tells us whether to fill the entries with links, or
               FAT_CLUSTER_AVAILABLE





-Return Value:


VOID


---*/



-{
-#define MAXCOUNTCLUS 0x10000
-#define COUNTSAVEDBCBS ((MAXCOUNTCLUS * sizeof(FAT_ENTRY) / PAGE_SIZE) +
2)

PBCB SavedBcbs[COUNTSAVEDBCBS][2];

ULONG SectorSize;
ULONG Cluster;

LBO StartSectorLbo;
LBO FinalSectorLbo;
LBO Lbo;

PVOID PinnedFat;


-#ifndef __REACTOS__

ULONG StartingPage;

-#endif


BOOLEAN ReleaseMutex = FALSE;

ULONG SavedStartingFatIndex = StartingFatIndex;

PAGED_CODE();

DebugTrace(+1, Dbg, "FatSetFatRun\n", 0);
DebugTrace( 0, Dbg, "  Vcb              = %8lx\n", Vcb);
DebugTrace( 0, Dbg, "  StartingFatIndex = %8x\n", StartingFatIndex);
DebugTrace( 0, Dbg, "  ClusterCount     = %8lx\n", ClusterCount);
DebugTrace( 0, Dbg, "  ChainTogether    = %s\n", ChainTogether ?

"TRUE":"FALSE");


//
//  Make sure they gave us a valid fat run.
//

FatVerifyIndexIsValid(IrpContext, Vcb, StartingFatIndex);
FatVerifyIndexIsValid(IrpContext, Vcb, StartingFatIndex +

ClusterCount - 1);


//
//  Check special case
//

if (ClusterCount == 0) {

   DebugTrace(-1, Dbg, "FatSetFatRun -> (VOID)\n", 0);


   return;


}

//
//  Set Sector Size
//

SectorSize = 1 << Vcb->AllocationSupport.LogOfBytesPerSector;

//
//  Case on 12 or 16 bit fats.
//
//  In the 12 bit case (mostly floppies) we always have the whole fat
//  (max 6k bytes) pinned during allocation operations.  This is

possibly

//  a wee bit slower, but saves headaches over fat entries with 8 bits
//  on one page, and 4 bits on the next.
//
//  In the 16 bit case we only read one page at a time, as needed.
//

//
//  DEAL WITH 12 BIT CASE
//

_SEH2_TRY {

   if (Vcb->AllocationSupport.FatIndexBitSize == 12) {




-#ifndef __REACTOS__

       StartingPage = 0;



-#endif


       //


       //  We read in the entire fat.  Note that using prepare write



marks

       //  the bcb pre-dirty, so we don't have to do it explicitly.


       //



       RtlZeroMemory( &SavedBcbs[0], 2 * sizeof(PBCB) * 2);



       FatPrepareWriteVolumeFile( IrpContext,


                                  Vcb,


                                  FatReservedBytes( &Vcb->Bpb ),


                                  FatBytesPerFat( &Vcb->Bpb ),


                                  &SavedBcbs[0][0],


                                  &PinnedFat,


                                  TRUE,


                                  FALSE );



       //


       //  Mark the affected sectors dirty.  Note that



FinalSectorLbo is

       //  the Lbo of the END of the entry (Thus * 3 + 2).  This



makes sure

       //  we catch the case of a dirty fat entry straddling a



sector boundry.

       //


       //  Note that if the first AddMcbEntry succeeds, all



following ones

       //  will simply coalese, and thus also succeed.


       //



       StartSectorLbo = (FatReservedBytes( &Vcb->Bpb ) +



StartingFatIndex * 3 / 2)

                        & ~(SectorSize - 1);



       FinalSectorLbo = (FatReservedBytes( &Vcb->Bpb ) +



((StartingFatIndex +

                        ClusterCount) * 3 + 2) / 2) & ~(SectorSize -



1);


       for (Lbo = StartSectorLbo; Lbo <= FinalSectorLbo; Lbo +=



SectorSize) {


           FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize );

       }



       //


       //  Store the entries into the fat; we need a little


       //  synchonization here and can't use a spinlock since the



bytes

       //  might not be resident.


       //



       FatLockFreeClusterBitMap( Vcb );


       ReleaseMutex = TRUE;



       for (Cluster = StartingFatIndex;


            Cluster < StartingFatIndex + ClusterCount - 1;


            Cluster++) {



           FatSet12BitEntry( PinnedFat,


                             Cluster,


                             ChainTogether ? Cluster + 1 :



FAT_CLUSTER_AVAILABLE );

       }



       //


       //  Save the last entry


       //



       FatSet12BitEntry( PinnedFat,


                         Cluster,


                         ChainTogether ?


                         FAT_CLUSTER_LAST & 0xfff :



FAT_CLUSTER_AVAILABLE );


       FatUnlockFreeClusterBitMap( Vcb );


       ReleaseMutex = FALSE;



   } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) {



       //


       //  DEAL WITH 32 BIT CASE


       //



       for (;;) {



           VBO StartOffsetInVolume;


           VBO FinalOffsetInVolume;



           ULONG Page;


           ULONG FinalCluster;


           PULONG FatEntry;


           ULONG ClusterCountThisRun;



           StartOffsetInVolume = FatReservedBytes(&Vcb->Bpb) +


                                       StartingFatIndex *



sizeof(FAT_ENTRY);


           if (ClusterCount > MAXCOUNTCLUS) {


               ClusterCountThisRun = MAXCOUNTCLUS;


           } else {


               ClusterCountThisRun = ClusterCount;


           }



           FinalOffsetInVolume = StartOffsetInVolume +


                                       (ClusterCountThisRun -  1) *



sizeof(FAT_ENTRY);



-#ifndef __REACTOS__

           StartingPage = StartOffsetInVolume / PAGE_SIZE;



-#endif


           {


               ULONG NumberOfPages;


               ULONG Offset;



               NumberOfPages = (FinalOffsetInVolume / PAGE_SIZE) -


                               (StartOffsetInVolume / PAGE_SIZE) + 1;



               RtlZeroMemory( &SavedBcbs[0][0], (NumberOfPages + 1)




sizeof(PBCB) * 2 );



               for ( Page = 0, Offset = StartOffsetInVolume &



~(PAGE_SIZE - 1);

                     Page < NumberOfPages;


                     Page++, Offset += PAGE_SIZE ) {



                   FatPrepareWriteVolumeFile( IrpContext,


                                              Vcb,


                                              Offset,


                                              PAGE_SIZE,


                                              &SavedBcbs[Page][0],


                                              (PVOID



*)&SavedBcbs[Page][1],

                                              TRUE,


                                              FALSE );



                   if (Page == 0) {



                       FatEntry = (PULONG)((PUCHAR)SavedBcbs[0][1] +


                                           (StartOffsetInVolume %



PAGE_SIZE));

                   }


               }


           }



           //


           //  Mark the run dirty


           //



           StartSectorLbo = StartOffsetInVolume & ~(SectorSize - 1);


           FinalSectorLbo = FinalOffsetInVolume & ~(SectorSize - 1);



           for (Lbo = StartSectorLbo; Lbo <= FinalSectorLbo; Lbo +=



SectorSize) {


               FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO)Lbo,



Lbo, SectorSize );

           }



           //


           //  Store the entries


           //


           //  We need extra synchronization here for broken



architectures

           //  like the ALPHA that don't support atomic 16 bit



writes.

           //




-#ifdef ALPHA

           FatLockFreeClusterBitMap( Vcb );


           ReleaseMutex = TRUE;



-#endif // ALPHA


           FinalCluster = StartingFatIndex + ClusterCountThisRun - 1;


           Page = 0;



           for (Cluster = StartingFatIndex;


                Cluster <= FinalCluster;


                Cluster++, FatEntry++) {



               //


               //  If we just crossed a page boundry (as opposed to



starting

               //  on one), update our idea of FatEntry.



               if ( (((ULONG_PTR)FatEntry & (PAGE_SIZE-1)) == 0) &&


                    (Cluster != StartingFatIndex) ) {



                   Page += 1;


                   FatEntry = (PULONG)SavedBcbs[Page][1];


               }



               *FatEntry = ChainTogether ? (FAT_ENTRY)(Cluster + 1) :


                                           FAT_CLUSTER_AVAILABLE;


           }



           //


           //  Fix up the last entry if we were chaining together


           //



           if ((ClusterCount <= MAXCOUNTCLUS) &&


               ChainTogether ) {



               *(FatEntry-1) = FAT_CLUSTER_LAST;


           }




-#ifdef ALPHA

           FatUnlockFreeClusterBitMap( Vcb );


           ReleaseMutex = FALSE;



-#endif // ALPHA


           {


               ULONG i = 0;


               //


               //  Unpin the Bcbs


               //



               while ( SavedBcbs[i][0] != NULL ) {



                   FatUnpinBcb( IrpContext, SavedBcbs[i][0] );


                   SavedBcbs[i][0] = NULL;



                   i += 1;


               }


           }



           if (ClusterCount <= MAXCOUNTCLUS) {



               break;



           } else {



               StartingFatIndex += MAXCOUNTCLUS;


               ClusterCount -= MAXCOUNTCLUS;


           }


       }



   } else {



       //


       //  DEAL WITH 16 BIT CASE


       //



       VBO StartOffsetInVolume;


       VBO FinalOffsetInVolume;



       ULONG Page;


       ULONG FinalCluster;


       PUSHORT FatEntry;



       StartOffsetInVolume = FatReservedBytes(&Vcb->Bpb) +


                                   StartingFatIndex * sizeof(USHORT);



       FinalOffsetInVolume = StartOffsetInVolume +


                                   (ClusterCount - 1) *



sizeof(USHORT);



-#ifndef __REACTOS__

       StartingPage = StartOffsetInVolume / PAGE_SIZE;



-#endif


       //


       //  Read in one page of fat at a time.  We cannot read in the


       //  all of the fat we need because of cache manager



limitations.

       //


       //  SavedBcb was initialized to be able to hold the largest


       //  possible number of pages in a fat plus and extra one to


       //  accomadate the boot sector, plus one more to make sure



there

       //  is enough room for the RtlZeroMemory below that needs the



mark

       //  the first Bcb after all the ones we will use as an end



marker.

       //



       {


           ULONG NumberOfPages;


           ULONG Offset;



           NumberOfPages = (FinalOffsetInVolume / PAGE_SIZE) -


                           (StartOffsetInVolume / PAGE_SIZE) + 1;



           RtlZeroMemory( &SavedBcbs[0][0], (NumberOfPages + 1) *



sizeof(PBCB) * 2 );


           for ( Page = 0, Offset = StartOffsetInVolume &



~(PAGE_SIZE - 1);

                 Page < NumberOfPages;


                 Page++, Offset += PAGE_SIZE ) {



               FatPrepareWriteVolumeFile( IrpContext,


                                          Vcb,


                                          Offset,


                                          PAGE_SIZE,


                                          &SavedBcbs[Page][0],


                                          (PVOID



*)&SavedBcbs[Page][1],

                                          TRUE,


                                          FALSE );



               if (Page == 0) {



                   FatEntry = (PUSHORT)((PUCHAR)SavedBcbs[0][1] +


                                       (StartOffsetInVolume %



PAGE_SIZE));

               }


           }


       }



       //


       //  Mark the run dirty


       //



       StartSectorLbo = StartOffsetInVolume & ~(SectorSize - 1);


       FinalSectorLbo = FinalOffsetInVolume & ~(SectorSize - 1);



       for (Lbo = StartSectorLbo; Lbo <= FinalSectorLbo; Lbo +=



SectorSize) {


           FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo,



SectorSize );

       }



       //


       //  Store the entries


       //


       //  We need extra synchronization here for broken



architectures

       //  like the ALPHA that don't support atomic 16 bit writes.


       //




-#ifdef ALPHA

       FatLockFreeClusterBitMap( Vcb );


       ReleaseMutex = TRUE;



-#endif // ALPHA


       FinalCluster = StartingFatIndex + ClusterCount - 1;


       Page = 0;



       for (Cluster = StartingFatIndex;


            Cluster <= FinalCluster;


            Cluster++, FatEntry++) {



           //


           //  If we just crossed a page boundry (as opposed to



starting

           //  on one), update our idea of FatEntry.



           if ( (((ULONG_PTR)FatEntry & (PAGE_SIZE-1)) == 0) &&


                (Cluster != StartingFatIndex) ) {



               Page += 1;


               FatEntry = (PUSHORT)SavedBcbs[Page][1];


           }



           *FatEntry = (USHORT) (ChainTogether ? (FAT_ENTRY)(Cluster





:






FAT_CLUSTER_AVAILABLE);

       }



       //


       //  Fix up the last entry if we were chaining together


       //



       if ( ChainTogether ) {



           *(FatEntry-1) = (USHORT)FAT_CLUSTER_LAST;


       }



-#ifdef ALPHA

       FatUnlockFreeClusterBitMap( Vcb );


       ReleaseMutex = FALSE;



-#endif // ALPHA

   }



} _SEH2_FINALLY {

   ULONG i = 0;



   DebugUnwind( FatSetFatRun );



   //


   //  If we still somehow have the Mutex, release it.


   //



   if (ReleaseMutex) {



       ASSERT( _SEH2_AbnormalTermination() );



       FatUnlockFreeClusterBitMap( Vcb );


   }



   //


   //  Unpin the Bcbs


   //



   while ( SavedBcbs[i][0] != NULL ) {



       FatUnpinBcb( IrpContext, SavedBcbs[i][0] );



       i += 1;


   }



   //


   //  At this point nothing in this finally clause should have



raised.

   //  So, now comes the unsafe (sigh) stuff.


   //



   if ( _SEH2_AbnormalTermination() &&


       (Vcb->AllocationSupport.FatIndexBitSize == 32) ) {



       //


       //  Fat32 unwind


       //


       //  This case is more complex because the FAT12 and FAT16



cases

       //  pin all the needed FAT pages (128K max), after which it


       //  can't fail, before changing any FAT entries.  In the Fat32


       //  case, it may not be practical to pin all the needed FAT


       //  pages, because that could span many megabytes.  So Fat32


       //  attacks in chunks, and if a failure occurs once the first


       //  chunk has been updated, we have to back out the updates.


       //


       //  The unwind consists of walking back over each FAT entry we


       //  have changed, setting it back to the previous value.  Note


       //  that the previous value with either be



FAT_CLUSTER_AVAILABLE

       //  (if ChainTogether==TRUE) or a simple link to the successor


       //  (if ChainTogether==FALSE).


       //


       //  We concede that any one of these calls could fail too; our


       //  objective is to make this case no more likely than the



case

       //  for a file consisting of multiple disjoint runs.


       //



       while ( StartingFatIndex > SavedStartingFatIndex ) {



           StartingFatIndex--;



           FatSetFatEntry( IrpContext, Vcb, StartingFatIndex,


               ChainTogether ?


                   StartingFatIndex + 1 : FAT_CLUSTER_AVAILABLE );


       }


   }



   DebugTrace(-1, Dbg, "FatSetFatRun -> (VOID)\n", 0);


} _SEH2_END;

return;

-}




-//
-//  Internal support routine
-//



-UCHAR
-FatLogOf (

IN ULONG Value
)


-/*++



-Routine Description:


This routine just computes the base 2 log of an integer.  It is only

used

on objects that are know to be powers of two.


-Arguments:


Value - The value to take the base 2 log of.


-Return Value:


UCHAR - The base 2 log of Value.


---*/



-{

UCHAR Log = 0;

PAGED_CODE();

DebugTrace(+1, Dbg, "LogOf\n", 0);
DebugTrace( 0, Dbg, "  Value = %8lx\n", Value);

//
//  Knock bits off until we we get a one at position 0
//

while ( (Value & 0xfffffffe) != 0 ) {

   Log++;


   Value >>= 1;


}

//
//  If there was more than one bit set, the file system messed up,
//  Bug Check.
//

if (Value != 0x1) {

   DebugTrace( 0, Dbg, "Received non power of 2.\n", 0);



   FatBugCheck( Value, Log, 0 );


}

DebugTrace(-1, Dbg, "LogOf -> %8lx\n", Log);

return Log;

-}




-VOID
-FatExamineFatEntries(

IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN ULONG StartIndex OPTIONAL,
IN ULONG EndIndex OPTIONAL,
IN BOOLEAN SetupWindows,
IN PFAT_WINDOW SwitchToWindow OPTIONAL,
IN PULONG BitMapBuffer OPTIONAL
)

-/*++



-Routine Description:


This routine handles scanning a segment of the FAT into in-memory

structures.


There are three fundamental cases, with variations depending on the

FAT type:



During volume setup, FatSetupAllocations




... 63110 lines suppressed ...

    

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Re: [ros-dev] [ros-diffs] [reactos] 01/01: [FASTFAT_NEW] This is not permitted by WDK license. We should rather import from MS GitHub and backport to NT5.2.