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.

[Alex Ionescu]

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(a)reactos.org>
wrote:

>  
> https://git.reactos.org/?p=reactos.git;a=commitdiff;h=
>  a913501626e599fba9d702149896f36046832deb
>
>  commit a913501626e599fba9d702149896f36046832deb
>  Author: Pierre Schweitzer <pierre(a)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:
>  -
>  -    1.  First window with >50% free clusters
>  -    2.  First empty window
>  -    3.  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 ==
>  0) &&
>  -                (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
>  + 1) :
>  -                                   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
>  + 2) && (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
>  - 1) ) {
>  -
>  -                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
>  + 1) :
>  -
>  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:
>  -
>  -    1) During volume setup, FatSetupAllocations
>  -
>  ... 63110 lines suppressed ...
>
>

[Pierre Schweitzer]

Hey Alex,

It was taken from W7 WDK. In that one, you had a FastFAT sample for
WNET, WLH, W7 and WXP. That's the later I took.

Cheers,
Pierre

Le 24/11/2017 à 22:12, Alex Ionescu a écrit :
>   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(a)reactos.org>
>  wrote:
>  
> >  
> > https://git.reactos.org/?p=reactos.git;a=commitdiff;h=
> >  a913501626e599fba9d702149896f36046832deb
> >
> >  commit a913501626e599fba9d702149896f36046832deb
> >  Author: Pierre Schweitzer <pierre(a)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:
> >  -
> >  -    1.  First window with >50% free clusters
> >  -    2.  First empty window
> >  -    3.  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 ==
> >  0) &&
> >  -                (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
> >  + 1) :
> >  -                                   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
> >  + 2) && (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
> >  - 1) ) {
> >  -
> >  -                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
> >  + 1) :
> >  -
> >  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:
> >  -
> >  -    1) During volume setup, FatSetupAllocations
> >  -
> >  ... 63110 lines suppressed ...
> >
> >  
>   

-- 
Pierre Schweitzer <pierre at reactos.org>
System & Network Administrator
Senior Kernel Developer
ReactOS Deutschland e.V.