mirror of
https://github.com/reactos/reactos.git
synced 2025-04-05 13:11:22 +00:00
[FASTFAT_NEW] Import again FastFAT from MS. This time from GitHub for license reasons.
This implies that a sample for W10. It has been backported to NT5.2; not sure how it would work on a W2K3 (feel free to test!)
This commit is contained in:
Pierre Schweitzer
parent
d8a15d0cc7
commit
0daa5547d9
44 changed files with 75220 additions and 0 deletions
43
drivers/filesystems/fastfat_new/CMakeLists.txt
Normal file
43
drivers/filesystems/fastfat_new/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
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)
|
||||
54
drivers/filesystems/fastfat_new/README.md
Normal file
54
drivers/filesystems/fastfat_new/README.md
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
<!---
|
||||
name: fastfat File System Driver
|
||||
platform: WDM
|
||||
language: cpp
|
||||
category: FileSystem
|
||||
description: A file system driver based on the Windows inbox FastFAT file system used as a model for new file systems.
|
||||
samplefwlink: http://go.microsoft.com/fwlink/p/?LinkId=620305
|
||||
--->
|
||||
|
||||
|
||||
|
||||
fastfat File System Driver
|
||||
==========================
|
||||
|
||||
The *fastfat* sample is file system driver that you can use as a model to write new file systems.
|
||||
|
||||
*fastfat* is a complete file system that addresses various issues such as storing data on disk, interacting with the cache manager, and handling various I/O operations such as file creation, performing read/writes on a file, setting information on a file, and performing control operations on the file system.
|
||||
|
||||
## Universal Windows Driver Compliant
|
||||
This sample builds a Universal Windows Driver. It uses only APIs and DDIs that are included in OneCoreUAP.
|
||||
|
||||
Build the sample
|
||||
----------------
|
||||
|
||||
You can build the sample in two ways: using Microsoft Visual Studio or the command line (*MSBuild*).
|
||||
|
||||
### Building a Driver Using Visual Studio
|
||||
|
||||
You build a driver the same way you build any project or solution in Visual Studio. When you create a new driver project using a Windows driver template, the template defines a default (active) project configuration and a default (active) solution build configuration. When you create a project from existing driver sources or convert existing driver code that was built with previous versions of the WDK, the conversion process preserves the target version information (operating systems and platform).
|
||||
|
||||
The default Solution build configuration is **Debug** and **Win32**.
|
||||
|
||||
**To select a configuration and build a driver**
|
||||
|
||||
1. Open the driver project or solution in Visual Studio (find fastfat.sln or fastfat.vcxproj).
|
||||
2. Right-click the solution in the **Solutions Explorer** and select **Configuration Manager**.
|
||||
3. From the **Configuration Manager**, select the **Active Solution Configuration** (for example, Debug or Release) and the **Active Solution Platform** (for example, Win32) that correspond to the type of build you are interested in.
|
||||
4. From the Build menu, click **Build Solution** (Ctrl+Shift+B).
|
||||
|
||||
### Building a Driver Using the Command Line (MSBuild)
|
||||
|
||||
You can build a driver from the command line using the Visual Studio Command Prompt window and the Microsoft Build Engine (MSBuild.exe) Previous versions of the WDK used the Windows Build utility (Build.exe) and provided separate build environment windows for each of the supported build configurations. You can now use the Visual Studio Command Prompt window for all build configurations.
|
||||
|
||||
**To select a configuration and build a driver or an application**
|
||||
|
||||
1. Open a Visual Studio Command Prompt window at the **Start** screen. From this window you can use MsBuild.exe to build any Visual Studio project by specifying the project (.VcxProj) or solutions (.Sln) file.
|
||||
2. Navigate to the project directory and enter the **MSbuild** command for your target. For example, to perform a clean build of a Visual Studio driver project called *filtername*.vcxproj, navigate to the project directory and enter the following MSBuild command:
|
||||
|
||||
**msbuild /t:clean /t:build .\\fastfat.vcxproj**.
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
No INF file is provided with this sample because the *fastfat* file system driver (fastfat.sys) is already part of the Windows operating system. You can build a private version of this file system and use it as a replacement for the native driver.
|
||||
423
drivers/filesystems/fastfat_new/acchksup.c
Normal file
423
drivers/filesystems/fastfat_new/acchksup.c
Normal file
|
|
@ -0,0 +1,423 @@
|
|||
/*++
|
||||
|
||||
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, FatCheckManageVolumeAccess)
|
||||
#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);
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// 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 |
|
||||
MAXIMUM_ALLOWED))) {
|
||||
|
||||
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. AccessMask will contain
|
||||
// the flags we're going to allow.
|
||||
//
|
||||
|
||||
ACCESS_MASK AccessMask = 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;
|
||||
|
||||
//
|
||||
// If this is a subdirectory also allow add file/directory and delete.
|
||||
//
|
||||
|
||||
if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DIRECTORY)) {
|
||||
|
||||
AccessMask |= FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE | FILE_DELETE_CHILD;
|
||||
}
|
||||
|
||||
if (FlagOn(*DesiredAccess, ~AccessMask)) {
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
BOOLEAN
|
||||
FatCheckManageVolumeAccess (
|
||||
_In_ PIRP_CONTEXT IrpContext,
|
||||
_In_ PACCESS_STATE AccessState,
|
||||
_In_ KPROCESSOR_MODE ProcessorMode
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function checks whether the SID described in the input access state has
|
||||
manage volume privilege.
|
||||
|
||||
Arguments:
|
||||
|
||||
AccessState - the access state describing the security context to be checked
|
||||
|
||||
ProcessorMode - the mode this check should occur against
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if privilege is held and FALSE otherwise
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PRIVILEGE_SET PrivilegeSet;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
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 TRUE;
|
||||
}
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
|
||||
PACCESS_TOKEN OriginalAccessToken;
|
||||
PACCESS_TOKEN RestrictedAccessToken;
|
||||
|
||||
PACCESS_TOKEN *EffectiveToken;
|
||||
|
||||
ACCESS_MASK GrantedAccess;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
|
||||
if (FatCheckManageVolumeAccess( IrpContext,
|
||||
AccessState,
|
||||
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;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress: 28175, "we're a file system, this is ok to touch" )
|
||||
#endif
|
||||
SeAccessCheck( DeviceObject->SecurityDescriptor,
|
||||
&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;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// 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;
|
||||
}
|
||||
|
||||
5295
drivers/filesystems/fastfat_new/allocsup.c
Normal file
5295
drivers/filesystems/fastfat_new/allocsup.c
Normal file
File diff suppressed because it is too large
Load diff
2017
drivers/filesystems/fastfat_new/cachesup.c
Normal file
2017
drivers/filesystems/fastfat_new/cachesup.c
Normal file
File diff suppressed because it is too large
Load diff
1189
drivers/filesystems/fastfat_new/cleanup.c
Normal file
1189
drivers/filesystems/fastfat_new/cleanup.c
Normal file
File diff suppressed because it is too large
Load diff
1289
drivers/filesystems/fastfat_new/close.c
Normal file
1289
drivers/filesystems/fastfat_new/close.c
Normal file
File diff suppressed because it is too large
Load diff
7000
drivers/filesystems/fastfat_new/create.c
Normal file
7000
drivers/filesystems/fastfat_new/create.c
Normal file
File diff suppressed because it is too large
Load diff
415
drivers/filesystems/fastfat_new/devctrl.c
Normal file
415
drivers/filesystems/fastfat_new/devctrl.c
Normal file
|
|
@ -0,0 +1,415 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
DevCtrl.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the File System Device Control routines for Fat
|
||||
called by the dispatch driver.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The local debug trace level
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_DEVCTRL)
|
||||
|
||||
//
|
||||
// Local procedure prototypes
|
||||
//
|
||||
|
||||
//
|
||||
// Tell prefast this is an IO_COMPLETION_ROUTINE
|
||||
//
|
||||
IO_COMPLETION_ROUTINE FatDeviceControlCompletionRoutine;
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatDeviceControlCompletionRoutine(
|
||||
IN PDEVICE_OBJECT DeviceObject,
|
||||
IN PIRP Irp,
|
||||
IN PVOID Contxt
|
||||
);
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatCommonDeviceControl)
|
||||
#pragma alloc_text(PAGE, FatFsdDeviceControl)
|
||||
#endif
|
||||
|
||||
|
||||
_Function_class_(IRP_MJ_DEVICE_CONTROL)
|
||||
_Function_class_(DRIVER_DISPATCH)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatFsdDeviceControl (
|
||||
_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
||||
_Inout_ PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine implements the FSD part of Device control operations
|
||||
|
||||
Arguments:
|
||||
|
||||
VolumeDeviceObject - Supplies the volume device object where the
|
||||
file exists
|
||||
|
||||
Irp - Supplies the Irp being processed
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The FSD status for the IRP
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
PIRP_CONTEXT IrpContext = NULL;
|
||||
|
||||
BOOLEAN TopLevel;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFsdDeviceControl\n", 0);
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
TopLevel = FatIsIrpTopLevel( Irp );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ));
|
||||
|
||||
Status = FatCommonDeviceControl( IrpContext, Irp );
|
||||
|
||||
} _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
|
||||
|
||||
//
|
||||
// We had some trouble trying to perform the requested
|
||||
// operation, so we'll abort the I/O request with
|
||||
// the error status that we get back from the
|
||||
// execption code
|
||||
//
|
||||
|
||||
Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
|
||||
} _SEH2_END;
|
||||
|
||||
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFsdDeviceControl -> %08lx\n", Status);
|
||||
|
||||
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatCommonDeviceControl (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the common routine for doing Device control operations called
|
||||
by both the fsd and fsp threads
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
InFsp - Indicates if this is the fsp thread or someother thread
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
KEVENT WaitEvent;
|
||||
PVOID CompletionContext = NULL;
|
||||
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Get a pointer to the current Irp stack location
|
||||
//
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatCommonDeviceControl\n", 0);
|
||||
DebugTrace( 0, Dbg, "Irp = %p\n", Irp);
|
||||
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
|
||||
|
||||
//
|
||||
// Decode the file object, the only type of opens we accept are
|
||||
// user volume opens.
|
||||
//
|
||||
|
||||
if (FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb ) != UserVolumeOpen) {
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonDeviceControl -> %08lx\n", STATUS_INVALID_PARAMETER);
|
||||
return STATUS_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// A few IOCTLs actually require some intervention on our part
|
||||
//
|
||||
|
||||
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
|
||||
|
||||
case IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES:
|
||||
|
||||
//
|
||||
// This is sent by the Volume Snapshot driver (Lovelace).
|
||||
// We flush the volume, and hold all file resources
|
||||
// to make sure that nothing more gets dirty. Then we wait
|
||||
// for the IRP to complete or cancel.
|
||||
//
|
||||
|
||||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
|
||||
FatAcquireExclusiveVolume( IrpContext, Vcb );
|
||||
|
||||
FatFlushAndCleanVolume( IrpContext,
|
||||
Irp,
|
||||
Vcb,
|
||||
FlushWithoutPurge );
|
||||
|
||||
KeInitializeEvent( &WaitEvent, NotificationEvent, FALSE );
|
||||
CompletionContext = &WaitEvent;
|
||||
|
||||
//
|
||||
// Get the next stack location, and copy over the stack location
|
||||
//
|
||||
|
||||
IoCopyCurrentIrpStackLocationToNext( Irp );
|
||||
|
||||
//
|
||||
// Set up the completion routine
|
||||
//
|
||||
|
||||
IoSetCompletionRoutine( Irp,
|
||||
FatDeviceControlCompletionRoutine,
|
||||
CompletionContext,
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE );
|
||||
break;
|
||||
|
||||
case IOCTL_DISK_COPY_DATA:
|
||||
|
||||
//
|
||||
// We cannot allow this IOCTL to be sent unless the volume is locked,
|
||||
// since this IOCTL allows direct writing of data to the volume.
|
||||
// We do allow kernel callers to force access via a flag. A handle that
|
||||
// issued a dismount can send this IOCTL as well.
|
||||
//
|
||||
|
||||
if (!FlagOn( Vcb->VcbState, VCB_STATE_FLAG_LOCKED ) &&
|
||||
!FlagOn( IrpSp->Flags, SL_FORCE_DIRECT_WRITE ) &&
|
||||
!FlagOn( Ccb->Flags, CCB_FLAG_COMPLETE_DISMOUNT )) {
|
||||
|
||||
FatCompleteRequest( IrpContext,
|
||||
Irp,
|
||||
STATUS_ACCESS_DENIED );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonDeviceControl -> %08lx\n", STATUS_ACCESS_DENIED);
|
||||
return STATUS_ACCESS_DENIED;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case IOCTL_SCSI_PASS_THROUGH:
|
||||
case IOCTL_SCSI_PASS_THROUGH_DIRECT:
|
||||
case IOCTL_SCSI_PASS_THROUGH_EX:
|
||||
case IOCTL_SCSI_PASS_THROUGH_DIRECT_EX:
|
||||
|
||||
//
|
||||
// If someone is issuing a format unit command underneath us, then make
|
||||
// sure we mark the device as needing verification when they close their
|
||||
// handle.
|
||||
//
|
||||
|
||||
if ((!FlagOn( IrpSp->FileObject->Flags, FO_FILE_MODIFIED ) ||
|
||||
!FlagOn( Ccb->Flags, CCB_FLAG_SENT_FORMAT_UNIT )) &&
|
||||
(Irp->AssociatedIrp.SystemBuffer != NULL)) {
|
||||
|
||||
PCDB Cdb = NULL;
|
||||
|
||||
//
|
||||
// If this is a 32 bit application running on 64 bit then thunk the
|
||||
// input structures to grab the Cdb.
|
||||
//
|
||||
|
||||
#if defined (_WIN64) && defined(BUILD_WOW64_ENABLED)
|
||||
if (IoIs32bitProcess(Irp)) {
|
||||
|
||||
if ( (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_SCSI_PASS_THROUGH) ||
|
||||
(IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT )) {
|
||||
|
||||
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof( SCSI_PASS_THROUGH32 )) {
|
||||
|
||||
Cdb = (PCDB)((PSCSI_PASS_THROUGH32)(Irp->AssociatedIrp.SystemBuffer))->Cdb;
|
||||
}
|
||||
} else {
|
||||
|
||||
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof( SCSI_PASS_THROUGH32_EX )) {
|
||||
|
||||
Cdb = (PCDB)((PSCSI_PASS_THROUGH32_EX)(Irp->AssociatedIrp.SystemBuffer))->Cdb;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
#endif
|
||||
if ( (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_SCSI_PASS_THROUGH) ||
|
||||
(IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT )) {
|
||||
|
||||
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof( SCSI_PASS_THROUGH )) {
|
||||
|
||||
Cdb = (PCDB)((PSCSI_PASS_THROUGH)(Irp->AssociatedIrp.SystemBuffer))->Cdb;
|
||||
}
|
||||
} else {
|
||||
|
||||
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof( SCSI_PASS_THROUGH_EX )) {
|
||||
|
||||
Cdb = (PCDB)((PSCSI_PASS_THROUGH_EX)(Irp->AssociatedIrp.SystemBuffer))->Cdb;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined (_WIN64) && defined(BUILD_WOW64_ENABLED)
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((Cdb != NULL) && (Cdb->AsByte[0] == SCSIOP_FORMAT_UNIT)) {
|
||||
|
||||
SetFlag( Ccb->Flags, CCB_FLAG_SENT_FORMAT_UNIT );
|
||||
SetFlag( IrpSp->FileObject->Flags, FO_FILE_MODIFIED );
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Fall through as we do not need to know the outcome of this operation.
|
||||
//
|
||||
|
||||
default:
|
||||
|
||||
//
|
||||
// FAT doesn't need to see this on the way back, so skip ourselves.
|
||||
//
|
||||
|
||||
IoSkipCurrentIrpStackLocation( Irp );
|
||||
break;
|
||||
}
|
||||
|
||||
//
|
||||
// Send the request.
|
||||
//
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
|
||||
if (Status == STATUS_PENDING && CompletionContext) {
|
||||
|
||||
KeWaitForSingleObject( &WaitEvent,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
NULL );
|
||||
|
||||
Status = Irp->IoStatus.Status;
|
||||
}
|
||||
|
||||
//
|
||||
// If we had a context, the IRP remains for us and we will complete it.
|
||||
// Handle it appropriately.
|
||||
//
|
||||
|
||||
if (CompletionContext) {
|
||||
|
||||
//
|
||||
// Release all the resources that we held because of a
|
||||
// VOLSNAP_FLUSH_AND_HOLD.
|
||||
//
|
||||
|
||||
NT_ASSERT( IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_VOLSNAP_FLUSH_AND_HOLD_WRITES );
|
||||
|
||||
FatReleaseVolume( IrpContext, Vcb );
|
||||
|
||||
//
|
||||
// If we had no context, the IRP will complete asynchronously.
|
||||
//
|
||||
|
||||
} else {
|
||||
|
||||
Irp = NULL;
|
||||
}
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonDeviceControl -> %08lx\n", Status);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Local support routine
|
||||
//
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatDeviceControlCompletionRoutine(
|
||||
_In_ PDEVICE_OBJECT DeviceObject,
|
||||
_In_ PIRP Irp,
|
||||
_In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt
|
||||
)
|
||||
|
||||
{
|
||||
PKEVENT Event = (PKEVENT) Contxt;
|
||||
|
||||
//
|
||||
// If there is an event, this is a synch request. Signal and
|
||||
// let I/O know this isn't done yet.
|
||||
//
|
||||
|
||||
if (Event) {
|
||||
|
||||
KeSetEvent( Event, 0, FALSE );
|
||||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||||
}
|
||||
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
UNREFERENCED_PARAMETER( Irp );
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
3858
drivers/filesystems/fastfat_new/deviosup.c
Normal file
3858
drivers/filesystems/fastfat_new/deviosup.c
Normal file
File diff suppressed because it is too large
Load diff
1613
drivers/filesystems/fastfat_new/dirctrl.c
Normal file
1613
drivers/filesystems/fastfat_new/dirctrl.c
Normal file
File diff suppressed because it is too large
Load diff
3804
drivers/filesystems/fastfat_new/dirsup.c
Normal file
3804
drivers/filesystems/fastfat_new/dirsup.c
Normal file
File diff suppressed because it is too large
Load diff
381
drivers/filesystems/fastfat_new/dumpsup.c
Normal file
381
drivers/filesystems/fastfat_new/dumpsup.c
Normal file
|
|
@ -0,0 +1,381 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
DumpSup.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements a collection of data structure dump routines
|
||||
for debugging the Fat file system
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
#ifdef FASTFATDBG
|
||||
|
||||
VOID FatDump(IN PVOID Ptr);
|
||||
|
||||
VOID FatDumpDataHeader();
|
||||
VOID FatDumpVcb(IN PVCB Ptr);
|
||||
VOID FatDumpFcb(IN PFCB Ptr);
|
||||
VOID FatDumpCcb(IN PCCB Ptr);
|
||||
|
||||
ULONG FatDumpCurrentColumn;
|
||||
|
||||
#define DumpNewLine() { \
|
||||
DbgPrint("\n"); \
|
||||
FatDumpCurrentColumn = 1; \
|
||||
}
|
||||
|
||||
#define DumpLabel(Label,Width) { \
|
||||
size_t i, LastPeriod=0; \
|
||||
CHAR _Str[20]; \
|
||||
for(i=0;i<2;i++) { _Str[i] = UCHAR_SP;} \
|
||||
for(i=0;i<strlen(#Label);i++) {if (#Label[i] == '.') LastPeriod = i;} \
|
||||
strncpy(&_Str[2],&#Label[LastPeriod],Width); \
|
||||
for(i=strlen(_Str);i<Width;i++) {_Str[i] = UCHAR_SP;} \
|
||||
_Str[Width] = '\0'; \
|
||||
DbgPrint("%s", _Str); \
|
||||
}
|
||||
|
||||
#define DumpField(Field) { \
|
||||
if ((FatDumpCurrentColumn + 18 + 9 + 9) > 80) {DumpNewLine();} \
|
||||
FatDumpCurrentColumn += 18 + 9 + 9; \
|
||||
DumpLabel(Field,18); \
|
||||
DbgPrint(":%p", Ptr->Field); \
|
||||
DbgPrint(" "); \
|
||||
}
|
||||
|
||||
#define DumpListEntry(Links) { \
|
||||
if ((FatDumpCurrentColumn + 18 + 9 + 9) > 80) {DumpNewLine();} \
|
||||
FatDumpCurrentColumn += 18 + 9 + 9; \
|
||||
DumpLabel(Links,18); \
|
||||
DbgPrint(":%p", Ptr->Links.Flink); \
|
||||
DbgPrint(":%p", Ptr->Links.Blink); \
|
||||
}
|
||||
|
||||
#define DumpName(Field,Width) { \
|
||||
ULONG i; \
|
||||
CHAR _String[256]; \
|
||||
if ((FatDumpCurrentColumn + 18 + Width) > 80) {DumpNewLine();} \
|
||||
FatDumpCurrentColumn += 18 + Width; \
|
||||
DumpLabel(Field,18); \
|
||||
for(i=0;i<Width;i++) {_String[i] = (CHAR)Ptr->Field[i];} \
|
||||
_String[Width] = '\0'; \
|
||||
DbgPrint("%s", _String); \
|
||||
}
|
||||
|
||||
#define TestForNull(Name) { \
|
||||
if (Ptr == NULL) { \
|
||||
DbgPrint("%s - Cannot dump a NULL pointer\n", Name); \
|
||||
return; \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatDump (
|
||||
IN PVOID Ptr
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine determines the type of internal record reference by ptr and
|
||||
calls the appropriate dump routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
Ptr - Supplies the pointer to the record to be dumped
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TestForNull("FatDump");
|
||||
|
||||
switch (NodeType(Ptr)) {
|
||||
|
||||
case FAT_NTC_DATA_HEADER:
|
||||
|
||||
FatDumpDataHeader();
|
||||
break;
|
||||
|
||||
case FAT_NTC_VCB:
|
||||
|
||||
FatDumpVcb(Ptr);
|
||||
break;
|
||||
|
||||
case FAT_NTC_FCB:
|
||||
case FAT_NTC_DCB:
|
||||
case FAT_NTC_ROOT_DCB:
|
||||
|
||||
FatDumpFcb(Ptr);
|
||||
break;
|
||||
|
||||
case FAT_NTC_CCB:
|
||||
|
||||
FatDumpCcb(Ptr);
|
||||
break;
|
||||
|
||||
default :
|
||||
|
||||
DbgPrint("FatDump - Unknown Node type code %p\n", *((PNODE_TYPE_CODE)(Ptr)));
|
||||
break;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatDumpDataHeader (
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Dump the top data structures and all Device structures
|
||||
|
||||
Arguments:
|
||||
|
||||
None
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PFAT_DATA Ptr;
|
||||
PLIST_ENTRY Links;
|
||||
|
||||
Ptr = &FatData;
|
||||
|
||||
TestForNull("FatDumpDataHeader");
|
||||
|
||||
DumpNewLine();
|
||||
DbgPrint("FatData@ %lx", (Ptr));
|
||||
DumpNewLine();
|
||||
|
||||
DumpField (NodeTypeCode);
|
||||
DumpField (NodeByteSize);
|
||||
DumpListEntry (VcbQueue);
|
||||
DumpField (DriverObject);
|
||||
DumpField (OurProcess);
|
||||
DumpNewLine();
|
||||
|
||||
for (Links = Ptr->VcbQueue.Flink;
|
||||
Links != &Ptr->VcbQueue;
|
||||
Links = Links->Flink) {
|
||||
|
||||
FatDumpVcb(CONTAINING_RECORD(Links, VCB, VcbLinks));
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatDumpVcb (
|
||||
IN PVCB Ptr
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Dump an Device structure, its Fcb queue amd direct access queue.
|
||||
|
||||
Arguments:
|
||||
|
||||
Ptr - Supplies the Device record to be dumped
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TestForNull("FatDumpVcb");
|
||||
|
||||
DumpNewLine();
|
||||
DbgPrint("Vcb@ %lx", (Ptr));
|
||||
DumpNewLine();
|
||||
|
||||
DumpField (VolumeFileHeader.NodeTypeCode);
|
||||
DumpField (VolumeFileHeader.NodeByteSize);
|
||||
DumpListEntry (VcbLinks);
|
||||
DumpField (TargetDeviceObject);
|
||||
DumpField (Vpb);
|
||||
DumpField (VcbState);
|
||||
DumpField (VcbCondition);
|
||||
DumpField (RootDcb);
|
||||
DumpField (DirectAccessOpenCount);
|
||||
DumpField (OpenFileCount);
|
||||
DumpField (ReadOnlyCount);
|
||||
DumpField (AllocationSupport);
|
||||
DumpField (AllocationSupport.RootDirectoryLbo);
|
||||
DumpField (AllocationSupport.RootDirectorySize);
|
||||
DumpField (AllocationSupport.FileAreaLbo);
|
||||
DumpField (AllocationSupport.NumberOfClusters);
|
||||
DumpField (AllocationSupport.NumberOfFreeClusters);
|
||||
DumpField (AllocationSupport.FatIndexBitSize);
|
||||
DumpField (AllocationSupport.LogOfBytesPerSector);
|
||||
DumpField (AllocationSupport.LogOfBytesPerCluster);
|
||||
DumpField (DirtyFatMcb);
|
||||
DumpField (FreeClusterBitMap);
|
||||
DumpField (VirtualVolumeFile);
|
||||
DumpField (SectionObjectPointers.DataSectionObject);
|
||||
DumpField (SectionObjectPointers.SharedCacheMap);
|
||||
DumpField (SectionObjectPointers.ImageSectionObject);
|
||||
DumpField (ClusterHint);
|
||||
DumpNewLine();
|
||||
|
||||
FatDumpFcb(Ptr->RootDcb);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatDumpFcb (
|
||||
IN PFCB Ptr
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Dump an Fcb structure, its various queues
|
||||
|
||||
Arguments:
|
||||
|
||||
Ptr - Supplies the Fcb record to be dumped
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PLIST_ENTRY Links;
|
||||
|
||||
TestForNull("FatDumpFcb");
|
||||
|
||||
DumpNewLine();
|
||||
if (NodeType(&Ptr->Header) == FAT_NTC_FCB) {DbgPrint("Fcb@ %lx", (Ptr));}
|
||||
else if (NodeType(&Ptr->Header) == FAT_NTC_DCB) {DbgPrint("Dcb@ %lx", (Ptr));}
|
||||
else if (NodeType(&Ptr->Header) == FAT_NTC_ROOT_DCB) {DbgPrint("RootDcb@ %lx", (Ptr));}
|
||||
else {DbgPrint("NonFcb NodeType @ %lx", (Ptr));}
|
||||
DumpNewLine();
|
||||
|
||||
DumpField (Header.NodeTypeCode);
|
||||
DumpField (Header.NodeByteSize);
|
||||
DumpListEntry (ParentDcbLinks);
|
||||
DumpField (ParentDcb);
|
||||
DumpField (Vcb);
|
||||
DumpField (FcbState);
|
||||
DumpField (FcbCondition);
|
||||
DumpField (UncleanCount);
|
||||
DumpField (OpenCount);
|
||||
DumpField (DirentOffsetWithinDirectory);
|
||||
DumpField (DirentFatFlags);
|
||||
DumpField (FullFileName.Length);
|
||||
DumpField (FullFileName.Buffer);
|
||||
DumpName (FullFileName.Buffer, 32);
|
||||
DumpField (ShortName.Name.Oem.Length);
|
||||
DumpField (ShortName.Name.Oem.Buffer);
|
||||
DumpField (NonPaged);
|
||||
DumpField (Header.AllocationSize.LowPart);
|
||||
DumpField (NonPaged->SectionObjectPointers.DataSectionObject);
|
||||
DumpField (NonPaged->SectionObjectPointers.SharedCacheMap);
|
||||
DumpField (NonPaged->SectionObjectPointers.ImageSectionObject);
|
||||
|
||||
if ((Ptr->Header.NodeTypeCode == FAT_NTC_DCB) ||
|
||||
(Ptr->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
|
||||
|
||||
DumpListEntry (Specific.Dcb.ParentDcbQueue);
|
||||
DumpField (Specific.Dcb.DirectoryFileOpenCount);
|
||||
DumpField (Specific.Dcb.DirectoryFile);
|
||||
|
||||
} else if (Ptr->Header.NodeTypeCode == FAT_NTC_FCB) {
|
||||
|
||||
DumpField (Header.FileSize.LowPart);
|
||||
|
||||
} else {
|
||||
|
||||
DumpNewLine();
|
||||
DbgPrint("Illegal Node type code");
|
||||
|
||||
}
|
||||
DumpNewLine();
|
||||
|
||||
if ((Ptr->Header.NodeTypeCode == FAT_NTC_DCB) ||
|
||||
(Ptr->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
|
||||
|
||||
for (Links = Ptr->Specific.Dcb.ParentDcbQueue.Flink;
|
||||
Links != &Ptr->Specific.Dcb.ParentDcbQueue;
|
||||
Links = Links->Flink) {
|
||||
|
||||
FatDumpFcb(CONTAINING_RECORD(Links, FCB, ParentDcbLinks));
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatDumpCcb (
|
||||
IN PCCB Ptr
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Dump a Ccb structure
|
||||
|
||||
Arguments:
|
||||
|
||||
Ptr - Supplies the Ccb record to be dumped
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TestForNull("FatDumpCcb");
|
||||
|
||||
DumpNewLine();
|
||||
DbgPrint("Ccb@ %lx", (Ptr));
|
||||
DumpNewLine();
|
||||
|
||||
DumpField (NodeTypeCode);
|
||||
DumpField (NodeByteSize);
|
||||
DumpField (UnicodeQueryTemplate.Length);
|
||||
DumpName (UnicodeQueryTemplate.Buffer, 32);
|
||||
DumpField (OffsetToStartSearchFrom);
|
||||
DumpNewLine();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#endif // FASTFATDBG
|
||||
|
||||
2043
drivers/filesystems/fastfat_new/ea.c
Normal file
2043
drivers/filesystems/fastfat_new/ea.c
Normal file
File diff suppressed because it is too large
Load diff
3856
drivers/filesystems/fastfat_new/easup.c
Normal file
3856
drivers/filesystems/fastfat_new/easup.c
Normal file
File diff suppressed because it is too large
Load diff
14
drivers/filesystems/fastfat_new/fastfat.rc
Normal file
14
drivers/filesystems/fastfat_new/fastfat.rc
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
//
|
||||
// Copyright (C) Microsoft. All rights reserved.
|
||||
//
|
||||
#include <windows.h>
|
||||
|
||||
#include <ntverp.h>
|
||||
|
||||
#define VER_FILETYPE VFT_DRV
|
||||
#define VER_FILESUBTYPE VFT2_DRV_SYSTEM
|
||||
#define VER_FILEDESCRIPTION_STR "Fast FAT File System Driver"
|
||||
#define VER_INTERNALNAME_STR "fastfat.sys"
|
||||
#define VER_ORIGINALFILENAME_STR "FastFAT.Sys"
|
||||
|
||||
#include "common.ver"
|
||||
755
drivers/filesystems/fastfat_new/fat.h
Normal file
755
drivers/filesystems/fastfat_new/fat.h
Normal file
|
|
@ -0,0 +1,755 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
Fat.h
|
||||
|
||||
Abstract:
|
||||
|
||||
This module defines the on-disk structure of the Fat file system.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _FAT_
|
||||
#define _FAT_
|
||||
|
||||
//
|
||||
// The following nomenclature is used to describe the Fat on-disk
|
||||
// structure:
|
||||
//
|
||||
// LBN - is the number of a sector relative to the start of the disk.
|
||||
//
|
||||
// VBN - is the number of a sector relative to the start of a file,
|
||||
// directory, or allocation.
|
||||
//
|
||||
// LBO - is a byte offset relative to the start of the disk.
|
||||
//
|
||||
// VBO - is a byte offset relative to the start of a file, directory
|
||||
// or allocation.
|
||||
//
|
||||
|
||||
typedef LONGLONG LBO; /* for Fat32, LBO is >32 bits */
|
||||
|
||||
typedef LBO *PLBO;
|
||||
|
||||
typedef ULONG32 VBO;
|
||||
typedef VBO *PVBO;
|
||||
|
||||
|
||||
//
|
||||
// The boot sector is the first physical sector (LBN == 0) on the volume.
|
||||
// Part of the sector contains a BIOS Parameter Block. The BIOS in the
|
||||
// sector is packed (i.e., unaligned) so we'll supply a unpacking macro
|
||||
// to translate a packed BIOS into its unpacked equivalent. The unpacked
|
||||
// BIOS structure is already defined in ntioapi.h so we only need to define
|
||||
// the packed BIOS.
|
||||
//
|
||||
|
||||
//
|
||||
// Define the Packed and Unpacked BIOS Parameter Block
|
||||
//
|
||||
|
||||
typedef struct _PACKED_BIOS_PARAMETER_BLOCK {
|
||||
UCHAR BytesPerSector[2]; // offset = 0x000 0
|
||||
UCHAR SectorsPerCluster[1]; // offset = 0x002 2
|
||||
UCHAR ReservedSectors[2]; // offset = 0x003 3
|
||||
UCHAR Fats[1]; // offset = 0x005 5
|
||||
UCHAR RootEntries[2]; // offset = 0x006 6
|
||||
UCHAR Sectors[2]; // offset = 0x008 8
|
||||
UCHAR Media[1]; // offset = 0x00A 10
|
||||
UCHAR SectorsPerFat[2]; // offset = 0x00B 11
|
||||
UCHAR SectorsPerTrack[2]; // offset = 0x00D 13
|
||||
UCHAR Heads[2]; // offset = 0x00F 15
|
||||
UCHAR HiddenSectors[4]; // offset = 0x011 17
|
||||
UCHAR LargeSectors[4]; // offset = 0x015 21
|
||||
} PACKED_BIOS_PARAMETER_BLOCK; // sizeof = 0x019 25
|
||||
typedef PACKED_BIOS_PARAMETER_BLOCK *PPACKED_BIOS_PARAMETER_BLOCK;
|
||||
|
||||
typedef struct _PACKED_BIOS_PARAMETER_BLOCK_EX {
|
||||
UCHAR BytesPerSector[2]; // offset = 0x000 0
|
||||
UCHAR SectorsPerCluster[1]; // offset = 0x002 2
|
||||
UCHAR ReservedSectors[2]; // offset = 0x003 3
|
||||
UCHAR Fats[1]; // offset = 0x005 5
|
||||
UCHAR RootEntries[2]; // offset = 0x006 6
|
||||
UCHAR Sectors[2]; // offset = 0x008 8
|
||||
UCHAR Media[1]; // offset = 0x00A 10
|
||||
UCHAR SectorsPerFat[2]; // offset = 0x00B 11
|
||||
UCHAR SectorsPerTrack[2]; // offset = 0x00D 13
|
||||
UCHAR Heads[2]; // offset = 0x00F 15
|
||||
UCHAR HiddenSectors[4]; // offset = 0x011 17
|
||||
UCHAR LargeSectors[4]; // offset = 0x015 21
|
||||
UCHAR LargeSectorsPerFat[4]; // offset = 0x019 25
|
||||
UCHAR ExtendedFlags[2]; // offset = 0x01D 29
|
||||
UCHAR FsVersion[2]; // offset = 0x01F 31
|
||||
UCHAR RootDirFirstCluster[4]; // offset = 0x021 33
|
||||
UCHAR FsInfoSector[2]; // offset = 0x025 37
|
||||
UCHAR BackupBootSector[2]; // offset = 0x027 39
|
||||
UCHAR Reserved[12]; // offset = 0x029 41
|
||||
} PACKED_BIOS_PARAMETER_BLOCK_EX; // sizeof = 0x035 53
|
||||
|
||||
typedef PACKED_BIOS_PARAMETER_BLOCK_EX *PPACKED_BIOS_PARAMETER_BLOCK_EX;
|
||||
|
||||
//
|
||||
// The IsBpbFat32 macro is defined to work with both packed and unpacked
|
||||
// BPB structures. Since we are only checking for zero, the byte order
|
||||
// does not matter.
|
||||
//
|
||||
|
||||
#define IsBpbFat32(bpb) (*(USHORT *)(&(bpb)->SectorsPerFat) == 0)
|
||||
|
||||
typedef struct BIOS_PARAMETER_BLOCK {
|
||||
USHORT BytesPerSector;
|
||||
UCHAR SectorsPerCluster;
|
||||
USHORT ReservedSectors;
|
||||
UCHAR Fats;
|
||||
USHORT RootEntries;
|
||||
USHORT Sectors;
|
||||
UCHAR Media;
|
||||
USHORT SectorsPerFat;
|
||||
USHORT SectorsPerTrack;
|
||||
USHORT Heads;
|
||||
ULONG32 HiddenSectors;
|
||||
ULONG32 LargeSectors;
|
||||
ULONG32 LargeSectorsPerFat;
|
||||
union {
|
||||
USHORT ExtendedFlags;
|
||||
struct {
|
||||
ULONG ActiveFat:4;
|
||||
ULONG Reserved0:3;
|
||||
ULONG MirrorDisabled:1;
|
||||
ULONG Reserved1:8;
|
||||
};
|
||||
};
|
||||
USHORT FsVersion;
|
||||
ULONG32 RootDirFirstCluster;
|
||||
USHORT FsInfoSector;
|
||||
USHORT BackupBootSector;
|
||||
} BIOS_PARAMETER_BLOCK, *PBIOS_PARAMETER_BLOCK;
|
||||
|
||||
//
|
||||
// This macro takes a Packed BIOS and fills in its Unpacked equivalent
|
||||
//
|
||||
|
||||
#define FatUnpackBios(Bios,Pbios) { \
|
||||
CopyUchar2(&(Bios)->BytesPerSector, &(Pbios)->BytesPerSector[0] ); \
|
||||
CopyUchar1(&(Bios)->SectorsPerCluster, &(Pbios)->SectorsPerCluster[0]); \
|
||||
CopyUchar2(&(Bios)->ReservedSectors, &(Pbios)->ReservedSectors[0] ); \
|
||||
CopyUchar1(&(Bios)->Fats, &(Pbios)->Fats[0] ); \
|
||||
CopyUchar2(&(Bios)->RootEntries, &(Pbios)->RootEntries[0] ); \
|
||||
CopyUchar2(&(Bios)->Sectors, &(Pbios)->Sectors[0] ); \
|
||||
CopyUchar1(&(Bios)->Media, &(Pbios)->Media[0] ); \
|
||||
CopyUchar2(&(Bios)->SectorsPerFat, &(Pbios)->SectorsPerFat[0] ); \
|
||||
CopyUchar2(&(Bios)->SectorsPerTrack, &(Pbios)->SectorsPerTrack[0] ); \
|
||||
CopyUchar2(&(Bios)->Heads, &(Pbios)->Heads[0] ); \
|
||||
CopyUchar4(&(Bios)->HiddenSectors, &(Pbios)->HiddenSectors[0] ); \
|
||||
CopyUchar4(&(Bios)->LargeSectors, &(Pbios)->LargeSectors[0] ); \
|
||||
CopyUchar4(&(Bios)->LargeSectorsPerFat,&((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->LargeSectorsPerFat[0] ); \
|
||||
CopyUchar2(&(Bios)->ExtendedFlags, &((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->ExtendedFlags[0] ); \
|
||||
CopyUchar2(&(Bios)->FsVersion, &((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->FsVersion[0] ); \
|
||||
CopyUchar4(&(Bios)->RootDirFirstCluster, \
|
||||
&((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->RootDirFirstCluster[0] ); \
|
||||
CopyUchar2(&(Bios)->FsInfoSector, &((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->FsInfoSector[0] ); \
|
||||
CopyUchar2(&(Bios)->BackupBootSector, &((PPACKED_BIOS_PARAMETER_BLOCK_EX)Pbios)->BackupBootSector[0] ); \
|
||||
}
|
||||
|
||||
//
|
||||
// Define the boot sector
|
||||
//
|
||||
|
||||
typedef struct _PACKED_BOOT_SECTOR {
|
||||
UCHAR Jump[3]; // offset = 0x000 0
|
||||
UCHAR Oem[8]; // offset = 0x003 3
|
||||
PACKED_BIOS_PARAMETER_BLOCK PackedBpb; // offset = 0x00B 11
|
||||
UCHAR PhysicalDriveNumber; // offset = 0x024 36
|
||||
UCHAR CurrentHead; // offset = 0x025 37
|
||||
UCHAR Signature; // offset = 0x026 38
|
||||
UCHAR Id[4]; // offset = 0x027 39
|
||||
UCHAR VolumeLabel[11]; // offset = 0x02B 43
|
||||
UCHAR SystemId[8]; // offset = 0x036 54
|
||||
} PACKED_BOOT_SECTOR; // sizeof = 0x03E 62
|
||||
|
||||
typedef PACKED_BOOT_SECTOR *PPACKED_BOOT_SECTOR;
|
||||
|
||||
typedef struct _PACKED_BOOT_SECTOR_EX {
|
||||
UCHAR Jump[3]; // offset = 0x000 0
|
||||
UCHAR Oem[8]; // offset = 0x003 3
|
||||
PACKED_BIOS_PARAMETER_BLOCK_EX PackedBpb; // offset = 0x00B 11
|
||||
UCHAR PhysicalDriveNumber; // offset = 0x040 64
|
||||
UCHAR CurrentHead; // offset = 0x041 65
|
||||
UCHAR Signature; // offset = 0x042 66
|
||||
UCHAR Id[4]; // offset = 0x043 67
|
||||
UCHAR VolumeLabel[11]; // offset = 0x047 71
|
||||
UCHAR SystemId[8]; // offset = 0x058 88
|
||||
} PACKED_BOOT_SECTOR_EX; // sizeof = 0x060 96
|
||||
|
||||
typedef PACKED_BOOT_SECTOR_EX *PPACKED_BOOT_SECTOR_EX;
|
||||
|
||||
//
|
||||
// Define the FAT32 FsInfo sector.
|
||||
//
|
||||
|
||||
typedef struct _FSINFO_SECTOR {
|
||||
ULONG SectorBeginSignature; // offset = 0x000 0
|
||||
UCHAR ExtraBootCode[480]; // offset = 0x004 4
|
||||
ULONG FsInfoSignature; // offset = 0x1e4 484
|
||||
ULONG FreeClusterCount; // offset = 0x1e8 488
|
||||
ULONG NextFreeCluster; // offset = 0x1ec 492
|
||||
UCHAR Reserved[12]; // offset = 0x1f0 496
|
||||
ULONG SectorEndSignature; // offset = 0x1fc 508
|
||||
} FSINFO_SECTOR, *PFSINFO_SECTOR;
|
||||
|
||||
#define FSINFO_SECTOR_BEGIN_SIGNATURE 0x41615252
|
||||
#define FSINFO_SECTOR_END_SIGNATURE 0xAA550000
|
||||
|
||||
#define FSINFO_SIGNATURE 0x61417272
|
||||
|
||||
//
|
||||
// We use the CurrentHead field for our dirty partition info.
|
||||
//
|
||||
|
||||
#define FAT_BOOT_SECTOR_DIRTY 0x01
|
||||
#define FAT_BOOT_SECTOR_TEST_SURFACE 0x02
|
||||
|
||||
//
|
||||
// Define a Fat Entry type.
|
||||
//
|
||||
// This type is used when representing a fat table entry. It also used
|
||||
// to be used when dealing with a fat table index and a count of entries,
|
||||
// but the ensuing type casting nightmare sealed this fate. These other
|
||||
// two types are represented as ULONGs.
|
||||
//
|
||||
|
||||
typedef ULONG32 FAT_ENTRY;
|
||||
|
||||
#define FAT32_ENTRY_MASK 0x0FFFFFFFUL
|
||||
|
||||
//
|
||||
// We use these special index values to set the dirty info for
|
||||
// DOS/Win9x compatibility.
|
||||
//
|
||||
|
||||
#define FAT_CLEAN_VOLUME (~FAT32_ENTRY_MASK | 0)
|
||||
#define FAT_DIRTY_VOLUME (~FAT32_ENTRY_MASK | 1)
|
||||
|
||||
#define FAT_DIRTY_BIT_INDEX 1
|
||||
|
||||
//
|
||||
// Physically, the entry is fully set if clean, and the high
|
||||
// bit knocked out if it is dirty (i.e., it is really a clean
|
||||
// bit). This means it is different per-FAT size.
|
||||
//
|
||||
|
||||
#define FAT_CLEAN_ENTRY (~0)
|
||||
|
||||
#define FAT12_DIRTY_ENTRY 0x7ff
|
||||
#define FAT16_DIRTY_ENTRY 0x7fff
|
||||
#define FAT32_DIRTY_ENTRY 0x7fffffff
|
||||
|
||||
//
|
||||
// The following constants the are the valid Fat index values.
|
||||
//
|
||||
|
||||
#define FAT_CLUSTER_AVAILABLE (FAT_ENTRY)0x00000000
|
||||
#define FAT_CLUSTER_RESERVED (FAT_ENTRY)0x0ffffff0
|
||||
#define FAT_CLUSTER_BAD (FAT_ENTRY)0x0ffffff7
|
||||
#define FAT_CLUSTER_LAST (FAT_ENTRY)0x0fffffff
|
||||
|
||||
//
|
||||
// Fat files have the following time/date structures. Note that the
|
||||
// following structure is a 32 bits long but USHORT aligned.
|
||||
//
|
||||
|
||||
typedef struct _FAT_TIME {
|
||||
|
||||
USHORT DoubleSeconds : 5;
|
||||
USHORT Minute : 6;
|
||||
USHORT Hour : 5;
|
||||
|
||||
} FAT_TIME;
|
||||
typedef FAT_TIME *PFAT_TIME;
|
||||
|
||||
typedef struct _FAT_DATE {
|
||||
|
||||
USHORT Day : 5;
|
||||
USHORT Month : 4;
|
||||
USHORT Year : 7; // Relative to 1980
|
||||
|
||||
} FAT_DATE;
|
||||
typedef FAT_DATE *PFAT_DATE;
|
||||
|
||||
typedef struct _FAT_TIME_STAMP {
|
||||
|
||||
FAT_TIME Time;
|
||||
FAT_DATE Date;
|
||||
|
||||
} FAT_TIME_STAMP;
|
||||
typedef FAT_TIME_STAMP *PFAT_TIME_STAMP;
|
||||
|
||||
//
|
||||
// Fat files have 8 character file names and 3 character extensions
|
||||
//
|
||||
|
||||
typedef UCHAR FAT8DOT3[11];
|
||||
typedef FAT8DOT3 *PFAT8DOT3;
|
||||
|
||||
|
||||
//
|
||||
// The directory entry record exists for every file/directory on the
|
||||
// disk except for the root directory.
|
||||
//
|
||||
|
||||
typedef struct _PACKED_DIRENT {
|
||||
FAT8DOT3 FileName; // offset = 0
|
||||
UCHAR Attributes; // offset = 11
|
||||
UCHAR NtByte; // offset = 12
|
||||
UCHAR CreationMSec; // offset = 13
|
||||
FAT_TIME_STAMP CreationTime; // offset = 14
|
||||
FAT_DATE LastAccessDate; // offset = 18
|
||||
union {
|
||||
USHORT ExtendedAttributes; // offset = 20
|
||||
USHORT FirstClusterOfFileHi; // offset = 20
|
||||
};
|
||||
FAT_TIME_STAMP LastWriteTime; // offset = 22
|
||||
USHORT FirstClusterOfFile; // offset = 26
|
||||
ULONG32 FileSize; // offset = 28
|
||||
} PACKED_DIRENT; // sizeof = 32
|
||||
typedef PACKED_DIRENT *PPACKED_DIRENT;
|
||||
|
||||
//
|
||||
// A packed dirent is already quadword aligned so simply declare a dirent as a
|
||||
// packed dirent
|
||||
//
|
||||
|
||||
typedef PACKED_DIRENT DIRENT;
|
||||
typedef DIRENT *PDIRENT;
|
||||
|
||||
//
|
||||
// The first byte of a dirent describes the dirent. There is also a routine
|
||||
// to help in deciding how to interpret the dirent.
|
||||
//
|
||||
|
||||
#define FAT_DIRENT_NEVER_USED 0x00
|
||||
#define FAT_DIRENT_REALLY_0E5 0x05
|
||||
#define FAT_DIRENT_DIRECTORY_ALIAS 0x2e
|
||||
#define FAT_DIRENT_DELETED 0xe5
|
||||
|
||||
//
|
||||
// Define the NtByte bits.
|
||||
//
|
||||
|
||||
//
|
||||
// These two bits are used for EFS on FAT
|
||||
// 0x1 means the file contents are encrypted
|
||||
//
|
||||
// 0x2 means the EFS metadata header is big.
|
||||
// (this optimization means we don't have to read
|
||||
// in the first sector of the file stream to get
|
||||
// the normal header size)
|
||||
//
|
||||
|
||||
#define FAT_DIRENT_NT_BYTE_ENCRYPTED 0x01
|
||||
#define FAT_DIRENT_NT_BYTE_BIG_HEADER 0x02
|
||||
|
||||
//
|
||||
// These two bits optimize the case in which either the name
|
||||
// or extension are all lower case.
|
||||
//
|
||||
|
||||
#define FAT_DIRENT_NT_BYTE_8_LOWER_CASE 0x08
|
||||
#define FAT_DIRENT_NT_BYTE_3_LOWER_CASE 0x10
|
||||
|
||||
//
|
||||
// Define the various dirent attributes
|
||||
//
|
||||
|
||||
#define FAT_DIRENT_ATTR_READ_ONLY 0x01
|
||||
#define FAT_DIRENT_ATTR_HIDDEN 0x02
|
||||
#define FAT_DIRENT_ATTR_SYSTEM 0x04
|
||||
#define FAT_DIRENT_ATTR_VOLUME_ID 0x08
|
||||
#define FAT_DIRENT_ATTR_DIRECTORY 0x10
|
||||
#define FAT_DIRENT_ATTR_ARCHIVE 0x20
|
||||
#define FAT_DIRENT_ATTR_DEVICE 0x40
|
||||
#define FAT_DIRENT_ATTR_LFN (FAT_DIRENT_ATTR_READ_ONLY | \
|
||||
FAT_DIRENT_ATTR_HIDDEN | \
|
||||
FAT_DIRENT_ATTR_SYSTEM | \
|
||||
FAT_DIRENT_ATTR_VOLUME_ID)
|
||||
|
||||
//
|
||||
// On-disk extension for EFS files.
|
||||
//
|
||||
|
||||
#define FAT_EFS_EXTENSION L".PFILE"
|
||||
#define FAT_EFS_EXTENSION_CHARCOUNT (6)
|
||||
#define FAT_EFS_EXTENSION_BYTECOUNT (12)
|
||||
|
||||
|
||||
//
|
||||
// These macros convert a number of fields in the Bpb to bytes from sectors
|
||||
//
|
||||
// ULONG
|
||||
// FatBytesPerCluster (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
// ULONG
|
||||
// FatBytesPerFat (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
// ULONG
|
||||
// FatReservedBytes (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatBytesPerCluster(B) ((ULONG)((B)->BytesPerSector * (B)->SectorsPerCluster))
|
||||
|
||||
#define FatBytesPerFat(B) (IsBpbFat32(B)? \
|
||||
((ULONG)((B)->BytesPerSector * (B)->LargeSectorsPerFat)) : \
|
||||
((ULONG)((B)->BytesPerSector * (B)->SectorsPerFat)))
|
||||
|
||||
#define FatReservedBytes(B) ((ULONG)((B)->BytesPerSector * (B)->ReservedSectors))
|
||||
|
||||
//
|
||||
// This macro returns the size of the root directory dirent area in bytes
|
||||
// For Fat32, the root directory is variable in length. This macro returns
|
||||
// 0 because it is also used to determine the location of cluster 2.
|
||||
//
|
||||
// ULONG
|
||||
// FatRootDirectorySize (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatRootDirectorySize(B) ((ULONG)((B)->RootEntries * sizeof(DIRENT)))
|
||||
|
||||
|
||||
//
|
||||
// This macro returns the first Lbo (zero based) of the root directory on
|
||||
// the device. This area is after the reserved and fats.
|
||||
//
|
||||
// For Fat32, the root directory is moveable. This macro returns the LBO
|
||||
// for cluster 2 because it is used to determine the location of cluster 2.
|
||||
// FatRootDirectoryLbo32() returns the actual LBO of the beginning of the
|
||||
// actual root directory.
|
||||
//
|
||||
// LBO
|
||||
// FatRootDirectoryLbo (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatRootDirectoryLbo(B) (FatReservedBytes(B) + ((B)->Fats * FatBytesPerFat(B)))
|
||||
#define FatRootDirectoryLbo32(B) (FatFileAreaLbo(B)+((B)->RootDirFirstCluster-2)*FatBytesPerCluster(B))
|
||||
|
||||
//
|
||||
// This macro returns the first Lbo (zero based) of the file area on the
|
||||
// the device. This area is after the reserved, fats, and root directory.
|
||||
//
|
||||
// LBO
|
||||
// FatFirstFileAreaLbo (
|
||||
// IN PBIOS_PARAMTER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatFileAreaLbo(B) (FatRootDirectoryLbo(B) + FatRootDirectorySize(B))
|
||||
|
||||
//
|
||||
// This macro returns the number of clusters on the disk. This value is
|
||||
// computed by taking the total sectors on the disk subtracting up to the
|
||||
// first file area sector and then dividing by the sectors per cluster count.
|
||||
// Note that I don't use any of the above macros since far too much
|
||||
// superfluous sector/byte conversion would take place.
|
||||
//
|
||||
// ULONG
|
||||
// FatNumberOfClusters (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
//
|
||||
// for prior to MS-DOS Version 3.2
|
||||
//
|
||||
// After DOS 4.0, at least one of these, Sectors or LargeSectors, will be zero.
|
||||
// but DOS version 3.2 case, both of these value might contains some value,
|
||||
// because, before 3.2, we don't have Large Sector entry, some disk might have
|
||||
// unexpected value in the field, we will use LargeSectors if Sectors eqaul to zero.
|
||||
//
|
||||
|
||||
#define FatNumberOfClusters(B) ( \
|
||||
\
|
||||
IsBpbFat32(B) ? \
|
||||
\
|
||||
((((B)->Sectors ? (B)->Sectors : (B)->LargeSectors) \
|
||||
\
|
||||
- ((B)->ReservedSectors + \
|
||||
(B)->Fats * (B)->LargeSectorsPerFat )) \
|
||||
\
|
||||
/ \
|
||||
\
|
||||
(B)->SectorsPerCluster) \
|
||||
: \
|
||||
((((B)->Sectors ? (B)->Sectors : (B)->LargeSectors) \
|
||||
\
|
||||
- ((B)->ReservedSectors + \
|
||||
(B)->Fats * (B)->SectorsPerFat + \
|
||||
(B)->RootEntries * sizeof(DIRENT) / (B)->BytesPerSector ) ) \
|
||||
\
|
||||
/ \
|
||||
\
|
||||
(B)->SectorsPerCluster) \
|
||||
)
|
||||
|
||||
//
|
||||
// This macro returns the fat table bit size (i.e., 12 or 16 bits)
|
||||
//
|
||||
// ULONG
|
||||
// FatIndexBitSize (
|
||||
// IN PBIOS_PARAMETER_BLOCK Bios
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatIndexBitSize(B) \
|
||||
((UCHAR)(IsBpbFat32(B) ? 32 : (FatNumberOfClusters(B) < 4087 ? 12 : 16)))
|
||||
|
||||
//
|
||||
// This macro raises STATUS_FILE_CORRUPT and marks the Fcb bad if an
|
||||
// index value is not within the proper range.
|
||||
// Note that the first two index values are invalid (0, 1), so we must
|
||||
// add two from the top end to make sure the everything is within range
|
||||
//
|
||||
// VOID
|
||||
// FatVerifyIndexIsValid (
|
||||
// IN PIRP_CONTEXT IrpContext,
|
||||
// IN PVCB Vcb,
|
||||
// IN ULONG Index
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatVerifyIndexIsValid(IC,V,I) { \
|
||||
if (((I) < 2) || ((I) > ((V)->AllocationSupport.NumberOfClusters + 1))) { \
|
||||
FatRaiseStatus(IC,STATUS_FILE_CORRUPT_ERROR); \
|
||||
} \
|
||||
}
|
||||
|
||||
//
|
||||
// These two macros are used to translate between Logical Byte Offsets,
|
||||
// and fat entry indexes. Note the use of variables stored in the Vcb.
|
||||
// These two macros are used at a higher level than the other macros
|
||||
// above.
|
||||
//
|
||||
// Note, these indexes are true cluster numbers.
|
||||
//
|
||||
// LBO
|
||||
// GetLboFromFatIndex (
|
||||
// IN FAT_ENTRY Fat_Index,
|
||||
// IN PVCB Vcb
|
||||
// );
|
||||
//
|
||||
// FAT_ENTRY
|
||||
// GetFatIndexFromLbo (
|
||||
// IN LBO Lbo,
|
||||
// IN PVCB Vcb
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatGetLboFromIndex(VCB,FAT_INDEX) ( \
|
||||
( (LBO) \
|
||||
(VCB)->AllocationSupport.FileAreaLbo + \
|
||||
(((LBO)((FAT_INDEX) - 2)) << (VCB)->AllocationSupport.LogOfBytesPerCluster) \
|
||||
) \
|
||||
)
|
||||
|
||||
#define FatGetIndexFromLbo(VCB,LBO) ( \
|
||||
(ULONG) ( \
|
||||
(((LBO) - (VCB)->AllocationSupport.FileAreaLbo) >> \
|
||||
(VCB)->AllocationSupport.LogOfBytesPerCluster) + 2 \
|
||||
) \
|
||||
)
|
||||
|
||||
//
|
||||
// The following macro does the shifting and such to lookup an entry
|
||||
//
|
||||
// VOID
|
||||
// FatLookup12BitEntry(
|
||||
// IN PVOID Fat,
|
||||
// IN FAT_ENTRY Index,
|
||||
// OUT PFAT_ENTRY Entry
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatLookup12BitEntry(FAT,INDEX,ENTRY) { \
|
||||
\
|
||||
CopyUchar2((PUCHAR)(ENTRY), (PUCHAR)(FAT) + (INDEX) * 3 / 2); \
|
||||
\
|
||||
*ENTRY = (FAT_ENTRY)(0xfff & (((INDEX) & 1) ? (*(ENTRY) >> 4) : \
|
||||
*(ENTRY))); \
|
||||
}
|
||||
|
||||
//
|
||||
// The following macro does the tmp shifting and such to store an entry
|
||||
//
|
||||
// VOID
|
||||
// FatSet12BitEntry(
|
||||
// IN PVOID Fat,
|
||||
// IN FAT_ENTRY Index,
|
||||
// IN FAT_ENTRY Entry
|
||||
// );
|
||||
//
|
||||
|
||||
#define FatSet12BitEntry(FAT,INDEX,ENTRY) { \
|
||||
\
|
||||
FAT_ENTRY TmpFatEntry; \
|
||||
\
|
||||
CopyUchar2((PUCHAR)&TmpFatEntry, (PUCHAR)(FAT) + (INDEX) * 3 / 2); \
|
||||
\
|
||||
TmpFatEntry = (FAT_ENTRY) \
|
||||
(((INDEX) & 1) ? ((ENTRY) << 4) | (TmpFatEntry & 0xf) \
|
||||
: (ENTRY) | (TmpFatEntry & 0xf000)); \
|
||||
\
|
||||
*((UNALIGNED UCHAR2 *)((PUCHAR)(FAT) + (INDEX) * 3 / 2)) = *((UNALIGNED UCHAR2 *)(&TmpFatEntry)); \
|
||||
}
|
||||
|
||||
//
|
||||
// The following macro compares two FAT_TIME_STAMPs
|
||||
//
|
||||
|
||||
#define FatAreTimesEqual(TIME1,TIME2) ( \
|
||||
RtlEqualMemory((TIME1),(TIME2), sizeof(FAT_TIME_STAMP)) \
|
||||
)
|
||||
|
||||
|
||||
#define EA_FILE_SIGNATURE (0x4445) // "ED"
|
||||
#define EA_SET_SIGNATURE (0x4145) // "EA"
|
||||
|
||||
//
|
||||
// If the volume contains any ea data then there is one EA file called
|
||||
// "EA DATA. SF" located in the root directory as Hidden, System and
|
||||
// ReadOnly.
|
||||
//
|
||||
|
||||
typedef struct _EA_FILE_HEADER {
|
||||
USHORT Signature; // offset = 0
|
||||
USHORT FormatType; // offset = 2
|
||||
USHORT LogType; // offset = 4
|
||||
USHORT Cluster1; // offset = 6
|
||||
USHORT NewCValue1; // offset = 8
|
||||
USHORT Cluster2; // offset = 10
|
||||
USHORT NewCValue2; // offset = 12
|
||||
USHORT Cluster3; // offset = 14
|
||||
USHORT NewCValue3; // offset = 16
|
||||
USHORT Handle; // offset = 18
|
||||
USHORT NewHOffset; // offset = 20
|
||||
UCHAR Reserved[10]; // offset = 22
|
||||
USHORT EaBaseTable[240]; // offset = 32
|
||||
} EA_FILE_HEADER; // sizeof = 512
|
||||
|
||||
typedef EA_FILE_HEADER *PEA_FILE_HEADER;
|
||||
|
||||
typedef USHORT EA_OFF_TABLE[128];
|
||||
|
||||
typedef EA_OFF_TABLE *PEA_OFF_TABLE;
|
||||
|
||||
//
|
||||
// Every file with an extended attribute contains in its dirent an index
|
||||
// into the EaMapTable. The map table contains an offset within the ea
|
||||
// file (cluster aligned) of the ea data for the file. The individual
|
||||
// ea data for each file is prefaced with an Ea Data Header.
|
||||
//
|
||||
|
||||
typedef struct _EA_SET_HEADER {
|
||||
USHORT Signature; // offset = 0
|
||||
USHORT OwnEaHandle; // offset = 2
|
||||
ULONG32 NeedEaCount; // offset = 4
|
||||
UCHAR OwnerFileName[14]; // offset = 8
|
||||
UCHAR Reserved[4]; // offset = 22
|
||||
UCHAR cbList[4]; // offset = 26
|
||||
UCHAR PackedEas[1]; // offset = 30
|
||||
} EA_SET_HEADER; // sizeof = 30
|
||||
typedef EA_SET_HEADER *PEA_SET_HEADER;
|
||||
|
||||
#define SIZE_OF_EA_SET_HEADER 30
|
||||
|
||||
#define MAXIMUM_EA_SIZE 0x0000ffff
|
||||
|
||||
#define GetcbList(EASET) (((EASET)->cbList[0] << 0) + \
|
||||
((EASET)->cbList[1] << 8) + \
|
||||
((EASET)->cbList[2] << 16) + \
|
||||
((EASET)->cbList[3] << 24))
|
||||
|
||||
#define SetcbList(EASET,CB) { \
|
||||
(EASET)->cbList[0] = (CB >> 0) & 0x0ff; \
|
||||
(EASET)->cbList[1] = (CB >> 8) & 0x0ff; \
|
||||
(EASET)->cbList[2] = (CB >> 16) & 0x0ff; \
|
||||
(EASET)->cbList[3] = (CB >> 24) & 0x0ff; \
|
||||
}
|
||||
|
||||
//
|
||||
// Every individual ea in an ea set is declared the following packed ea
|
||||
//
|
||||
|
||||
typedef struct _PACKED_EA {
|
||||
UCHAR Flags;
|
||||
UCHAR EaNameLength;
|
||||
UCHAR EaValueLength[2];
|
||||
CHAR EaName[1];
|
||||
} PACKED_EA;
|
||||
typedef PACKED_EA *PPACKED_EA;
|
||||
|
||||
//
|
||||
// The following two macros are used to get and set the ea value length
|
||||
// field of a packed ea
|
||||
//
|
||||
// VOID
|
||||
// GetEaValueLength (
|
||||
// IN PPACKED_EA Ea,
|
||||
// OUT PUSHORT ValueLength
|
||||
// );
|
||||
//
|
||||
// VOID
|
||||
// SetEaValueLength (
|
||||
// IN PPACKED_EA Ea,
|
||||
// IN USHORT ValueLength
|
||||
// );
|
||||
//
|
||||
|
||||
#define GetEaValueLength(EA,LEN) { \
|
||||
*(LEN) = 0; \
|
||||
CopyUchar2( (LEN), (EA)->EaValueLength ); \
|
||||
}
|
||||
|
||||
#define SetEaValueLength(EA,LEN) { \
|
||||
CopyUchar2( &((EA)->EaValueLength), (LEN) ); \
|
||||
}
|
||||
|
||||
//
|
||||
// The following macro is used to get the size of a packed ea
|
||||
//
|
||||
// VOID
|
||||
// SizeOfPackedEa (
|
||||
// IN PPACKED_EA Ea,
|
||||
// OUT PUSHORT EaSize
|
||||
// );
|
||||
//
|
||||
|
||||
#define SizeOfPackedEa(EA,SIZE) { \
|
||||
ULONG _NL,_DL; _NL = 0; _DL = 0; \
|
||||
CopyUchar1(&_NL, &(EA)->EaNameLength); \
|
||||
GetEaValueLength(EA, &_DL); \
|
||||
*(SIZE) = 1 + 1 + 2 + _NL + 1 + _DL; \
|
||||
}
|
||||
|
||||
#define EA_NEED_EA_FLAG 0x80
|
||||
#define MIN_EA_HANDLE 1
|
||||
#define MAX_EA_HANDLE 30719
|
||||
#define UNUSED_EA_HANDLE 0xffff
|
||||
#define EA_CBLIST_OFFSET 0x1a
|
||||
#define MAX_EA_BASE_INDEX 240
|
||||
#define MAX_EA_OFFSET_INDEX 128
|
||||
|
||||
|
||||
#endif // _FAT_
|
||||
|
||||
1576
drivers/filesystems/fastfat_new/fatdata.c
Normal file
1576
drivers/filesystems/fastfat_new/fatdata.c
Normal file
File diff suppressed because it is too large
Load diff
338
drivers/filesystems/fastfat_new/fatdata.h
Normal file
338
drivers/filesystems/fastfat_new/fatdata.h
Normal file
|
|
@ -0,0 +1,338 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
FatData.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module declares the global data used by the Fat file system.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _FATDATA_
|
||||
#define _FATDATA_
|
||||
|
||||
//
|
||||
// The global fsd data record, and a global zero large integer
|
||||
//
|
||||
|
||||
extern FAT_DATA FatData;
|
||||
|
||||
extern IO_STATUS_BLOCK FatGarbageIosb;
|
||||
|
||||
extern NPAGED_LOOKASIDE_LIST FatIrpContextLookasideList;
|
||||
extern NPAGED_LOOKASIDE_LIST FatNonPagedFcbLookasideList;
|
||||
extern NPAGED_LOOKASIDE_LIST FatEResourceLookasideList;
|
||||
|
||||
extern SLIST_HEADER FatCloseContextSList;
|
||||
extern FAST_MUTEX FatCloseQueueMutex;
|
||||
|
||||
extern PDEVICE_OBJECT FatDiskFileSystemDeviceObject;
|
||||
extern PDEVICE_OBJECT FatCdromFileSystemDeviceObject;
|
||||
|
||||
extern LARGE_INTEGER FatLargeZero;
|
||||
extern LARGE_INTEGER FatMaxLarge;
|
||||
extern LARGE_INTEGER Fat30Milliseconds;
|
||||
extern LARGE_INTEGER Fat100Milliseconds;
|
||||
extern LARGE_INTEGER FatOneSecond;
|
||||
extern LARGE_INTEGER FatOneDay;
|
||||
extern LARGE_INTEGER FatJanOne1980;
|
||||
extern LARGE_INTEGER FatDecThirtyOne1979;
|
||||
|
||||
extern FAT_TIME_STAMP FatTimeJanOne1980;
|
||||
|
||||
extern LARGE_INTEGER FatMagic10000;
|
||||
#define FAT_SHIFT10000 13
|
||||
|
||||
extern LARGE_INTEGER FatMagic86400000;
|
||||
#define FAT_SHIFT86400000 26
|
||||
|
||||
#define FatConvert100nsToMilliseconds(LARGE_INTEGER) ( \
|
||||
RtlExtendedMagicDivide( (LARGE_INTEGER), FatMagic10000, FAT_SHIFT10000 )\
|
||||
)
|
||||
|
||||
#define FatConvertMillisecondsToDays(LARGE_INTEGER) ( \
|
||||
RtlExtendedMagicDivide( (LARGE_INTEGER), FatMagic86400000, FAT_SHIFT86400000 ) \
|
||||
)
|
||||
|
||||
#define FatConvertDaysToMilliseconds(DAYS) ( \
|
||||
Int32x32To64( (DAYS), 86400000 ) \
|
||||
)
|
||||
|
||||
//
|
||||
// Reserve MDL for paging file io forward progress.
|
||||
//
|
||||
|
||||
#define FAT_RESERVE_MDL_SIZE 16
|
||||
|
||||
#ifndef __REACTOS__
|
||||
__volatile extern PMDL FatReserveMdl;
|
||||
#else
|
||||
extern __volatile PMDL FatReserveMdl;
|
||||
#endif
|
||||
extern KEVENT FatReserveEvent;
|
||||
|
||||
//
|
||||
// The global structure used to contain our fast I/O callbacks
|
||||
//
|
||||
|
||||
extern FAST_IO_DISPATCH FatFastIoDispatch;
|
||||
|
||||
//
|
||||
// Global to store disk IO accounting Enabled/Disabled state
|
||||
//
|
||||
|
||||
extern LOGICAL FatDiskAccountingEnabled;
|
||||
|
||||
//
|
||||
// Read ahead amount used for normal data files
|
||||
//
|
||||
|
||||
#define READ_AHEAD_GRANULARITY (0x10000)
|
||||
|
||||
//
|
||||
// Define maximum number of parallel Reads or Writes that will be generated
|
||||
// per one request.
|
||||
//
|
||||
|
||||
#define FAT_MAX_IO_RUNS_ON_STACK ((ULONG) 5)
|
||||
|
||||
//
|
||||
// Define the maximum number of delayed closes.
|
||||
//
|
||||
|
||||
#define FAT_MAX_DELAYED_CLOSES ((ULONG)16)
|
||||
|
||||
extern ULONG FatMaxDelayedCloseCount;
|
||||
|
||||
//
|
||||
// The maximum chunk size we use when defragmenting files.
|
||||
//
|
||||
|
||||
#define FAT_DEFAULT_DEFRAG_CHUNK_IN_BYTES (0x10000)
|
||||
|
||||
//
|
||||
// Define constant for time rounding.
|
||||
//
|
||||
|
||||
#define TenMSec (10*1000*10)
|
||||
#define TwoSeconds (2*1000*1000*10)
|
||||
#define AlmostTenMSec (TenMSec - 1)
|
||||
#define AlmostTwoSeconds (TwoSeconds - 1)
|
||||
|
||||
// too big #define HighPartPerDay (24*60*60*1000*1000*10 >> 32)
|
||||
|
||||
#define HighPartPerDay (52734375 >> 18)
|
||||
|
||||
//
|
||||
// The global Fat debug level variable, its values are:
|
||||
//
|
||||
// 0x00000000 Always gets printed (used when about to bug check)
|
||||
//
|
||||
// 0x00000001 Error conditions
|
||||
// 0x00000002 Debug hooks
|
||||
// 0x00000004 Catch exceptions before completing Irp
|
||||
// 0x00000008
|
||||
//
|
||||
// 0x00000010
|
||||
// 0x00000020
|
||||
// 0x00000040
|
||||
// 0x00000080
|
||||
//
|
||||
// 0x00000100
|
||||
// 0x00000200
|
||||
// 0x00000400
|
||||
// 0x00000800
|
||||
//
|
||||
// 0x00001000
|
||||
// 0x00002000
|
||||
// 0x00004000
|
||||
// 0x00008000
|
||||
//
|
||||
// 0x00010000
|
||||
// 0x00020000
|
||||
// 0x00040000
|
||||
// 0x00080000
|
||||
//
|
||||
// 0x00100000
|
||||
// 0x00200000
|
||||
// 0x00400000
|
||||
// 0x00800000
|
||||
//
|
||||
// 0x01000000
|
||||
// 0x02000000
|
||||
// 0x04000000
|
||||
// 0x08000000
|
||||
//
|
||||
// 0x10000000
|
||||
// 0x20000000
|
||||
// 0x40000000
|
||||
// 0x80000000
|
||||
//
|
||||
|
||||
|
||||
#ifdef FASTFATDBG
|
||||
|
||||
#define DEBUG_TRACE_ERROR (0x00000001)
|
||||
#define DEBUG_TRACE_DEBUG_HOOKS (0x00000002)
|
||||
#define DEBUG_TRACE_CATCH_EXCEPTIONS (0x00000004)
|
||||
#define DEBUG_TRACE_UNWIND (0x00000008)
|
||||
#define DEBUG_TRACE_CLEANUP (0x00000010)
|
||||
#define DEBUG_TRACE_CLOSE (0x00000020)
|
||||
#define DEBUG_TRACE_CREATE (0x00000040)
|
||||
#define DEBUG_TRACE_DIRCTRL (0x00000080)
|
||||
#define DEBUG_TRACE_EA (0x00000100)
|
||||
#define DEBUG_TRACE_FILEINFO (0x00000200)
|
||||
#define DEBUG_TRACE_FSCTRL (0x00000400)
|
||||
#define DEBUG_TRACE_LOCKCTRL (0x00000800)
|
||||
#define DEBUG_TRACE_READ (0x00001000)
|
||||
#define DEBUG_TRACE_VOLINFO (0x00002000)
|
||||
#define DEBUG_TRACE_WRITE (0x00004000)
|
||||
#define DEBUG_TRACE_FLUSH (0x00008000)
|
||||
#define DEBUG_TRACE_DEVCTRL (0x00010000)
|
||||
#define DEBUG_TRACE_SHUTDOWN (0x00020000)
|
||||
#define DEBUG_TRACE_FATDATA (0x00040000)
|
||||
#define DEBUG_TRACE_PNP (0x00080000)
|
||||
#define DEBUG_TRACE_ACCHKSUP (0x00100000)
|
||||
#define DEBUG_TRACE_ALLOCSUP (0x00200000)
|
||||
#define DEBUG_TRACE_DIRSUP (0x00400000)
|
||||
#define DEBUG_TRACE_FILOBSUP (0x00800000)
|
||||
#define DEBUG_TRACE_NAMESUP (0x01000000)
|
||||
#define DEBUG_TRACE_VERFYSUP (0x02000000)
|
||||
#define DEBUG_TRACE_CACHESUP (0x04000000)
|
||||
#define DEBUG_TRACE_SPLAYSUP (0x08000000)
|
||||
#define DEBUG_TRACE_DEVIOSUP (0x10000000)
|
||||
#define DEBUG_TRACE_STRUCSUP (0x20000000)
|
||||
#define DEBUG_TRACE_FSP_DISPATCHER (0x40000000)
|
||||
#define DEBUG_TRACE_FSP_DUMP (0x80000000)
|
||||
|
||||
extern LONG FatDebugTraceLevel;
|
||||
extern LONG FatDebugTraceIndent;
|
||||
|
||||
#define DebugTrace(INDENT,LEVEL,X,Y) { \
|
||||
LONG _i; \
|
||||
if (((LEVEL) == 0) || (FatDebugTraceLevel & (LEVEL))) { \
|
||||
_i = (ULONG)PsGetCurrentThread(); \
|
||||
DbgPrint("%08lx:",_i); \
|
||||
if ((INDENT) < 0) { \
|
||||
FatDebugTraceIndent += (INDENT); \
|
||||
} \
|
||||
if (FatDebugTraceIndent < 0) { \
|
||||
FatDebugTraceIndent = 0; \
|
||||
} \
|
||||
for (_i = 0; _i < FatDebugTraceIndent; _i += 1) { \
|
||||
DbgPrint(" "); \
|
||||
} \
|
||||
DbgPrint(X,Y); \
|
||||
if ((INDENT) > 0) { \
|
||||
FatDebugTraceIndent += (INDENT); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define DebugDump(STR,LEVEL,PTR) { \
|
||||
__pragma(warning(push)) \
|
||||
__pragma(warning(disable:4210)) \
|
||||
ULONG _i; \
|
||||
VOID FatDump(IN PVOID Ptr); \
|
||||
if (((LEVEL) == 0) || (FatDebugTraceLevel & (LEVEL))) { \
|
||||
_i = (ULONG)PsGetCurrentThread(); \
|
||||
DbgPrint("%08lx:",_i); \
|
||||
DbgPrint(STR); \
|
||||
if (PTR != NULL) {FatDump(PTR);} \
|
||||
NT_ASSERT(FALSE); \
|
||||
} \
|
||||
__pragma(warning(pop)) \
|
||||
}
|
||||
|
||||
#define DebugUnwind(X) { \
|
||||
if (AbnormalTermination()) { \
|
||||
DebugTrace(0, DEBUG_TRACE_UNWIND, #X ", Abnormal termination.\n", 0); \
|
||||
} \
|
||||
}
|
||||
|
||||
//
|
||||
// The following variables are used to keep track of the total amount
|
||||
// of requests processed by the file system, and the number of requests
|
||||
// that end up being processed by the Fsp thread. The first variable
|
||||
// is incremented whenever an Irp context is created (which is always
|
||||
// at the start of an Fsd entry point) and the second is incremented
|
||||
// by read request.
|
||||
//
|
||||
|
||||
extern ULONG FatFsdEntryCount;
|
||||
extern ULONG FatFspEntryCount;
|
||||
extern ULONG FatIoCallDriverCount;
|
||||
extern ULONG FatTotalTicks[];
|
||||
|
||||
#define DebugDoit(X) {X;}
|
||||
|
||||
extern LONG FatPerformanceTimerLevel;
|
||||
|
||||
#define TimerStart(LEVEL) { \
|
||||
LARGE_INTEGER TStart, TEnd; \
|
||||
LARGE_INTEGER TElapsed; \
|
||||
TStart = KeQueryPerformanceCounter( NULL ); \
|
||||
|
||||
#define TimerStop(LEVEL,s) \
|
||||
TEnd = KeQueryPerformanceCounter( NULL ); \
|
||||
TElapsed.QuadPart = TEnd.QuadPart - TStart.QuadPart; \
|
||||
FatTotalTicks[FatLogOf(LEVEL)] += TElapsed.LowPart; \
|
||||
if (FlagOn( FatPerformanceTimerLevel, (LEVEL))) { \
|
||||
DbgPrint("Time of %s %ld\n", (s), TElapsed.LowPart ); \
|
||||
} \
|
||||
}
|
||||
|
||||
//
|
||||
// I need this because C can't support conditional compilation within
|
||||
// a macro.
|
||||
//
|
||||
|
||||
extern PVOID FatNull;
|
||||
|
||||
#else
|
||||
|
||||
#define DebugTrace(INDENT,LEVEL,X,Y) {NOTHING;}
|
||||
#define DebugDump(STR,LEVEL,PTR) {NOTHING;}
|
||||
#define DebugUnwind(X) {NOTHING;}
|
||||
#define DebugDoit(X) {NOTHING;}
|
||||
|
||||
#define TimerStart(LEVEL)
|
||||
#define TimerStop(LEVEL,s)
|
||||
|
||||
#define FatNull NULL
|
||||
|
||||
#endif // FASTFATDBG
|
||||
|
||||
//
|
||||
// The following macro is for all people who compile with the DBG switch
|
||||
// set, not just fastfat dbg users
|
||||
//
|
||||
|
||||
#if DBG
|
||||
|
||||
#define DbgDoit(X) {X;}
|
||||
|
||||
#else
|
||||
|
||||
#define DbgDoit(X) {NOTHING;}
|
||||
|
||||
#endif // DBG
|
||||
|
||||
#if DBG
|
||||
|
||||
extern NTSTATUS FatBreakOnInterestingIoCompletion;
|
||||
extern NTSTATUS FatBreakOnInterestingExceptionStatus;
|
||||
extern NTSTATUS FatBreakOnInterestingIrpCompletion;
|
||||
|
||||
extern BOOLEAN FatTestRaisedStatus;
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _FATDATA_
|
||||
|
||||
|
||||
771
drivers/filesystems/fastfat_new/fatinit.c
Normal file
771
drivers/filesystems/fastfat_new/fatinit.c
Normal file
|
|
@ -0,0 +1,771 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
FatInit.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the DRIVER_INITIALIZATION routine for Fat
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
DRIVER_INITIALIZE DriverEntry;
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
DriverEntry(
|
||||
_In_ PDRIVER_OBJECT DriverObject,
|
||||
_In_ PUNICODE_STRING RegistryPath
|
||||
);
|
||||
|
||||
_Function_class_(DRIVER_UNLOAD)
|
||||
VOID
|
||||
NTAPI
|
||||
FatUnload(
|
||||
#ifndef __REACTOS__
|
||||
_In_ _Unreferenced_parameter_ PDRIVER_OBJECT DriverObject
|
||||
#else
|
||||
_In_ PDRIVER_OBJECT DriverObject
|
||||
#endif
|
||||
);
|
||||
|
||||
NTSTATUS
|
||||
FatGetCompatibilityModeValue(
|
||||
IN PUNICODE_STRING ValueName,
|
||||
IN OUT PULONG Value
|
||||
);
|
||||
|
||||
BOOLEAN
|
||||
FatIsFujitsuFMR (
|
||||
);
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(INIT, DriverEntry)
|
||||
#pragma alloc_text(INIT, FatGetCompatibilityModeValue)
|
||||
#pragma alloc_text(INIT, FatIsFujitsuFMR)
|
||||
//#pragma alloc_text(PAGE, FatUnload)
|
||||
#endif
|
||||
|
||||
#define COMPATIBILITY_MODE_KEY_NAME L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\FileSystem"
|
||||
#define COMPATIBILITY_MODE_VALUE_NAME L"Win31FileSystem"
|
||||
#define CODE_PAGE_INVARIANCE_VALUE_NAME L"FatDisableCodePageInvariance"
|
||||
|
||||
|
||||
#define KEY_WORK_AREA ((sizeof(KEY_VALUE_FULL_INFORMATION) + \
|
||||
sizeof(ULONG)) + 64)
|
||||
|
||||
#define REGISTRY_HARDWARE_DESCRIPTION_W \
|
||||
L"\\Registry\\Machine\\Hardware\\DESCRIPTION\\System"
|
||||
|
||||
#define REGISTRY_MACHINE_IDENTIFIER_W L"Identifier"
|
||||
|
||||
#define FUJITSU_FMR_NAME_W L"FUJITSU FMR-"
|
||||
|
||||
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
DriverEntry(
|
||||
_In_ PDRIVER_OBJECT DriverObject,
|
||||
_In_ PUNICODE_STRING RegistryPath
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the initialization routine for the Fat file system
|
||||
device driver. This routine creates the device object for the FileSystem
|
||||
device and performs all other driver initialization.
|
||||
|
||||
Arguments:
|
||||
|
||||
DriverObject - Pointer to driver object created by the system.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The function value is the final status from the initialization
|
||||
operation.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
USHORT MaxDepth;
|
||||
NTSTATUS Status;
|
||||
UNICODE_STRING UnicodeString;
|
||||
FS_FILTER_CALLBACKS FilterCallbacks;
|
||||
UNICODE_STRING ValueName;
|
||||
ULONG Value;
|
||||
|
||||
UNREFERENCED_PARAMETER( RegistryPath );
|
||||
|
||||
//
|
||||
// Create the device object for disks. To avoid problems with filters who
|
||||
// know this name, we must keep it.
|
||||
//
|
||||
|
||||
RtlInitUnicodeString( &UnicodeString, L"\\Fat" );
|
||||
Status = IoCreateDevice( DriverObject,
|
||||
0,
|
||||
&UnicodeString,
|
||||
FILE_DEVICE_DISK_FILE_SYSTEM,
|
||||
0,
|
||||
FALSE,
|
||||
&FatDiskFileSystemDeviceObject );
|
||||
|
||||
if (!NT_SUCCESS( Status )) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Create the device object for "cdroms".
|
||||
//
|
||||
|
||||
RtlInitUnicodeString( &UnicodeString, L"\\FatCdrom" );
|
||||
Status = IoCreateDevice( DriverObject,
|
||||
0,
|
||||
&UnicodeString,
|
||||
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
|
||||
0,
|
||||
FALSE,
|
||||
&FatCdromFileSystemDeviceObject );
|
||||
|
||||
if (!NT_SUCCESS( Status )) {
|
||||
IoDeleteDevice( FatDiskFileSystemDeviceObject);
|
||||
return Status;
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( push )
|
||||
#pragma prefast( disable:28155, "these are all correct" )
|
||||
#pragma prefast( disable:28169, "these are all correct" )
|
||||
#pragma prefast( disable:28175, "this is a filesystem, touching FastIoDispatch is allowed" )
|
||||
#endif
|
||||
|
||||
DriverObject->DriverUnload = FatUnload;
|
||||
|
||||
//
|
||||
// Note that because of the way data caching is done, we set neither
|
||||
// the Direct I/O or Buffered I/O bit in DeviceObject->Flags. If
|
||||
// data is not in the cache, or the request is not buffered, we may,
|
||||
// set up for Direct I/O by hand.
|
||||
//
|
||||
|
||||
//
|
||||
// Initialize the driver object with this driver's entry points.
|
||||
//
|
||||
|
||||
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)FatFsdCreate;
|
||||
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)FatFsdClose;
|
||||
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)FatFsdRead;
|
||||
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)FatFsdWrite;
|
||||
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryInformation;
|
||||
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetInformation;
|
||||
DriverObject->MajorFunction[IRP_MJ_QUERY_EA] = (PDRIVER_DISPATCH)FatFsdQueryEa;
|
||||
DriverObject->MajorFunction[IRP_MJ_SET_EA] = (PDRIVER_DISPATCH)FatFsdSetEa;
|
||||
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)FatFsdFlushBuffers;
|
||||
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryVolumeInformation;
|
||||
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetVolumeInformation;
|
||||
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)FatFsdCleanup;
|
||||
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = (PDRIVER_DISPATCH)FatFsdDirectoryControl;
|
||||
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)FatFsdFileSystemControl;
|
||||
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = (PDRIVER_DISPATCH)FatFsdLockControl;
|
||||
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)FatFsdDeviceControl;
|
||||
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)FatFsdShutdown;
|
||||
DriverObject->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH)FatFsdPnp;
|
||||
|
||||
DriverObject->FastIoDispatch = &FatFastIoDispatch;
|
||||
|
||||
RtlZeroMemory(&FatFastIoDispatch, sizeof(FatFastIoDispatch));
|
||||
|
||||
FatFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
|
||||
FatFastIoDispatch.FastIoCheckIfPossible = FatFastIoCheckIfPossible; // CheckForFastIo
|
||||
FatFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read
|
||||
FatFastIoDispatch.FastIoWrite = FsRtlCopyWrite; // Write
|
||||
FatFastIoDispatch.FastIoQueryBasicInfo = FatFastQueryBasicInfo; // QueryBasicInfo
|
||||
FatFastIoDispatch.FastIoQueryStandardInfo = FatFastQueryStdInfo; // QueryStandardInfo
|
||||
FatFastIoDispatch.FastIoLock = FatFastLock; // Lock
|
||||
FatFastIoDispatch.FastIoUnlockSingle = FatFastUnlockSingle; // UnlockSingle
|
||||
FatFastIoDispatch.FastIoUnlockAll = FatFastUnlockAll; // UnlockAll
|
||||
FatFastIoDispatch.FastIoUnlockAllByKey = FatFastUnlockAllByKey; // UnlockAllByKey
|
||||
FatFastIoDispatch.FastIoQueryNetworkOpenInfo = FatFastQueryNetworkOpenInfo;
|
||||
FatFastIoDispatch.AcquireForCcFlush = FatAcquireForCcFlush;
|
||||
FatFastIoDispatch.ReleaseForCcFlush = FatReleaseForCcFlush;
|
||||
FatFastIoDispatch.MdlRead = FsRtlMdlReadDev;
|
||||
FatFastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
|
||||
FatFastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
|
||||
FatFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( pop )
|
||||
#endif
|
||||
|
||||
//
|
||||
// Initialize the filter callbacks we use.
|
||||
//
|
||||
|
||||
RtlZeroMemory( &FilterCallbacks,
|
||||
sizeof(FS_FILTER_CALLBACKS) );
|
||||
|
||||
FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
|
||||
FilterCallbacks.PreAcquireForSectionSynchronization = FatFilterCallbackAcquireForCreateSection;
|
||||
|
||||
Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject,
|
||||
&FilterCallbacks );
|
||||
|
||||
if (!NT_SUCCESS( Status )) {
|
||||
|
||||
IoDeleteDevice( FatDiskFileSystemDeviceObject );
|
||||
IoDeleteDevice( FatCdromFileSystemDeviceObject );
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Initialize the global data structures
|
||||
//
|
||||
|
||||
//
|
||||
// The FatData record
|
||||
//
|
||||
|
||||
RtlZeroMemory( &FatData, sizeof(FAT_DATA));
|
||||
|
||||
FatData.NodeTypeCode = FAT_NTC_DATA_HEADER;
|
||||
FatData.NodeByteSize = sizeof(FAT_DATA);
|
||||
|
||||
InitializeListHead(&FatData.VcbQueue);
|
||||
|
||||
FatData.DriverObject = DriverObject;
|
||||
FatData.DiskFileSystemDeviceObject = FatDiskFileSystemDeviceObject;
|
||||
FatData.CdromFileSystemDeviceObject = FatCdromFileSystemDeviceObject;
|
||||
|
||||
//
|
||||
// This list head keeps track of closes yet to be done.
|
||||
//
|
||||
|
||||
InitializeListHead( &FatData.AsyncCloseList );
|
||||
InitializeListHead( &FatData.DelayedCloseList );
|
||||
|
||||
FatData.FatCloseItem = IoAllocateWorkItem( FatDiskFileSystemDeviceObject);
|
||||
|
||||
if (FatData.FatCloseItem == NULL) {
|
||||
IoDeleteDevice (FatDiskFileSystemDeviceObject);
|
||||
IoDeleteDevice (FatCdromFileSystemDeviceObject);
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate the zero page
|
||||
//
|
||||
|
||||
#ifndef __REACTOS__
|
||||
FatData.ZeroPage = ExAllocatePoolWithTag( NonPagedPoolNx, PAGE_SIZE, 'ZtaF' );
|
||||
#else
|
||||
FatData.ZeroPage = ExAllocatePoolWithTag( NonPagedPool, PAGE_SIZE, 'ZtaF' );
|
||||
#endif
|
||||
if (FatData.ZeroPage == NULL) {
|
||||
IoDeleteDevice (FatDiskFileSystemDeviceObject);
|
||||
IoDeleteDevice (FatCdromFileSystemDeviceObject);
|
||||
return STATUS_INSUFFICIENT_RESOURCES;
|
||||
}
|
||||
RtlZeroMemory( FatData.ZeroPage, PAGE_SIZE );
|
||||
|
||||
|
||||
//
|
||||
// Now initialize our general purpose spinlock (gag) and figure out how
|
||||
// deep and wide we want our delayed lists (along with fooling ourselves
|
||||
// about the lookaside depths).
|
||||
//
|
||||
|
||||
KeInitializeSpinLock( &FatData.GeneralSpinLock );
|
||||
|
||||
switch ( MmQuerySystemSize() ) {
|
||||
|
||||
case MmSmallSystem:
|
||||
|
||||
MaxDepth = 4;
|
||||
FatMaxDelayedCloseCount = FAT_MAX_DELAYED_CLOSES;
|
||||
break;
|
||||
|
||||
case MmMediumSystem:
|
||||
|
||||
MaxDepth = 8;
|
||||
FatMaxDelayedCloseCount = 4 * FAT_MAX_DELAYED_CLOSES;
|
||||
break;
|
||||
|
||||
case MmLargeSystem:
|
||||
default:
|
||||
|
||||
MaxDepth = 16;
|
||||
FatMaxDelayedCloseCount = 16 * FAT_MAX_DELAYED_CLOSES;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Initialize the cache manager callback routines
|
||||
//
|
||||
|
||||
FatData.CacheManagerCallbacks.AcquireForLazyWrite = &FatAcquireFcbForLazyWrite;
|
||||
FatData.CacheManagerCallbacks.ReleaseFromLazyWrite = &FatReleaseFcbFromLazyWrite;
|
||||
FatData.CacheManagerCallbacks.AcquireForReadAhead = &FatAcquireFcbForReadAhead;
|
||||
FatData.CacheManagerCallbacks.ReleaseFromReadAhead = &FatReleaseFcbFromReadAhead;
|
||||
|
||||
FatData.CacheManagerNoOpCallbacks.AcquireForLazyWrite = &FatNoOpAcquire;
|
||||
FatData.CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = &FatNoOpRelease;
|
||||
FatData.CacheManagerNoOpCallbacks.AcquireForReadAhead = &FatNoOpAcquire;
|
||||
FatData.CacheManagerNoOpCallbacks.ReleaseFromReadAhead = &FatNoOpRelease;
|
||||
|
||||
//
|
||||
// Set up global pointer to our process.
|
||||
//
|
||||
|
||||
FatData.OurProcess = PsGetCurrentProcess();
|
||||
|
||||
//
|
||||
// Setup the number of processors we support for statistics as the current number
|
||||
// running.
|
||||
//
|
||||
|
||||
#if (NTDDI_VERSION >= NTDDI_VISTA)
|
||||
FatData.NumberProcessors = KeQueryActiveProcessorCount( NULL );
|
||||
#else
|
||||
FatData.NumberProcessors = KeNumberProcessors;
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// Read the registry to determine if we are in ChicagoMode.
|
||||
//
|
||||
|
||||
ValueName.Buffer = COMPATIBILITY_MODE_VALUE_NAME;
|
||||
ValueName.Length = sizeof(COMPATIBILITY_MODE_VALUE_NAME) - sizeof(WCHAR);
|
||||
ValueName.MaximumLength = sizeof(COMPATIBILITY_MODE_VALUE_NAME);
|
||||
|
||||
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
|
||||
|
||||
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
|
||||
|
||||
FatData.ChicagoMode = FALSE;
|
||||
|
||||
} else {
|
||||
|
||||
FatData.ChicagoMode = TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Read the registry to determine if we are going to generate LFNs
|
||||
// for valid 8.3 names with extended characters.
|
||||
//
|
||||
|
||||
ValueName.Buffer = CODE_PAGE_INVARIANCE_VALUE_NAME;
|
||||
ValueName.Length = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME) - sizeof(WCHAR);
|
||||
ValueName.MaximumLength = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME);
|
||||
|
||||
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
|
||||
|
||||
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
|
||||
|
||||
FatData.CodePageInvariant = FALSE;
|
||||
|
||||
} else {
|
||||
|
||||
FatData.CodePageInvariant = TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Initialize our global resource and fire up the lookaside lists.
|
||||
//
|
||||
|
||||
ExInitializeResourceLite( &FatData.Resource );
|
||||
|
||||
ExInitializeNPagedLookasideList( &FatIrpContextLookasideList,
|
||||
NULL,
|
||||
NULL,
|
||||
#ifndef __REACTOS__
|
||||
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#else
|
||||
POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#endif
|
||||
sizeof(IRP_CONTEXT),
|
||||
TAG_IRP_CONTEXT,
|
||||
MaxDepth );
|
||||
|
||||
ExInitializeNPagedLookasideList( &FatNonPagedFcbLookasideList,
|
||||
NULL,
|
||||
NULL,
|
||||
#ifndef __REACTOS__
|
||||
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#else
|
||||
POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#endif
|
||||
sizeof(NON_PAGED_FCB),
|
||||
TAG_FCB_NONPAGED,
|
||||
MaxDepth );
|
||||
|
||||
ExInitializeNPagedLookasideList( &FatEResourceLookasideList,
|
||||
NULL,
|
||||
NULL,
|
||||
#ifndef __REACTOS__
|
||||
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#else
|
||||
POOL_RAISE_IF_ALLOCATION_FAILURE,
|
||||
#endif
|
||||
sizeof(ERESOURCE),
|
||||
TAG_ERESOURCE,
|
||||
MaxDepth );
|
||||
|
||||
ExInitializeSListHead( &FatCloseContextSList );
|
||||
ExInitializeFastMutex( &FatCloseQueueMutex );
|
||||
KeInitializeEvent( &FatReserveEvent, SynchronizationEvent, TRUE );
|
||||
|
||||
//
|
||||
// Register the file system with the I/O system
|
||||
//
|
||||
|
||||
IoRegisterFileSystem(FatDiskFileSystemDeviceObject);
|
||||
ObReferenceObject (FatDiskFileSystemDeviceObject);
|
||||
IoRegisterFileSystem(FatCdromFileSystemDeviceObject);
|
||||
ObReferenceObject (FatCdromFileSystemDeviceObject);
|
||||
|
||||
//
|
||||
// Find out if we are running an a FujitsuFMR machine.
|
||||
//
|
||||
|
||||
FatData.FujitsuFMR = FatIsFujitsuFMR();
|
||||
|
||||
#if (NTDDI_VERSION >= NTDDI_WIN8)
|
||||
|
||||
//
|
||||
// Find out global disk accounting state, cache the result
|
||||
//
|
||||
|
||||
FatDiskAccountingEnabled = PsIsDiskCountersEnabled();
|
||||
|
||||
#endif
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
return( STATUS_SUCCESS );
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(DRIVER_UNLOAD)
|
||||
VOID
|
||||
NTAPI
|
||||
FatUnload(
|
||||
#ifndef __REACTOS__
|
||||
_In_ _Unreferenced_parameter_ PDRIVER_OBJECT DriverObject
|
||||
#else
|
||||
_In_ PDRIVER_OBJECT DriverObject
|
||||
#endif
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the unload routine for the filesystem
|
||||
|
||||
Arguments:
|
||||
|
||||
DriverObject - Pointer to driver object created by the system.
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
UNREFERENCED_PARAMETER( DriverObject );
|
||||
|
||||
|
||||
ExDeleteNPagedLookasideList (&FatEResourceLookasideList);
|
||||
ExDeleteNPagedLookasideList (&FatNonPagedFcbLookasideList);
|
||||
ExDeleteNPagedLookasideList (&FatIrpContextLookasideList);
|
||||
ExDeleteResourceLite( &FatData.Resource );
|
||||
IoFreeWorkItem (FatData.FatCloseItem);
|
||||
ObDereferenceObject( FatDiskFileSystemDeviceObject);
|
||||
ObDereferenceObject( FatCdromFileSystemDeviceObject);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Local Support routine
|
||||
//
|
||||
|
||||
NTSTATUS
|
||||
FatGetCompatibilityModeValue (
|
||||
IN PUNICODE_STRING ValueName,
|
||||
IN OUT PULONG Value
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Given a unicode value name this routine will go into the registry
|
||||
location for the Chicago compatibilitymode information and get the
|
||||
value.
|
||||
|
||||
Arguments:
|
||||
|
||||
ValueName - the unicode name for the registry value located in the registry.
|
||||
Value - a pointer to the ULONG for the result.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS
|
||||
|
||||
If STATUS_SUCCESSFUL is returned, the location *Value will be
|
||||
updated with the DWORD value from the registry. If any failing
|
||||
status is returned, this value is untouched.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
HANDLE Handle;
|
||||
NTSTATUS Status;
|
||||
ULONG RequestLength;
|
||||
ULONG ResultLength;
|
||||
UCHAR Buffer[KEY_WORK_AREA];
|
||||
UNICODE_STRING KeyName;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
|
||||
|
||||
KeyName.Buffer = COMPATIBILITY_MODE_KEY_NAME;
|
||||
KeyName.Length = sizeof(COMPATIBILITY_MODE_KEY_NAME) - sizeof(WCHAR);
|
||||
KeyName.MaximumLength = sizeof(COMPATIBILITY_MODE_KEY_NAME);
|
||||
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
&KeyName,
|
||||
OBJ_CASE_INSENSITIVE,
|
||||
NULL,
|
||||
NULL);
|
||||
|
||||
Status = ZwOpenKey(&Handle,
|
||||
KEY_READ,
|
||||
&ObjectAttributes);
|
||||
|
||||
if (!NT_SUCCESS(Status)) {
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
RequestLength = KEY_WORK_AREA;
|
||||
|
||||
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)Buffer;
|
||||
|
||||
while (1) {
|
||||
|
||||
Status = ZwQueryValueKey(Handle,
|
||||
ValueName,
|
||||
KeyValueFullInformation,
|
||||
KeyValueInformation,
|
||||
RequestLength,
|
||||
&ResultLength);
|
||||
|
||||
NT_ASSERT( Status != STATUS_BUFFER_OVERFLOW );
|
||||
|
||||
if (Status == STATUS_BUFFER_OVERFLOW) {
|
||||
|
||||
//
|
||||
// Try to get a buffer big enough.
|
||||
//
|
||||
|
||||
if (KeyValueInformation != (PKEY_VALUE_FULL_INFORMATION)Buffer) {
|
||||
|
||||
ExFreePool(KeyValueInformation);
|
||||
}
|
||||
|
||||
RequestLength += 256;
|
||||
|
||||
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)
|
||||
ExAllocatePoolWithTag(PagedPool,
|
||||
RequestLength,
|
||||
' taF');
|
||||
|
||||
if (!KeyValueInformation) {
|
||||
|
||||
ZwClose(Handle);
|
||||
return STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ZwClose(Handle);
|
||||
|
||||
if (NT_SUCCESS(Status)) {
|
||||
|
||||
if (KeyValueInformation->DataLength != 0) {
|
||||
|
||||
PULONG DataPtr;
|
||||
|
||||
//
|
||||
// Return contents to the caller.
|
||||
//
|
||||
|
||||
DataPtr = (PULONG)
|
||||
((PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
|
||||
*Value = *DataPtr;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// Treat as if no value was found
|
||||
//
|
||||
|
||||
Status = STATUS_OBJECT_NAME_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
|
||||
if (KeyValueInformation != (PKEY_VALUE_FULL_INFORMATION)Buffer) {
|
||||
|
||||
ExFreePool(KeyValueInformation);
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Local Support routine
|
||||
//
|
||||
|
||||
BOOLEAN
|
||||
FatIsFujitsuFMR (
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine tells if is we running on a FujitsuFMR machine.
|
||||
|
||||
Arguments:
|
||||
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE is we are and FALSE otherwise
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
BOOLEAN Result;
|
||||
HANDLE Handle;
|
||||
NTSTATUS Status;
|
||||
ULONG RequestLength;
|
||||
ULONG ResultLength;
|
||||
UCHAR Buffer[KEY_WORK_AREA];
|
||||
UNICODE_STRING KeyName;
|
||||
UNICODE_STRING ValueName;
|
||||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||||
PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
|
||||
|
||||
//
|
||||
// Set default as PC/AT
|
||||
//
|
||||
|
||||
KeyName.Buffer = REGISTRY_HARDWARE_DESCRIPTION_W;
|
||||
KeyName.Length = sizeof(REGISTRY_HARDWARE_DESCRIPTION_W) - sizeof(WCHAR);
|
||||
KeyName.MaximumLength = sizeof(REGISTRY_HARDWARE_DESCRIPTION_W);
|
||||
|
||||
InitializeObjectAttributes(&ObjectAttributes,
|
||||
&KeyName,
|
||||
OBJ_CASE_INSENSITIVE,
|
||||
NULL,
|
||||
NULL);
|
||||
|
||||
Status = ZwOpenKey(&Handle,
|
||||
KEY_READ,
|
||||
&ObjectAttributes);
|
||||
|
||||
if (!NT_SUCCESS(Status)) {
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
ValueName.Buffer = REGISTRY_MACHINE_IDENTIFIER_W;
|
||||
ValueName.Length = sizeof(REGISTRY_MACHINE_IDENTIFIER_W) - sizeof(WCHAR);
|
||||
ValueName.MaximumLength = sizeof(REGISTRY_MACHINE_IDENTIFIER_W);
|
||||
|
||||
RequestLength = KEY_WORK_AREA;
|
||||
|
||||
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)Buffer;
|
||||
|
||||
while (1) {
|
||||
|
||||
Status = ZwQueryValueKey(Handle,
|
||||
&ValueName,
|
||||
KeyValueFullInformation,
|
||||
KeyValueInformation,
|
||||
RequestLength,
|
||||
&ResultLength);
|
||||
|
||||
// NT_ASSERT( Status != STATUS_BUFFER_OVERFLOW );
|
||||
|
||||
if (Status == STATUS_BUFFER_OVERFLOW) {
|
||||
|
||||
//
|
||||
// Try to get a buffer big enough.
|
||||
//
|
||||
|
||||
if (KeyValueInformation != (PKEY_VALUE_FULL_INFORMATION)Buffer) {
|
||||
|
||||
ExFreePool(KeyValueInformation);
|
||||
}
|
||||
|
||||
RequestLength += 256;
|
||||
|
||||
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)
|
||||
ExAllocatePoolWithTag(PagedPool, RequestLength, ' taF');
|
||||
|
||||
if (!KeyValueInformation) {
|
||||
|
||||
ZwClose(Handle);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ZwClose(Handle);
|
||||
|
||||
if (NT_SUCCESS(Status) &&
|
||||
(KeyValueInformation->DataLength >= sizeof(FUJITSU_FMR_NAME_W)) &&
|
||||
(RtlCompareMemory((PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset,
|
||||
FUJITSU_FMR_NAME_W,
|
||||
sizeof(FUJITSU_FMR_NAME_W) - sizeof(WCHAR)) ==
|
||||
sizeof(FUJITSU_FMR_NAME_W) - sizeof(WCHAR))) {
|
||||
|
||||
Result = TRUE;
|
||||
|
||||
} else {
|
||||
|
||||
Result = FALSE;
|
||||
}
|
||||
|
||||
if (KeyValueInformation != (PKEY_VALUE_FULL_INFORMATION)Buffer) {
|
||||
|
||||
ExFreePool(KeyValueInformation);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
3098
drivers/filesystems/fastfat_new/fatprocs.h
Normal file
3098
drivers/filesystems/fastfat_new/fatprocs.h
Normal file
File diff suppressed because it is too large
Load diff
1
drivers/filesystems/fastfat_new/fatprocssrc.c
Normal file
1
drivers/filesystems/fastfat_new/fatprocssrc.c
Normal file
|
|
@ -0,0 +1 @@
|
|||
#include "fatprocs.h"
|
||||
1786
drivers/filesystems/fastfat_new/fatstruc.h
Normal file
1786
drivers/filesystems/fastfat_new/fatstruc.h
Normal file
File diff suppressed because it is too large
Load diff
5202
drivers/filesystems/fastfat_new/fileinfo.c
Normal file
5202
drivers/filesystems/fastfat_new/fileinfo.c
Normal file
File diff suppressed because it is too large
Load diff
591
drivers/filesystems/fastfat_new/filobsup.c
Normal file
591
drivers/filesystems/fastfat_new/filobsup.c
Normal file
|
|
@ -0,0 +1,591 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
FilObSup.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Fat File object support routines.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The Bug check file id for this module
|
||||
//
|
||||
|
||||
#define BugCheckFileId (FAT_BUG_CHECK_FILOBSUP)
|
||||
|
||||
//
|
||||
// The debug trace level
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_FILOBSUP)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatForceCacheMiss)
|
||||
#pragma alloc_text(PAGE, FatPurgeReferencedFileObjects)
|
||||
#pragma alloc_text(PAGE, FatSetFileObject)
|
||||
#pragma alloc_text(PAGE, FatDecodeFileObject)
|
||||
#endif
|
||||
|
||||
|
||||
VOID
|
||||
FatSetFileObject (
|
||||
IN PFILE_OBJECT FileObject OPTIONAL,
|
||||
IN TYPE_OF_OPEN TypeOfOpen,
|
||||
IN PVOID VcbOrFcbOrDcb,
|
||||
IN PCCB Ccb OPTIONAL
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine sets the file system pointers within the file object
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies a pointer to the file object being modified, and
|
||||
can optionally be null.
|
||||
|
||||
TypeOfOpen - Supplies the type of open denoted by the file object.
|
||||
This is only used by this procedure for sanity checking.
|
||||
|
||||
VcbOrFcbOrDcb - Supplies a pointer to either a vcb, fcb, or dcb
|
||||
|
||||
Ccb - Optionally supplies a pointer to a ccb
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatSetFileObject, FileObject = %p\n", FileObject );
|
||||
|
||||
NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
|
||||
|
||||
|
||||
NT_ASSERT(((TypeOfOpen == UnopenedFileObject))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == UserFileOpen) &&
|
||||
(NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
|
||||
(Ccb != NULL))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == EaFile) &&
|
||||
(NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
|
||||
(Ccb == NULL))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == UserDirectoryOpen) &&
|
||||
((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
|
||||
(Ccb != NULL))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == UserVolumeOpen) &&
|
||||
(NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
|
||||
(Ccb != NULL))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == VirtualVolumeFile) &&
|
||||
(NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
|
||||
(Ccb == NULL))
|
||||
|
||||
||
|
||||
|
||||
((TypeOfOpen == DirectoryFile) &&
|
||||
((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
|
||||
(Ccb == NULL))
|
||||
);
|
||||
|
||||
|
||||
UNREFERENCED_PARAMETER( TypeOfOpen );
|
||||
|
||||
//
|
||||
// If we were given an Fcb, Dcb, or Vcb, we have some processing to do.
|
||||
//
|
||||
|
||||
NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
|
||||
|
||||
if ( VcbOrFcbOrDcb != NULL ) {
|
||||
|
||||
//
|
||||
// Set the Vpb field in the file object, and if we were given an
|
||||
// Fcb or Dcb move the field over to point to the nonpaged Fcb/Dcb
|
||||
//
|
||||
|
||||
if (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) {
|
||||
|
||||
FileObject->Vpb = ((PVCB)VcbOrFcbOrDcb)->Vpb;
|
||||
|
||||
} else {
|
||||
|
||||
FileObject->Vpb = ((PFCB)VcbOrFcbOrDcb)->Vcb->Vpb;
|
||||
|
||||
//
|
||||
// If this is a temporary file, note it in the FcbState
|
||||
//
|
||||
|
||||
if (FlagOn(((PFCB)VcbOrFcbOrDcb)->FcbState, FCB_STATE_TEMPORARY)) {
|
||||
|
||||
SetFlag(FileObject->Flags, FO_TEMPORARY_FILE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
|
||||
|
||||
//
|
||||
// Now set the fscontext fields of the file object
|
||||
//
|
||||
|
||||
if (ARGUMENT_PRESENT( FileObject )) {
|
||||
|
||||
FileObject->FsContext = VcbOrFcbOrDcb;
|
||||
FileObject->FsContext2 = Ccb;
|
||||
}
|
||||
|
||||
NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatSetFileObject -> VOID\n", 0);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
TYPE_OF_OPEN
|
||||
FatDecodeFileObject (
|
||||
_In_ PFILE_OBJECT FileObject,
|
||||
_Outptr_ PVCB *Vcb,
|
||||
_Outptr_ PFCB *FcbOrDcb,
|
||||
_Outptr_ PCCB *Ccb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This procedure takes a pointer to a file object, that has already been
|
||||
opened by the Fat file system and figures out what really is opened.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies the file object pointer being interrogated
|
||||
|
||||
Vcb - Receives a pointer to the Vcb for the file object.
|
||||
|
||||
FcbOrDcb - Receives a pointer to the Fcb/Dcb for the file object, if
|
||||
one exists.
|
||||
|
||||
Ccb - Receives a pointer to the Ccb for the file object, if one exists.
|
||||
|
||||
Return Value:
|
||||
|
||||
TYPE_OF_OPEN - returns the type of file denoted by the input file object.
|
||||
|
||||
UserFileOpen - The FO represents a user's opened data file.
|
||||
Ccb, FcbOrDcb, and Vcb are set. FcbOrDcb points to an Fcb.
|
||||
|
||||
UserDirectoryOpen - The FO represents a user's opened directory.
|
||||
Ccb, FcbOrDcb, and Vcb are set. FcbOrDcb points to a Dcb/RootDcb
|
||||
|
||||
UserVolumeOpen - The FO represents a user's opened volume.
|
||||
Ccb and Vcb are set. FcbOrDcb is null.
|
||||
|
||||
VirtualVolumeFile - The FO represents the special virtual volume file.
|
||||
Vcb is set, and Ccb and FcbOrDcb are null.
|
||||
|
||||
DirectoryFile - The FO represents a special directory file.
|
||||
Vcb and FcbOrDcb are set. Ccb is null. FcbOrDcb points to a
|
||||
Dcb/RootDcb.
|
||||
|
||||
EaFile - The FO represents an Ea Io stream file.
|
||||
FcbOrDcb, and Vcb are set. FcbOrDcb points to an Fcb, and Ccb is
|
||||
null.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TYPE_OF_OPEN TypeOfOpen;
|
||||
PVOID FsContext;
|
||||
PVOID FsContext2;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatDecodeFileObject, FileObject = %p\n", FileObject);
|
||||
|
||||
//
|
||||
// Reference the fs context fields of the file object, and zero out
|
||||
// the out pointer parameters.
|
||||
//
|
||||
|
||||
FsContext = FileObject->FsContext;
|
||||
FsContext2 = FileObject->FsContext2;
|
||||
|
||||
//
|
||||
// Special case the situation where FsContext is null
|
||||
//
|
||||
|
||||
if (FsContext == NULL) {
|
||||
|
||||
*Ccb = NULL;
|
||||
*FcbOrDcb = NULL;
|
||||
*Vcb = NULL;
|
||||
|
||||
TypeOfOpen = UnopenedFileObject;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// Now we can case on the node type code of the fscontext pointer
|
||||
// and set the appropriate out pointers
|
||||
//
|
||||
|
||||
switch (NodeType(FsContext)) {
|
||||
|
||||
case FAT_NTC_VCB:
|
||||
|
||||
*Ccb = FsContext2;
|
||||
*FcbOrDcb = NULL;
|
||||
*Vcb = FsContext;
|
||||
|
||||
TypeOfOpen = ( *Ccb == NULL ? VirtualVolumeFile : UserVolumeOpen );
|
||||
|
||||
break;
|
||||
|
||||
case FAT_NTC_ROOT_DCB:
|
||||
case FAT_NTC_DCB:
|
||||
|
||||
*Ccb = FsContext2;
|
||||
*FcbOrDcb = FsContext;
|
||||
*Vcb = (*FcbOrDcb)->Vcb;
|
||||
|
||||
TypeOfOpen = ( *Ccb == NULL ? DirectoryFile : UserDirectoryOpen );
|
||||
|
||||
DebugTrace(0, Dbg, "Referencing directory: %wZ\n", &(*FcbOrDcb)->FullFileName);
|
||||
|
||||
break;
|
||||
|
||||
case FAT_NTC_FCB:
|
||||
|
||||
*Ccb = FsContext2;
|
||||
*FcbOrDcb = FsContext;
|
||||
*Vcb = (*FcbOrDcb)->Vcb;
|
||||
|
||||
if (*Ccb != NULL ) {
|
||||
|
||||
TypeOfOpen = UserFileOpen;
|
||||
DebugTrace(0, Dbg, "Referencing file: %wZ\n", &(*FcbOrDcb)->FullFileName);
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// No Ccb means this is a special open.
|
||||
//
|
||||
|
||||
|
||||
if ( *FcbOrDcb == (*Vcb)->EaFcb ) {
|
||||
|
||||
TypeOfOpen = EaFile;
|
||||
DebugTrace(0, Dbg, "Referencing EA file: %wZ\n", &(*FcbOrDcb)->FullFileName);
|
||||
|
||||
} else {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast(suppress:28159, "things are seriously wrong if we get here")
|
||||
#endif
|
||||
FatBugCheck( NodeType(FsContext), 0, 0 );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
|
||||
#endif
|
||||
FatBugCheck( NodeType(FsContext), 0, 0 );
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// and return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(0, Dbg, "FatDecodeFileObject -> VCB(%p)\n", *Vcb);
|
||||
DebugTrace(0, Dbg, "FatDecodeFileObject -> FCB(%p)\n", *FcbOrDcb);
|
||||
DebugTrace(0, Dbg, "FatDecodeFileObject -> CCB(%p)\n", *Ccb);
|
||||
DebugTrace(-1, Dbg, "FatDecodeFileObject -> TypeOfOpen = %08lx\n", TypeOfOpen);
|
||||
|
||||
return TypeOfOpen;
|
||||
}
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
VOID
|
||||
FatPurgeReferencedFileObjects (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb,
|
||||
IN FAT_FLUSH_TYPE FlushType
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine non-recursively walks from the given FcbOrDcb and trys
|
||||
to force Cc or Mm to close any sections it may be holding on to.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - Supplies a pointer to either an fcb or a dcb
|
||||
|
||||
FlushType - Specifies the kind of flushing to perform
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PFCB OriginalFcb = Fcb;
|
||||
PFCB NextFcb;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatPurgeReferencedFileObjects, Fcb = %p\n", Fcb );
|
||||
|
||||
NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||||
|
||||
//
|
||||
// First, if we have a delayed close, force it closed.
|
||||
//
|
||||
|
||||
FatFspClose(Fcb->Vcb);
|
||||
|
||||
//
|
||||
// Walk the directory tree forcing sections closed.
|
||||
//
|
||||
// Note that it very important to get the next node to visit before
|
||||
// acting on the current node. This is because acting on a node may
|
||||
// make it, and an arbitrary number of direct ancestors, vanish.
|
||||
// Since we never visit ancestors in our top-down enumeration scheme, we
|
||||
// can safely continue the enumeration even when the tree is vanishing
|
||||
// beneath us. This is way cool.
|
||||
//
|
||||
|
||||
while ( Fcb != NULL ) {
|
||||
|
||||
NextFcb = FatGetNextFcbTopDown(IrpContext, Fcb, OriginalFcb);
|
||||
|
||||
//
|
||||
// Check for the EA file fcb
|
||||
//
|
||||
|
||||
if ( !FlagOn(Fcb->DirentFatFlags, FAT_DIRENT_ATTR_VOLUME_ID) ) {
|
||||
|
||||
FatForceCacheMiss( IrpContext, Fcb, FlushType );
|
||||
}
|
||||
|
||||
Fcb = NextFcb;
|
||||
}
|
||||
|
||||
DebugTrace(-1, Dbg, "FatPurgeReferencedFileObjects (VOID)\n", 0 );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
VOID
|
||||
FatForceCacheMiss (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb,
|
||||
IN FAT_FLUSH_TYPE FlushType
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The following routine asks either Cc or Mm to get rid of any cached
|
||||
pages on a file. Note that this will fail if a user has mapped a file.
|
||||
|
||||
If there is a shared cache map, purge the cache section. Otherwise
|
||||
we have to go and ask Mm to blow away the section.
|
||||
|
||||
NOTE: This caller MUST own the Vcb exclusive.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - Supplies a pointer to an fcb
|
||||
|
||||
FlushType - Specifies the kind of flushing to perform
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PVCB Vcb;
|
||||
BOOLEAN ChildrenAcquired = FALSE;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// If we can't wait, bail.
|
||||
//
|
||||
|
||||
NT_ASSERT( FatVcbAcquiredExclusive( IrpContext, Fcb->Vcb ) ||
|
||||
FlagOn( Fcb->Vcb->VcbState, VCB_STATE_FLAG_LOCKED ) );
|
||||
|
||||
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
|
||||
|
||||
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
|
||||
}
|
||||
|
||||
//
|
||||
// If we are purging a directory file object, we must acquire all the
|
||||
// FCBs exclusive so that the parent directory is not being pinned.
|
||||
// Careful, we can collide with something acquiring up the tree like
|
||||
// an unpin repinned flush (FsRtlAcquireFileForCcFlush ...) of a parent
|
||||
// dir on extending writethrough of a child file (oops). So get things
|
||||
// going up the tree, not down.
|
||||
//
|
||||
|
||||
if ((NodeType(Fcb) != FAT_NTC_FCB) &&
|
||||
!IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue)) {
|
||||
|
||||
PLIST_ENTRY Links;
|
||||
PFCB TempFcb;
|
||||
|
||||
ChildrenAcquired = TRUE;
|
||||
|
||||
for (Links = Fcb->Specific.Dcb.ParentDcbQueue.Flink;
|
||||
Links != &Fcb->Specific.Dcb.ParentDcbQueue;
|
||||
Links = Links->Flink) {
|
||||
|
||||
TempFcb = CONTAINING_RECORD( Links, FCB, ParentDcbLinks );
|
||||
|
||||
(VOID)FatAcquireExclusiveFcb( IrpContext, TempFcb );
|
||||
}
|
||||
}
|
||||
|
||||
(VOID)FatAcquireExclusiveFcb( IrpContext, Fcb );
|
||||
|
||||
//
|
||||
// We use this flag to indicate to a close beneath us that
|
||||
// the Fcb resource should be freed before deleting the Fcb.
|
||||
//
|
||||
|
||||
Vcb = Fcb->Vcb;
|
||||
|
||||
SetFlag( Fcb->FcbState, FCB_STATE_FORCE_MISS_IN_PROGRESS );
|
||||
|
||||
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
BOOLEAN DataSectionExists;
|
||||
BOOLEAN ImageSectionExists;
|
||||
|
||||
PSECTION_OBJECT_POINTERS Section;
|
||||
|
||||
if ( FlushType ) {
|
||||
|
||||
(VOID)FatFlushFile( IrpContext, Fcb, FlushType );
|
||||
}
|
||||
|
||||
//
|
||||
// The Flush may have made the Fcb go away
|
||||
//
|
||||
|
||||
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB)) {
|
||||
|
||||
Section = &Fcb->NonPaged->SectionObjectPointers;
|
||||
|
||||
DataSectionExists = (BOOLEAN)(Section->DataSectionObject != NULL);
|
||||
ImageSectionExists = (BOOLEAN)(Section->ImageSectionObject != NULL);
|
||||
|
||||
//
|
||||
// Note, it is critical to do the Image section first as the
|
||||
// purge of the data section may cause the image section to go
|
||||
// away, but the opposite is not true.
|
||||
//
|
||||
|
||||
if (ImageSectionExists) {
|
||||
|
||||
(VOID)MmFlushImageSection( Section, MmFlushForWrite );
|
||||
}
|
||||
|
||||
if (DataSectionExists) {
|
||||
|
||||
CcPurgeCacheSection( Section, NULL, 0, FALSE );
|
||||
}
|
||||
}
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
//
|
||||
// If we purging a directory file object, release all the Fcb
|
||||
// resources that we acquired above. The Dcb cannot have vanished
|
||||
// if there were Fcbs underneath it, and the Fcbs couldn't have gone
|
||||
// away since I own the Vcb.
|
||||
//
|
||||
|
||||
if (ChildrenAcquired) {
|
||||
|
||||
PLIST_ENTRY Links;
|
||||
PFCB TempFcb;
|
||||
|
||||
for (Links = Fcb->Specific.Dcb.ParentDcbQueue.Flink;
|
||||
Links != &Fcb->Specific.Dcb.ParentDcbQueue;
|
||||
Links = Links->Flink) {
|
||||
|
||||
TempFcb = CONTAINING_RECORD( Links, FCB, ParentDcbLinks );
|
||||
|
||||
FatReleaseFcb( IrpContext, TempFcb );
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Since we have the Vcb exclusive we know that if any closes
|
||||
// come in it is because the CcPurgeCacheSection caused the
|
||||
// Fcb to go away. Also in close, the Fcb was released
|
||||
// before being freed.
|
||||
//
|
||||
|
||||
if ( !FlagOn(Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB) ) {
|
||||
|
||||
ClearFlag( Fcb->FcbState, FCB_STATE_FORCE_MISS_IN_PROGRESS );
|
||||
|
||||
FatReleaseFcb( (IRPCONTEXT), Fcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
}
|
||||
|
||||
|
||||
1371
drivers/filesystems/fastfat_new/flush.c
Normal file
1371
drivers/filesystems/fastfat_new/flush.c
Normal file
File diff suppressed because it is too large
Load diff
8198
drivers/filesystems/fastfat_new/fsctrl.c
Normal file
8198
drivers/filesystems/fastfat_new/fsctrl.c
Normal file
File diff suppressed because it is too large
Load diff
485
drivers/filesystems/fastfat_new/fspdisp.c
Normal file
485
drivers/filesystems/fastfat_new/fspdisp.c
Normal file
|
|
@ -0,0 +1,485 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
FspDisp.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the main dispatch procedure/thread for the Fat
|
||||
Fsp
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// Internal support routine, spinlock wrapper.
|
||||
//
|
||||
|
||||
PVOID
|
||||
FatRemoveOverflowEntry (
|
||||
IN PVOLUME_DEVICE_OBJECT VolDo
|
||||
);
|
||||
|
||||
//
|
||||
// Define our local debug trace level
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_FSP_DISPATCHER)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatFspDispatch)
|
||||
#endif
|
||||
|
||||
|
||||
VOID
|
||||
NTAPI
|
||||
FatFspDispatch (
|
||||
_In_ PVOID Context
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the main FSP thread routine that is executed to receive
|
||||
and dispatch IRP requests. Each FSP thread begins its execution here.
|
||||
There is one thread created at system initialization time and subsequent
|
||||
threads created as needed.
|
||||
|
||||
Arguments:
|
||||
|
||||
|
||||
Context - Supplies the thread id.
|
||||
|
||||
Return Value:
|
||||
|
||||
None - This routine never exits
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status = STATUS_SUCCESS;
|
||||
|
||||
|
||||
PIRP Irp;
|
||||
PIRP_CONTEXT IrpContext;
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
BOOLEAN VcbDeleted;
|
||||
BOOLEAN ExceptionCompletedIrp = FALSE;
|
||||
|
||||
PVOLUME_DEVICE_OBJECT VolDo;
|
||||
|
||||
UCHAR MajorFunction = 0;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
IrpContext = (PIRP_CONTEXT)Context;
|
||||
|
||||
Irp = IrpContext->OriginatingIrp;
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
//
|
||||
// Now because we are the Fsp we will force the IrpContext to
|
||||
// indicate true on Wait.
|
||||
//
|
||||
|
||||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
|
||||
|
||||
//
|
||||
// If this request has an associated volume device object, remember it.
|
||||
//
|
||||
|
||||
if ( IrpSp->FileObject != NULL ) {
|
||||
|
||||
VolDo = CONTAINING_RECORD( IrpSp->DeviceObject,
|
||||
VOLUME_DEVICE_OBJECT,
|
||||
DeviceObject );
|
||||
} else {
|
||||
|
||||
VolDo = NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Now case on the function code. For each major function code,
|
||||
// either call the appropriate FSP routine or case on the minor
|
||||
// function and then call the FSP routine. The FSP routine that
|
||||
// we call is responsible for completing the IRP, and not us.
|
||||
// That way the routine can complete the IRP and then continue
|
||||
// post processing as required. For example, a read can be
|
||||
// satisfied right away and then read can be done.
|
||||
//
|
||||
// We'll do all of the work within an exception handler that
|
||||
// will be invoked if ever some underlying operation gets into
|
||||
// trouble (e.g., if FatReadSectorsSync has trouble).
|
||||
//
|
||||
|
||||
while ( TRUE ) {
|
||||
|
||||
ExceptionCompletedIrp = FALSE;
|
||||
|
||||
DebugTrace(0, Dbg, "FatFspDispatch: Irp = %p\n", Irp);
|
||||
|
||||
//
|
||||
// If this Irp was top level, note it in our thread local storage.
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
if ( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) ) {
|
||||
|
||||
IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );
|
||||
|
||||
} else {
|
||||
|
||||
IoSetTopLevelIrp( Irp );
|
||||
}
|
||||
|
||||
MajorFunction = IrpContext->MajorFunction;
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
switch ( MajorFunction ) {
|
||||
|
||||
//
|
||||
// For Create Operation,
|
||||
//
|
||||
|
||||
case IRP_MJ_CREATE:
|
||||
|
||||
Status = FatCommonCreate( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For close operations. We do a little kludge here in case
|
||||
// this close causes a volume to go away. It will NULL the
|
||||
// VolDo local variable so that we will not try to look at
|
||||
// the overflow queue.
|
||||
//
|
||||
|
||||
case IRP_MJ_CLOSE:
|
||||
|
||||
{
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
TYPE_OF_OPEN TypeOfOpen;
|
||||
|
||||
//
|
||||
// Extract and decode the file object
|
||||
//
|
||||
|
||||
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
|
||||
|
||||
//
|
||||
// Do the close. We have a slightly different format
|
||||
// for this call because of the async closes.
|
||||
//
|
||||
|
||||
Status = FatCommonClose( Vcb,
|
||||
Fcb,
|
||||
Ccb,
|
||||
TypeOfOpen,
|
||||
TRUE,
|
||||
TRUE,
|
||||
&VcbDeleted );
|
||||
|
||||
//
|
||||
// If the VCB was deleted, do not try to access it later.
|
||||
//
|
||||
|
||||
if (VcbDeleted) {
|
||||
|
||||
VolDo = NULL;
|
||||
}
|
||||
|
||||
NT_ASSERT(Status == STATUS_SUCCESS);
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
//
|
||||
// For read operations
|
||||
//
|
||||
|
||||
case IRP_MJ_READ:
|
||||
|
||||
(VOID) FatCommonRead( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For write operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_WRITE:
|
||||
|
||||
(VOID) FatCommonWrite( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Query Information operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_QUERY_INFORMATION:
|
||||
|
||||
(VOID) FatCommonQueryInformation( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Set Information operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_SET_INFORMATION:
|
||||
|
||||
(VOID) FatCommonSetInformation( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Query EA operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_QUERY_EA:
|
||||
|
||||
(VOID) FatCommonQueryEa( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Set EA operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_SET_EA:
|
||||
|
||||
(VOID) FatCommonSetEa( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Flush buffers operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_FLUSH_BUFFERS:
|
||||
|
||||
(VOID) FatCommonFlushBuffers( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Query Volume Information operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_QUERY_VOLUME_INFORMATION:
|
||||
|
||||
(VOID) FatCommonQueryVolumeInfo( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Set Volume Information operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_SET_VOLUME_INFORMATION:
|
||||
|
||||
(VOID) FatCommonSetVolumeInfo( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For File Cleanup operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_CLEANUP:
|
||||
|
||||
(VOID) FatCommonCleanup( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Directory Control operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_DIRECTORY_CONTROL:
|
||||
|
||||
(VOID) FatCommonDirectoryControl( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For File System Control operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_FILE_SYSTEM_CONTROL:
|
||||
|
||||
(VOID) FatCommonFileSystemControl( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Lock Control operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_LOCK_CONTROL:
|
||||
|
||||
(VOID) FatCommonLockControl( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For Device Control operations,
|
||||
//
|
||||
|
||||
case IRP_MJ_DEVICE_CONTROL:
|
||||
|
||||
(VOID) FatCommonDeviceControl( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For the Shutdown operation,
|
||||
//
|
||||
|
||||
case IRP_MJ_SHUTDOWN:
|
||||
|
||||
(VOID) FatCommonShutdown( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For plug and play operations.
|
||||
//
|
||||
|
||||
case IRP_MJ_PNP:
|
||||
|
||||
//
|
||||
// I don't believe this should ever occur, but allow for the unexpected.
|
||||
//
|
||||
|
||||
(VOID) FatCommonPnp( IrpContext, Irp );
|
||||
break;
|
||||
|
||||
//
|
||||
// For any other major operations, return an invalid
|
||||
// request.
|
||||
//
|
||||
|
||||
default:
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
} _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
|
||||
|
||||
//
|
||||
// We had some trouble trying to perform the requested
|
||||
// operation, so we'll abort the I/O request with
|
||||
// the error status that we get back from the
|
||||
// execption code.
|
||||
//
|
||||
|
||||
(VOID) FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
|
||||
ExceptionCompletedIrp = TRUE;
|
||||
} _SEH2_END;
|
||||
|
||||
IoSetTopLevelIrp( NULL );
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
|
||||
if (MajorFunction == IRP_MJ_CREATE && !ExceptionCompletedIrp && Status != STATUS_PENDING) {
|
||||
|
||||
//
|
||||
// Creates are completed here. IrpContext is also freed here.
|
||||
//
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
}
|
||||
|
||||
//
|
||||
// If there are any entries on this volume's overflow queue, service
|
||||
// them.
|
||||
//
|
||||
|
||||
if ( VolDo != NULL ) {
|
||||
|
||||
PVOID Entry;
|
||||
|
||||
//
|
||||
// We have a volume device object so see if there is any work
|
||||
// left to do in its overflow queue.
|
||||
//
|
||||
|
||||
Entry = FatRemoveOverflowEntry( VolDo );
|
||||
|
||||
//
|
||||
// There wasn't an entry, break out of the loop and return to
|
||||
// the Ex Worker thread.
|
||||
//
|
||||
|
||||
if ( Entry == NULL ) {
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
//
|
||||
// Extract the IrpContext, Irp, and IrpSp, and loop.
|
||||
//
|
||||
|
||||
IrpContext = CONTAINING_RECORD( Entry,
|
||||
IRP_CONTEXT,
|
||||
WorkQueueItem.List );
|
||||
|
||||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
|
||||
|
||||
Irp = IrpContext->OriginatingIrp;
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
continue;
|
||||
|
||||
} else {
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Internal support routine, spinlock wrapper.
|
||||
//
|
||||
|
||||
PVOID
|
||||
FatRemoveOverflowEntry (
|
||||
IN PVOLUME_DEVICE_OBJECT VolDo
|
||||
)
|
||||
{
|
||||
PVOID Entry;
|
||||
KIRQL SavedIrql;
|
||||
|
||||
KeAcquireSpinLock( &VolDo->OverflowQueueSpinLock, &SavedIrql );
|
||||
|
||||
if (VolDo->OverflowQueueCount > 0) {
|
||||
|
||||
//
|
||||
// There is overflow work to do in this volume so we'll
|
||||
// decrement the Overflow count, dequeue the IRP, and release
|
||||
// the Event
|
||||
//
|
||||
|
||||
VolDo->OverflowQueueCount -= 1;
|
||||
|
||||
Entry = RemoveHeadList( &VolDo->OverflowQueue );
|
||||
|
||||
} else {
|
||||
|
||||
VolDo->PostedRequestCount -= 1;
|
||||
|
||||
Entry = NULL;
|
||||
}
|
||||
|
||||
KeReleaseSpinLock( &VolDo->OverflowQueueSpinLock, SavedIrql );
|
||||
|
||||
return Entry;
|
||||
}
|
||||
|
||||
|
||||
56
drivers/filesystems/fastfat_new/lfn.h
Normal file
56
drivers/filesystems/fastfat_new/lfn.h
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
Lfn.h
|
||||
|
||||
Abstract:
|
||||
|
||||
This module defines the on-disk structure of long file names on FAT.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _LFN_
|
||||
#define _LFN_
|
||||
|
||||
//
|
||||
// This strucure defines the on disk format on long file name dirents.
|
||||
//
|
||||
|
||||
typedef struct _PACKED_LFN_DIRENT {
|
||||
UCHAR Ordinal; // offset = 0
|
||||
UCHAR Name1[10]; // offset = 1 (Really 5 chars, but not WCHAR aligned)
|
||||
UCHAR Attributes; // offset = 11
|
||||
UCHAR Type; // offset = 12
|
||||
UCHAR Checksum; // offset = 13
|
||||
WCHAR Name2[6]; // offset = 14
|
||||
USHORT MustBeZero; // offset = 26
|
||||
WCHAR Name3[2]; // offset = 28
|
||||
} PACKED_LFN_DIRENT; // sizeof = 32
|
||||
typedef PACKED_LFN_DIRENT *PPACKED_LFN_DIRENT;
|
||||
|
||||
#define FAT_LAST_LONG_ENTRY 0x40 // Ordinal field
|
||||
#define FAT_LONG_NAME_COMP 0x0 // Type field
|
||||
|
||||
//
|
||||
// A packed lfn dirent is already quadword aligned so simply declare a
|
||||
// lfn dirent as a packed lfn dirent.
|
||||
//
|
||||
|
||||
typedef PACKED_LFN_DIRENT LFN_DIRENT;
|
||||
typedef LFN_DIRENT *PLFN_DIRENT;
|
||||
|
||||
//
|
||||
// This is the largest size buffer we would ever need to read an Lfn
|
||||
//
|
||||
|
||||
#define MAX_LFN_CHARACTERS 260
|
||||
#define MAX_LFN_DIRENTS 20
|
||||
|
||||
#define FAT_LFN_DIRENTS_NEEDED(NAME) (((NAME)->Length/sizeof(WCHAR) + 12)/13)
|
||||
|
||||
#endif // _LFN_
|
||||
|
||||
770
drivers/filesystems/fastfat_new/lockctrl.c
Normal file
770
drivers/filesystems/fastfat_new/lockctrl.c
Normal file
|
|
@ -0,0 +1,770 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
LockCtrl.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Lock Control routines for Fat called
|
||||
by the dispatch driver.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The local debug trace level
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_LOCKCTRL)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatCommonLockControl)
|
||||
#pragma alloc_text(PAGE, FatFastLock)
|
||||
#pragma alloc_text(PAGE, FatFastUnlockAll)
|
||||
#pragma alloc_text(PAGE, FatFastUnlockAllByKey)
|
||||
#pragma alloc_text(PAGE, FatFastUnlockSingle)
|
||||
#pragma alloc_text(PAGE, FatFsdLockControl)
|
||||
#endif
|
||||
|
||||
|
||||
_Function_class_(IRP_MJ_LOCK_CONTROL)
|
||||
_Function_class_(DRIVER_DISPATCH)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatFsdLockControl (
|
||||
_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
||||
_Inout_ PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine implements the FSD part of Lock control operations
|
||||
|
||||
Arguments:
|
||||
|
||||
VolumeDeviceObject - Supplies the volume device object where the
|
||||
file exists
|
||||
|
||||
Irp - Supplies the Irp being processed
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The FSD status for the IRP
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
PIRP_CONTEXT IrpContext = NULL;
|
||||
|
||||
BOOLEAN TopLevel;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFsdLockControl\n", 0);
|
||||
|
||||
//
|
||||
// Call the common Lock Control routine, with blocking allowed if
|
||||
// synchronous
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
TopLevel = FatIsIrpTopLevel( Irp );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
|
||||
|
||||
Status = FatCommonLockControl( IrpContext, Irp );
|
||||
|
||||
} _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
|
||||
|
||||
//
|
||||
// We had some trouble trying to perform the requested
|
||||
// operation, so we'll abort the I/O request with
|
||||
// the error status that we get back from the
|
||||
// execption code
|
||||
//
|
||||
|
||||
Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
|
||||
} _SEH2_END;
|
||||
|
||||
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFsdLockControl -> %08lx\n", Status);
|
||||
|
||||
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(FAST_IO_LOCK)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatFastLock (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
IN PLARGE_INTEGER FileOffset,
|
||||
IN PLARGE_INTEGER Length,
|
||||
PEPROCESS ProcessId,
|
||||
ULONG Key,
|
||||
BOOLEAN FailImmediately,
|
||||
BOOLEAN ExclusiveLock,
|
||||
OUT PIO_STATUS_BLOCK IoStatus,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is a call back routine for doing the fast lock call.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies the file object used in this operation
|
||||
|
||||
FileOffset - Supplies the file offset used in this operation
|
||||
|
||||
Length - Supplies the length used in this operation
|
||||
|
||||
ProcessId - Supplies the process ID used in this operation
|
||||
|
||||
Key - Supplies the key used in this operation
|
||||
|
||||
FailImmediately - Indicates if the request should fail immediately
|
||||
if the lock cannot be granted.
|
||||
|
||||
ExclusiveLock - Indicates if this is a request for an exclusive or
|
||||
shared lock
|
||||
|
||||
IoStatus - Receives the Status if this operation is successful
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if this operation completed and FALSE if caller
|
||||
needs to take the long route.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
BOOLEAN Results = FALSE;
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFastLock\n", 0);
|
||||
|
||||
//
|
||||
// Decode the type of file object we're being asked to process and make
|
||||
// sure it is only a user file open.
|
||||
//
|
||||
|
||||
if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
|
||||
|
||||
IoStatus->Status = STATUS_INVALID_PARAMETER;
|
||||
IoStatus->Information = 0;
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastLock -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Acquire shared access to the Fcb
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We check whether we can proceed
|
||||
// based on the state of the file oplocks.
|
||||
//
|
||||
|
||||
if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
|
||||
|
||||
try_return( Results = FALSE );
|
||||
}
|
||||
|
||||
//
|
||||
// Now call the FsRtl routine to do the actual processing of the
|
||||
// Lock request
|
||||
//
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress:28159, "prefast indicates this API is obsolete but it is ok for fastfat to continue using it" )
|
||||
#endif
|
||||
Results = FsRtlFastLock( &Fcb->Specific.Fcb.FileLock,
|
||||
FileObject,
|
||||
FileOffset,
|
||||
Length,
|
||||
ProcessId,
|
||||
Key,
|
||||
FailImmediately,
|
||||
ExclusiveLock,
|
||||
IoStatus,
|
||||
NULL,
|
||||
FALSE );
|
||||
|
||||
if (Results) {
|
||||
|
||||
//
|
||||
// Set the flag indicating if Fast I/O is possible
|
||||
//
|
||||
|
||||
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
||||
}
|
||||
|
||||
try_exit: NOTHING;
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
DebugUnwind( FatFastLock );
|
||||
|
||||
//
|
||||
// Release the Fcb, and return to our caller
|
||||
//
|
||||
|
||||
ExReleaseResourceLite( Fcb->Header.Resource );
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastLock -> %08lx\n", Results);
|
||||
} _SEH2_END;
|
||||
|
||||
return Results;
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(FAST_IO_UNLOCK_SINGLE)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatFastUnlockSingle (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
IN PLARGE_INTEGER FileOffset,
|
||||
IN PLARGE_INTEGER Length,
|
||||
PEPROCESS ProcessId,
|
||||
ULONG Key,
|
||||
OUT PIO_STATUS_BLOCK IoStatus,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is a call back routine for doing the fast unlock single call.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies the file object used in this operation
|
||||
|
||||
FileOffset - Supplies the file offset used in this operation
|
||||
|
||||
Length - Supplies the length used in this operation
|
||||
|
||||
ProcessId - Supplies the process ID used in this operation
|
||||
|
||||
Key - Supplies the key used in this operation
|
||||
|
||||
Status - Receives the Status if this operation is successful
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if this operation completed and FALSE if caller
|
||||
needs to take the long route.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
BOOLEAN Results = FALSE;
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFastUnlockSingle\n", 0);
|
||||
|
||||
IoStatus->Information = 0;
|
||||
|
||||
//
|
||||
// Decode the type of file object we're being asked to process and make sure
|
||||
// it is only a user file open
|
||||
//
|
||||
|
||||
if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
|
||||
|
||||
IoStatus->Status = STATUS_INVALID_PARAMETER;
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockSingle -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Acquire exclusive access to the Fcb this operation can always wait
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We check whether we can proceed based on the state of the file oplocks.
|
||||
//
|
||||
|
||||
if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
|
||||
|
||||
try_return( Results = FALSE );
|
||||
}
|
||||
|
||||
//
|
||||
// Now call the FsRtl routine to do the actual processing of the
|
||||
// Lock request. The call will always succeed.
|
||||
//
|
||||
|
||||
Results = TRUE;
|
||||
IoStatus->Status = FsRtlFastUnlockSingle( &Fcb->Specific.Fcb.FileLock,
|
||||
FileObject,
|
||||
FileOffset,
|
||||
Length,
|
||||
ProcessId,
|
||||
Key,
|
||||
NULL,
|
||||
FALSE );
|
||||
|
||||
//
|
||||
// Set the flag indicating if Fast I/O is possible
|
||||
//
|
||||
|
||||
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
||||
|
||||
try_exit: NOTHING;
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
DebugUnwind( FatFastUnlockSingle );
|
||||
|
||||
//
|
||||
// Release the Fcb, and return to our caller
|
||||
//
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockSingle -> %08lx\n", Results);
|
||||
} _SEH2_END;
|
||||
|
||||
return Results;
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(FAST_IO_UNLOCK_ALL)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatFastUnlockAll (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
PEPROCESS ProcessId,
|
||||
OUT PIO_STATUS_BLOCK IoStatus,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is a call back routine for doing the fast unlock all call.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies the file object used in this operation
|
||||
|
||||
ProcessId - Supplies the process ID used in this operation
|
||||
|
||||
Status - Receives the Status if this operation is successful
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if this operation completed and FALSE if caller
|
||||
needs to take the long route.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
BOOLEAN Results = FALSE;
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFastUnlockAll\n", 0);
|
||||
|
||||
IoStatus->Information = 0;
|
||||
|
||||
//
|
||||
// Decode the type of file object we're being asked to process and make sure
|
||||
// it is only a user file open.
|
||||
//
|
||||
|
||||
if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
|
||||
|
||||
IoStatus->Status = STATUS_INVALID_PARAMETER;
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockAll -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Acquire exclusive access to the Fcb this operation can always wait
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
(VOID) ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We check whether we can proceed based on the state of the file oplocks.
|
||||
//
|
||||
|
||||
if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
|
||||
|
||||
try_return( Results = FALSE );
|
||||
}
|
||||
|
||||
//
|
||||
// Now call the FsRtl routine to do the actual processing of the
|
||||
// Lock request. The call will always succeed.
|
||||
//
|
||||
|
||||
Results = TRUE;
|
||||
IoStatus->Status = FsRtlFastUnlockAll( &Fcb->Specific.Fcb.FileLock,
|
||||
FileObject,
|
||||
ProcessId,
|
||||
NULL );
|
||||
|
||||
//
|
||||
// Set the flag indicating if Fast I/O is possible
|
||||
//
|
||||
|
||||
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
||||
|
||||
try_exit: NOTHING;
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
DebugUnwind( FatFastUnlockAll );
|
||||
|
||||
//
|
||||
// Release the Fcb, and return to our caller
|
||||
//
|
||||
|
||||
ExReleaseResourceLite( (Fcb)->Header.Resource );
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockAll -> %08lx\n", Results);
|
||||
} _SEH2_END;
|
||||
|
||||
return Results;
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(FAST_IO_UNLOCK_ALL_BY_KEY)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatFastUnlockAllByKey (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
PVOID ProcessId,
|
||||
ULONG Key,
|
||||
OUT PIO_STATUS_BLOCK IoStatus,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is a call back routine for doing the fast unlock all by key call.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileObject - Supplies the file object used in this operation
|
||||
|
||||
ProcessId - Supplies the process ID used in this operation
|
||||
|
||||
Key - Supplies the key used in this operation
|
||||
|
||||
Status - Receives the Status if this operation is successful
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if this operation completed and FALSE if caller
|
||||
needs to take the long route.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
BOOLEAN Results = FALSE;
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFastUnlockAllByKey\n", 0);
|
||||
|
||||
IoStatus->Information = 0;
|
||||
|
||||
//
|
||||
// Decode the type of file object we're being asked to process and make sure
|
||||
// it is only a user file open.
|
||||
//
|
||||
|
||||
if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
|
||||
|
||||
IoStatus->Status = STATUS_INVALID_PARAMETER;
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockAll -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
//
|
||||
// Acquire exclusive access to the Fcb this operation can always wait
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
(VOID) ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We check whether we can proceed based on the state of the file oplocks.
|
||||
//
|
||||
|
||||
if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
|
||||
|
||||
try_return( Results = FALSE );
|
||||
}
|
||||
|
||||
//
|
||||
// Now call the FsRtl routine to do the actual processing of the
|
||||
// Lock request. The call will always succeed.
|
||||
//
|
||||
|
||||
Results = TRUE;
|
||||
IoStatus->Status = FsRtlFastUnlockAllByKey( &Fcb->Specific.Fcb.FileLock,
|
||||
FileObject,
|
||||
ProcessId,
|
||||
Key,
|
||||
NULL );
|
||||
|
||||
//
|
||||
// Set the flag indicating if Fast I/O is possible
|
||||
//
|
||||
|
||||
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
||||
|
||||
try_exit: NOTHING;
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
DebugUnwind( FatFastUnlockAllByKey );
|
||||
|
||||
//
|
||||
// Release the Fcb, and return to our caller
|
||||
//
|
||||
|
||||
ExReleaseResourceLite( (Fcb)->Header.Resource );
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFastUnlockAllByKey -> %08lx\n", Results);
|
||||
} _SEH2_END;
|
||||
|
||||
return Results;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatCommonLockControl (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the common routine for doing Lock control operations called
|
||||
by both the fsd and fsp threads
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status = STATUS_SUCCESS;
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
|
||||
TYPE_OF_OPEN TypeOfOpen;
|
||||
|
||||
PVCB Vcb;
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
|
||||
BOOLEAN OplockPostIrp = FALSE;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Get a pointer to the current Irp stack location
|
||||
//
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
DebugTrace(+1, Dbg, "FatCommonLockControl\n", 0);
|
||||
DebugTrace( 0, Dbg, "Irp = %p\n", Irp);
|
||||
DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
|
||||
|
||||
//
|
||||
// Decode the type of file object we're being asked to process
|
||||
//
|
||||
|
||||
TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
|
||||
|
||||
//
|
||||
// If the file is not a user file open then we reject the request
|
||||
// as an invalid parameter
|
||||
//
|
||||
|
||||
if (TypeOfOpen != UserFileOpen) {
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonLockControl -> STATUS_INVALID_PARAMETER\n", 0);
|
||||
return STATUS_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// Acquire exclusive access to the Fcb and enqueue the Irp if we didn't
|
||||
// get access
|
||||
//
|
||||
|
||||
if (!FatAcquireSharedFcb( IrpContext, Fcb )) {
|
||||
|
||||
Status = FatFsdPostRequest( IrpContext, Irp );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
|
||||
return Status;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We check whether we can proceed
|
||||
// based on the state of the file oplocks.
|
||||
//
|
||||
|
||||
#if (NTDDI_VERSION >= NTDDI_WIN8)
|
||||
|
||||
if (((IRP_MN_LOCK == IrpSp->MinorFunction) &&
|
||||
((ULONGLONG)IrpSp->Parameters.LockControl.ByteOffset.QuadPart <
|
||||
(ULONGLONG)Fcb->Header.AllocationSize.QuadPart)) ||
|
||||
((IRP_MN_LOCK != IrpSp->MinorFunction) &&
|
||||
FsRtlAreThereWaitingFileLocks( &Fcb->Specific.Fcb.FileLock ))) {
|
||||
|
||||
//
|
||||
// Check whether we can proceed based on the state of file oplocks if doing
|
||||
// an operation that interferes with oplocks. Those operations are:
|
||||
//
|
||||
// 1. Lock a range within the file's AllocationSize.
|
||||
// 2. Unlock a range when there are waiting locks on the file. This one
|
||||
// is not guaranteed to interfere with oplocks, but it could, as
|
||||
// unlocking this range might cause a waiting lock to be granted
|
||||
// within AllocationSize!
|
||||
//
|
||||
|
||||
#endif
|
||||
Status = FsRtlCheckOplock( FatGetFcbOplock(Fcb),
|
||||
Irp,
|
||||
IrpContext,
|
||||
FatOplockComplete,
|
||||
NULL );
|
||||
|
||||
#if (NTDDI_VERSION >= NTDDI_WIN8)
|
||||
}
|
||||
#endif
|
||||
|
||||
if (Status != STATUS_SUCCESS) {
|
||||
|
||||
OplockPostIrp = TRUE;
|
||||
try_return( NOTHING );
|
||||
}
|
||||
|
||||
//
|
||||
// Now call the FsRtl routine to do the actual processing of the
|
||||
// Lock request
|
||||
//
|
||||
|
||||
Status = FsRtlProcessFileLock( &Fcb->Specific.Fcb.FileLock, Irp, NULL );
|
||||
|
||||
//
|
||||
// Set the flag indicating if Fast I/O is possible
|
||||
//
|
||||
|
||||
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
||||
|
||||
try_exit: NOTHING;
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
DebugUnwind( FatCommonLockControl );
|
||||
|
||||
//
|
||||
// Only if this is not an abnormal termination do we delete the
|
||||
// irp context
|
||||
//
|
||||
|
||||
if (!_SEH2_AbnormalTermination() && !OplockPostIrp) {
|
||||
|
||||
FatCompleteRequest( IrpContext, FatNull, 0 );
|
||||
}
|
||||
|
||||
//
|
||||
// Release the Fcb, and return to our caller
|
||||
//
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
|
||||
DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
|
||||
} _SEH2_END;
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
1114
drivers/filesystems/fastfat_new/namesup.c
Normal file
1114
drivers/filesystems/fastfat_new/namesup.c
Normal file
File diff suppressed because it is too large
Load diff
194
drivers/filesystems/fastfat_new/nodetype.h
Normal file
194
drivers/filesystems/fastfat_new/nodetype.h
Normal file
|
|
@ -0,0 +1,194 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
NodeType.h
|
||||
|
||||
Abstract:
|
||||
|
||||
This module defines all of the node type codes used in this development
|
||||
shell. Every major data structure in the file system is assigned a node
|
||||
type code that is. This code is the first CSHORT in the structure and is
|
||||
followed by a CSHORT containing the size, in bytes, of the structure.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _FATNODETYPE_
|
||||
#define _FATNODETYPE_
|
||||
|
||||
typedef USHORT NODE_TYPE_CODE;
|
||||
typedef NODE_TYPE_CODE *PNODE_TYPE_CODE;
|
||||
|
||||
#define NTC_UNDEFINED ((NODE_TYPE_CODE)0x0000)
|
||||
|
||||
#define FAT_NTC_DATA_HEADER ((NODE_TYPE_CODE)0x0500)
|
||||
#define FAT_NTC_VCB ((NODE_TYPE_CODE)0x0501)
|
||||
#define FAT_NTC_FCB ((NODE_TYPE_CODE)0x0502)
|
||||
#define FAT_NTC_DCB ((NODE_TYPE_CODE)0x0503)
|
||||
#define FAT_NTC_ROOT_DCB ((NODE_TYPE_CODE)0x0504)
|
||||
#define FAT_NTC_CCB ((NODE_TYPE_CODE)0x0507)
|
||||
#define FAT_NTC_IRP_CONTEXT ((NODE_TYPE_CODE)0x0508)
|
||||
|
||||
typedef CSHORT NODE_BYTE_SIZE;
|
||||
|
||||
#ifndef NodeType
|
||||
|
||||
//
|
||||
// So all records start with
|
||||
//
|
||||
// typedef struct _RECORD_NAME {
|
||||
// NODE_TYPE_CODE NodeTypeCode;
|
||||
// NODE_BYTE_SIZE NodeByteSize;
|
||||
// :
|
||||
// } RECORD_NAME;
|
||||
// typedef RECORD_NAME *PRECORD_NAME;
|
||||
//
|
||||
|
||||
#define NodeType(Ptr) (*((PNODE_TYPE_CODE)(Ptr)))
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// The following definitions are used to generate meaningful blue bugcheck
|
||||
// screens. On a bugcheck the file system can output 4 ulongs of useful
|
||||
// information. The first ulong will have encoded in it a source file id
|
||||
// (in the high word) and the line number of the bugcheck (in the low word).
|
||||
// The other values can be whatever the caller of the bugcheck routine deems
|
||||
// necessary.
|
||||
//
|
||||
// Each individual file that calls bugcheck needs to have defined at the
|
||||
// start of the file a constant called BugCheckFileId with one of the
|
||||
// FAT_BUG_CHECK_ values defined below and then use FatBugCheck to bugcheck
|
||||
// the system.
|
||||
//
|
||||
|
||||
|
||||
#define FAT_BUG_CHECK_ACCHKSUP (0x00010000)
|
||||
#define FAT_BUG_CHECK_ALLOCSUP (0x00020000)
|
||||
#define FAT_BUG_CHECK_CACHESUP (0x00030000)
|
||||
#define FAT_BUG_CHECK_CLEANUP (0x00040000)
|
||||
#define FAT_BUG_CHECK_CLOSE (0x00050000)
|
||||
#define FAT_BUG_CHECK_CREATE (0x00060000)
|
||||
#define FAT_BUG_CHECK_DEVCTRL (0x00070000)
|
||||
#define FAT_BUG_CHECK_DEVIOSUP (0x00080000)
|
||||
#define FAT_BUG_CHECK_DIRCTRL (0x00090000)
|
||||
#define FAT_BUG_CHECK_DIRSUP (0x000a0000)
|
||||
#define FAT_BUG_CHECK_DUMPSUP (0x000b0000)
|
||||
#define FAT_BUG_CHECK_EA (0x000c0000)
|
||||
#define FAT_BUG_CHECK_EASUP (0x000d0000)
|
||||
#define FAT_BUG_CHECK_FATDATA (0x000e0000)
|
||||
#define FAT_BUG_CHECK_FATINIT (0x000f0000)
|
||||
#define FAT_BUG_CHECK_FILEINFO (0x00100000)
|
||||
#define FAT_BUG_CHECK_FILOBSUP (0x00110000)
|
||||
#define FAT_BUG_CHECK_FLUSH (0x00120000)
|
||||
#define FAT_BUG_CHECK_FSCTRL (0x00130000)
|
||||
#define FAT_BUG_CHECK_FSPDISP (0x00140000)
|
||||
#define FAT_BUG_CHECK_LOCKCTRL (0x00150000)
|
||||
#define FAT_BUG_CHECK_NAMESUP (0x00160000)
|
||||
#define FAT_BUG_CHECK_PNP (0x00170000)
|
||||
#define FAT_BUG_CHECK_READ (0x00180000)
|
||||
#define FAT_BUG_CHECK_RESRCSUP (0x00190000)
|
||||
#define FAT_BUG_CHECK_SHUTDOWN (0x001a0000)
|
||||
#define FAT_BUG_CHECK_SPLAYSUP (0x001b0000)
|
||||
#define FAT_BUG_CHECK_STRUCSUP (0x001c0000)
|
||||
#define FAT_BUG_CHECK_TIMESUP (0x001d0000)
|
||||
#define FAT_BUG_CHECK_VERFYSUP (0x001e0000)
|
||||
#define FAT_BUG_CHECK_VOLINFO (0x001f0000)
|
||||
#define FAT_BUG_CHECK_WORKQUE (0x00200000)
|
||||
#define FAT_BUG_CHECK_WRITE (0x00210000)
|
||||
|
||||
|
||||
#define FatBugCheck(A,B,C) { KeBugCheckEx(FAT_FILE_SYSTEM, BugCheckFileId | __LINE__, A, B, C ); }
|
||||
|
||||
|
||||
//
|
||||
// In this module we'll also define some globally known constants
|
||||
//
|
||||
|
||||
#define UCHAR_NUL 0x00
|
||||
#define UCHAR_SOH 0x01
|
||||
#define UCHAR_STX 0x02
|
||||
#define UCHAR_ETX 0x03
|
||||
#define UCHAR_EOT 0x04
|
||||
#define UCHAR_ENQ 0x05
|
||||
#define UCHAR_ACK 0x06
|
||||
#define UCHAR_BEL 0x07
|
||||
#define UCHAR_BS 0x08
|
||||
#define UCHAR_HT 0x09
|
||||
#define UCHAR_LF 0x0a
|
||||
#define UCHAR_VT 0x0b
|
||||
#define UCHAR_FF 0x0c
|
||||
#define UCHAR_CR 0x0d
|
||||
#define UCHAR_SO 0x0e
|
||||
#define UCHAR_SI 0x0f
|
||||
#define UCHAR_DLE 0x10
|
||||
#define UCHAR_DC1 0x11
|
||||
#define UCHAR_DC2 0x12
|
||||
#define UCHAR_DC3 0x13
|
||||
#define UCHAR_DC4 0x14
|
||||
#define UCHAR_NAK 0x15
|
||||
#define UCHAR_SYN 0x16
|
||||
#define UCHAR_ETB 0x17
|
||||
#define UCHAR_CAN 0x18
|
||||
#define UCHAR_EM 0x19
|
||||
#define UCHAR_SUB 0x1a
|
||||
#define UCHAR_ESC 0x1b
|
||||
#define UCHAR_FS 0x1c
|
||||
#define UCHAR_GS 0x1d
|
||||
#define UCHAR_RS 0x1e
|
||||
#define UCHAR_US 0x1f
|
||||
#define UCHAR_SP 0x20
|
||||
|
||||
#ifndef BUILDING_FSKDEXT
|
||||
|
||||
//
|
||||
// These are the tags we use to uniquely identify pool allocations.
|
||||
//
|
||||
|
||||
#define TAG_CCB 'CtaF'
|
||||
#define TAG_FCB 'FtaF'
|
||||
#define TAG_FCB_NONPAGED 'NtaF'
|
||||
#define TAG_ERESOURCE 'EtaF'
|
||||
#define TAG_IRP_CONTEXT 'ItaF'
|
||||
|
||||
#define TAG_BCB 'btaF'
|
||||
#define TAG_DIRENT 'DtaF'
|
||||
#define TAG_DIRENT_BITMAP 'TtaF'
|
||||
#define TAG_EA_DATA 'dtaF'
|
||||
#define TAG_EA_SET_HEADER 'etaF'
|
||||
#define TAG_EVENT 'ttaF'
|
||||
#define TAG_FAT_BITMAP 'BtaF'
|
||||
#define TAG_FAT_CLOSE_CONTEXT 'xtaF'
|
||||
#define TAG_FAT_IO_CONTEXT 'XtaF'
|
||||
#define TAG_FAT_WINDOW 'WtaF'
|
||||
#define TAG_FILENAME_BUFFER 'ntaF'
|
||||
#define TAG_IO_RUNS 'itaF'
|
||||
#define TAG_REPINNED_BCB 'RtaF'
|
||||
#define TAG_STASHED_BPB 'StaF'
|
||||
#define TAG_VCB_STATS 'VtaF'
|
||||
#define TAG_DEFERRED_FLUSH_CONTEXT 'ftaF'
|
||||
|
||||
#define TAG_VPB 'vtaF'
|
||||
|
||||
#define TAG_VERIFY_BOOTSECTOR 'staF'
|
||||
#define TAG_VERIFY_ROOTDIR 'rtaF'
|
||||
|
||||
#define TAG_OUTPUT_MAPPINGPAIRS 'PtaF'
|
||||
|
||||
#define TAG_ENTRY_LOOKUP_BUFFER 'LtaF'
|
||||
|
||||
#define TAG_IO_BUFFER 'OtaF'
|
||||
#define TAG_IO_USER_BUFFER 'QtaF'
|
||||
|
||||
#define TAG_DYNAMIC_NAME_BUFFER 'ctaF'
|
||||
|
||||
#define TAG_DEFRAG_BUFFER 'GtaF'
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _NODETYPE_
|
||||
|
||||
|
||||
902
drivers/filesystems/fastfat_new/pnp.c
Normal file
902
drivers/filesystems/fastfat_new/pnp.c
Normal file
|
|
@ -0,0 +1,902 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1997-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
Pnp.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Plug and Play routines for FAT called by
|
||||
the dispatch driver.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The Bug check file id for this module
|
||||
//
|
||||
|
||||
#define BugCheckFileId (FAT_BUG_CHECK_PNP)
|
||||
|
||||
#define Dbg (DEBUG_TRACE_PNP)
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_Requires_lock_held_(FatData.Resource)
|
||||
NTSTATUS
|
||||
FatPnpQueryRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
);
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
);
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpSurpriseRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
);
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpCancelRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
);
|
||||
|
||||
IO_COMPLETION_ROUTINE FatPnpCompletionRoutine;
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatPnpCompletionRoutine (
|
||||
_In_ PDEVICE_OBJECT DeviceObject,
|
||||
_In_ PIRP Irp,
|
||||
_In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt
|
||||
);
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatCommonPnp)
|
||||
#pragma alloc_text(PAGE, FatFsdPnp)
|
||||
#pragma alloc_text(PAGE, FatPnpCancelRemove)
|
||||
#pragma alloc_text(PAGE, FatPnpQueryRemove)
|
||||
#pragma alloc_text(PAGE, FatPnpRemove)
|
||||
#pragma alloc_text(PAGE, FatPnpSurpriseRemove)
|
||||
#endif
|
||||
|
||||
|
||||
_Function_class_(IRP_MJ_PNP)
|
||||
_Function_class_(DRIVER_DISPATCH)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatFsdPnp (
|
||||
_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
||||
_Inout_ PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine implements the FSD part of PnP operations
|
||||
|
||||
Arguments:
|
||||
|
||||
VolumeDeviceObject - Supplies the volume device object where the
|
||||
file exists
|
||||
|
||||
Irp - Supplies the Irp being processed
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The FSD status for the IRP
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
PIRP_CONTEXT IrpContext = NULL;
|
||||
|
||||
BOOLEAN TopLevel;
|
||||
BOOLEAN Wait;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFsdPnp\n", 0);
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
TopLevel = FatIsIrpTopLevel( Irp );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// We expect there to never be a fileobject, in which case we will always
|
||||
// wait. Since at the moment we don't have any concept of pending Pnp
|
||||
// operations, this is a bit nitpicky.
|
||||
//
|
||||
|
||||
if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
|
||||
|
||||
Wait = TRUE;
|
||||
|
||||
} else {
|
||||
|
||||
Wait = CanFsdWait( Irp );
|
||||
}
|
||||
|
||||
IrpContext = FatCreateIrpContext( Irp, Wait );
|
||||
|
||||
Status = FatCommonPnp( IrpContext, Irp );
|
||||
|
||||
} _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
|
||||
|
||||
//
|
||||
// We had some trouble trying to perform the requested
|
||||
// operation, so we'll abort the I/O request with
|
||||
// the error status that we get back from the
|
||||
// execption code
|
||||
//
|
||||
|
||||
Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
|
||||
} _SEH2_END;
|
||||
|
||||
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFsdPnp -> %08lx\n", Status);
|
||||
|
||||
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatCommonPnp (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the common routine for doing PnP operations called
|
||||
by both the fsd and fsp threads
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
|
||||
PVOLUME_DEVICE_OBJECT OurDeviceObject;
|
||||
PVCB Vcb;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Force everything to wait.
|
||||
//
|
||||
|
||||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
|
||||
|
||||
//
|
||||
// Get the current Irp stack location.
|
||||
//
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
//
|
||||
// Find our Vcb. This is tricky since we have no file object in the Irp.
|
||||
//
|
||||
|
||||
OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
|
||||
|
||||
//
|
||||
// Take the global lock to synchronise against volume teardown.
|
||||
//
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( push )
|
||||
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
|
||||
#pragma prefast( disable: 28193, "this will always wait" )
|
||||
#endif
|
||||
|
||||
FatAcquireExclusiveGlobal( IrpContext );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( pop )
|
||||
#endif
|
||||
|
||||
//
|
||||
// Make sure this device object really is big enough to be a volume device
|
||||
// object. If it isn't, we need to get out before we try to reference some
|
||||
// field that takes us past the end of an ordinary device object.
|
||||
//
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress: 28175, "touching Size is ok for a filesystem" )
|
||||
#endif
|
||||
if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
|
||||
NodeType( &OurDeviceObject->Vcb ) != FAT_NTC_VCB) {
|
||||
|
||||
//
|
||||
// We were called with something we don't understand.
|
||||
//
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
|
||||
Status = STATUS_INVALID_PARAMETER;
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
return Status;
|
||||
}
|
||||
|
||||
Vcb = &OurDeviceObject->Vcb;
|
||||
|
||||
//
|
||||
// Case on the minor code.
|
||||
//
|
||||
|
||||
switch ( IrpSp->MinorFunction ) {
|
||||
|
||||
case IRP_MN_QUERY_REMOVE_DEVICE:
|
||||
|
||||
Status = FatPnpQueryRemove( IrpContext, Irp, Vcb );
|
||||
break;
|
||||
|
||||
case IRP_MN_SURPRISE_REMOVAL:
|
||||
|
||||
Status = FatPnpSurpriseRemove( IrpContext, Irp, Vcb );
|
||||
break;
|
||||
|
||||
case IRP_MN_REMOVE_DEVICE:
|
||||
|
||||
Status = FatPnpRemove( IrpContext, Irp, Vcb );
|
||||
break;
|
||||
|
||||
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
||||
|
||||
Status = FatPnpCancelRemove( IrpContext, Irp, Vcb );
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
|
||||
//
|
||||
// Just pass the IRP on. As we do not need to be in the
|
||||
// way on return, ellide ourselves out of the stack.
|
||||
//
|
||||
|
||||
IoSkipCurrentIrpStackLocation( Irp );
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
|
||||
//
|
||||
// Cleanup our Irp Context. The driver has completed the Irp.
|
||||
//
|
||||
|
||||
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
FatPnpAdjustVpbRefCount(
|
||||
IN PVCB Vcb,
|
||||
IN ULONG Delta
|
||||
)
|
||||
{
|
||||
KIRQL OldIrql;
|
||||
|
||||
IoAcquireVpbSpinLock( &OldIrql);
|
||||
Vcb->Vpb->ReferenceCount += Delta;
|
||||
IoReleaseVpbSpinLock( OldIrql);
|
||||
}
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_Requires_lock_held_(FatData.Resource)
|
||||
NTSTATUS
|
||||
FatPnpQueryRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine handles the PnP query remove operation. The filesystem
|
||||
is responsible for answering whether there are any reasons it sees
|
||||
that the volume can not go away (and the device removed). Initiation
|
||||
of the dismount begins when we answer yes to this question.
|
||||
|
||||
Query will be followed by a Cancel or Remove.
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Vcb - Supplies the volume being queried.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status = STATUS_SUCCESS;
|
||||
KEVENT Event;
|
||||
BOOLEAN VcbDeleted = FALSE;
|
||||
BOOLEAN GlobalHeld = TRUE;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Having said yes to a QUERY, any communication with the
|
||||
// underlying storage stack is undefined (and may block)
|
||||
// until the bounding CANCEL or REMOVE is sent.
|
||||
//
|
||||
|
||||
FatAcquireExclusiveVcb( IrpContext, Vcb );
|
||||
|
||||
FatReleaseGlobal( IrpContext);
|
||||
GlobalHeld = FALSE;
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
Status = FatLockVolumeInternal( IrpContext, Vcb, NULL );
|
||||
|
||||
//
|
||||
// Drop an additional reference on the Vpb so that the volume cannot be
|
||||
// torn down when we drop all the locks below.
|
||||
//
|
||||
|
||||
FatPnpAdjustVpbRefCount( Vcb, 1);
|
||||
|
||||
//
|
||||
// Drop and reacquire the resources in the right order.
|
||||
//
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
|
||||
NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( push )
|
||||
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
|
||||
#pragma prefast( disable: 28193, "this will always wait" )
|
||||
#endif
|
||||
|
||||
FatAcquireExclusiveGlobal( IrpContext );
|
||||
GlobalHeld = TRUE;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( pop )
|
||||
#endif
|
||||
|
||||
FatAcquireExclusiveVcb( IrpContext, Vcb );
|
||||
|
||||
//
|
||||
// Drop the reference we added above.
|
||||
//
|
||||
|
||||
FatPnpAdjustVpbRefCount( Vcb, (ULONG)-1);
|
||||
|
||||
if (NT_SUCCESS( Status )) {
|
||||
|
||||
//
|
||||
// With the volume held locked, note that we must finalize as much
|
||||
// as possible right now.
|
||||
//
|
||||
|
||||
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, Flush );
|
||||
|
||||
//
|
||||
// We need to pass this down before starting the dismount, which
|
||||
// could disconnect us immediately from the stack.
|
||||
//
|
||||
|
||||
//
|
||||
// Get the next stack location, and copy over the stack location
|
||||
//
|
||||
|
||||
IoCopyCurrentIrpStackLocationToNext( Irp );
|
||||
|
||||
//
|
||||
// Set up the completion routine
|
||||
//
|
||||
|
||||
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
||||
IoSetCompletionRoutine( Irp,
|
||||
FatPnpCompletionRoutine,
|
||||
&Event,
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE );
|
||||
|
||||
//
|
||||
// Send the request and wait.
|
||||
//
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
|
||||
if (Status == STATUS_PENDING) {
|
||||
|
||||
KeWaitForSingleObject( &Event,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
NULL );
|
||||
|
||||
Status = Irp->IoStatus.Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Now if no one below us failed already, initiate the dismount
|
||||
// on this volume, make it go away. PnP needs to see our internal
|
||||
// streams close and drop their references to the target device.
|
||||
//
|
||||
// Since we were able to lock the volume, we are guaranteed to
|
||||
// move this volume into dismount state and disconnect it from
|
||||
// the underlying storage stack. The force on our part is actually
|
||||
// unnecesary, though complete.
|
||||
//
|
||||
// What is not strictly guaranteed, though, is that the closes
|
||||
// for the metadata streams take effect synchronously underneath
|
||||
// of this call. This would leave references on the target device
|
||||
// even though we are disconnected!
|
||||
//
|
||||
|
||||
if (NT_SUCCESS( Status )) {
|
||||
|
||||
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
|
||||
|
||||
NT_ASSERT( VcbDeleted || Vcb->VcbCondition == VcbBad );
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
//
|
||||
// Release the Vcb if it could still remain.
|
||||
//
|
||||
|
||||
if (!VcbDeleted) {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
}
|
||||
|
||||
if (GlobalHeld) {
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
}
|
||||
} _SEH2_END;
|
||||
|
||||
//
|
||||
// Cleanup our IrpContext and complete the IRP if neccesary.
|
||||
//
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine handles the PnP remove operation. This is our notification
|
||||
that the underlying storage device for the volume we have is gone, and
|
||||
an excellent indication that the volume will never reappear. The filesystem
|
||||
is responsible for initiation or completion of the dismount.
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Vcb - Supplies the volume being removed.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
KEVENT Event;
|
||||
BOOLEAN VcbDeleted = FALSE;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// REMOVE - a storage device is now gone. We either got
|
||||
// QUERY'd and said yes OR got a SURPRISE OR a storage
|
||||
// stack failed to spin back up from a sleep/stop state
|
||||
// (the only case in which this will be the first warning).
|
||||
//
|
||||
// Note that it is entirely unlikely that we will be around
|
||||
// for a REMOVE in the first two cases, as we try to intiate
|
||||
// dismount.
|
||||
//
|
||||
|
||||
//
|
||||
// Acquire the global resource so that we can try to vaporize
|
||||
// the volume, and the vcb resource itself.
|
||||
//
|
||||
|
||||
FatAcquireExclusiveVcb( IrpContext, Vcb );
|
||||
|
||||
//
|
||||
// The device will be going away. Remove our lock (benign
|
||||
// if we never had it).
|
||||
//
|
||||
|
||||
(VOID) FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
|
||||
|
||||
//
|
||||
// We need to pass this down before starting the dismount, which
|
||||
// could disconnect us immediately from the stack.
|
||||
//
|
||||
|
||||
//
|
||||
// Get the next stack location, and copy over the stack location
|
||||
//
|
||||
|
||||
IoCopyCurrentIrpStackLocationToNext( Irp );
|
||||
|
||||
//
|
||||
// Set up the completion routine
|
||||
//
|
||||
|
||||
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
||||
IoSetCompletionRoutine( Irp,
|
||||
FatPnpCompletionRoutine,
|
||||
&Event,
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE );
|
||||
|
||||
//
|
||||
// Send the request and wait.
|
||||
//
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
|
||||
if (Status == STATUS_PENDING) {
|
||||
|
||||
KeWaitForSingleObject( &Event,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
NULL );
|
||||
|
||||
Status = Irp->IoStatus.Status;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// Knock as many files down for this volume as we can.
|
||||
//
|
||||
|
||||
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
|
||||
|
||||
//
|
||||
// Now make our dismount happen. This may not vaporize the
|
||||
// Vcb, of course, since there could be any number of handles
|
||||
// outstanding if we were not preceeded by a QUERY.
|
||||
//
|
||||
// PnP will take care of disconnecting this stack if we
|
||||
// couldn't get off of it immediately.
|
||||
//
|
||||
|
||||
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
//
|
||||
// Release the Vcb if it could still remain.
|
||||
//
|
||||
|
||||
if (!VcbDeleted) {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
}
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
} _SEH2_END;
|
||||
|
||||
//
|
||||
// Cleanup our IrpContext and complete the IRP.
|
||||
//
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpSurpriseRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine handles the PnP surprise remove operation. This is another
|
||||
type of notification that the underlying storage device for the volume we
|
||||
have is gone, and is excellent indication that the volume will never reappear.
|
||||
The filesystem is responsible for initiation or completion the dismount.
|
||||
|
||||
For the most part, only "real" drivers care about the distinction of a
|
||||
surprise remove, which is a result of our noticing that a user (usually)
|
||||
physically reached into the machine and pulled something out.
|
||||
|
||||
Surprise will be followed by a Remove when all references have been shut down.
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Vcb - Supplies the volume being removed.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
KEVENT Event;
|
||||
BOOLEAN VcbDeleted = FALSE;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// SURPRISE - a device was physically yanked away without
|
||||
// any warning. This means external forces.
|
||||
//
|
||||
|
||||
FatAcquireExclusiveVcb( IrpContext, Vcb );
|
||||
|
||||
//
|
||||
// We need to pass this down before starting the dismount, which
|
||||
// could disconnect us immediately from the stack.
|
||||
//
|
||||
|
||||
//
|
||||
// Get the next stack location, and copy over the stack location
|
||||
//
|
||||
|
||||
IoCopyCurrentIrpStackLocationToNext( Irp );
|
||||
|
||||
//
|
||||
// Set up the completion routine
|
||||
//
|
||||
|
||||
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
||||
IoSetCompletionRoutine( Irp,
|
||||
FatPnpCompletionRoutine,
|
||||
&Event,
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE );
|
||||
|
||||
//
|
||||
// Send the request and wait.
|
||||
//
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
|
||||
if (Status == STATUS_PENDING) {
|
||||
|
||||
KeWaitForSingleObject( &Event,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
NULL );
|
||||
|
||||
Status = Irp->IoStatus.Status;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// Knock as many files down for this volume as we can.
|
||||
//
|
||||
|
||||
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
|
||||
|
||||
//
|
||||
// Now make our dismount happen. This may not vaporize the
|
||||
// Vcb, of course, since there could be any number of handles
|
||||
// outstanding since this is an out of band notification.
|
||||
//
|
||||
|
||||
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
//
|
||||
// Release the Vcb if it could still remain.
|
||||
//
|
||||
|
||||
if (!VcbDeleted) {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
}
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
} _SEH2_END;
|
||||
|
||||
//
|
||||
// Cleanup our IrpContext and complete the IRP.
|
||||
//
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, Status );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatPnpCancelRemove (
|
||||
PIRP_CONTEXT IrpContext,
|
||||
PIRP Irp,
|
||||
PVCB Vcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine handles the PnP cancel remove operation. This is our
|
||||
notification that a previously proposed remove (query) was eventually
|
||||
vetoed by a component. The filesystem is responsible for cleaning up
|
||||
and getting ready for more IO.
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp to process
|
||||
|
||||
Vcb - Supplies the volume being removed.
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status = STATUS_SUCCESS;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// CANCEL - a previous QUERY has been rescinded as a result
|
||||
// of someone vetoing. Since PnP cannot figure out who may
|
||||
// have gotten the QUERY (think about it: stacked drivers),
|
||||
// we must expect to deal with getting a CANCEL without having
|
||||
// seen the QUERY.
|
||||
//
|
||||
// For FAT, this is quite easy. In fact, we can't get a
|
||||
// CANCEL if the underlying drivers succeeded the QUERY since
|
||||
// we disconnect the Vpb on our dismount initiation. This is
|
||||
// actually pretty important because if PnP could get to us
|
||||
// after the disconnect we'd be thoroughly unsynchronized
|
||||
// with respect to the Vcb getting torn apart - merely referencing
|
||||
// the volume device object is insufficient to keep us intact.
|
||||
//
|
||||
|
||||
FatAcquireExclusiveVcb( IrpContext, Vcb );
|
||||
FatReleaseGlobal( IrpContext);
|
||||
|
||||
//
|
||||
// Unlock the volume. This is benign if we never had seen
|
||||
// a QUERY.
|
||||
//
|
||||
|
||||
(VOID)FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// Send the request. The underlying driver will complete the
|
||||
// IRP. Since we don't need to be in the way, simply ellide
|
||||
// ourselves out of the IRP stack.
|
||||
//
|
||||
|
||||
IoSkipCurrentIrpStackLocation( Irp );
|
||||
|
||||
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
|
||||
}
|
||||
_SEH2_FINALLY {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
} _SEH2_END;
|
||||
|
||||
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Local support routine
|
||||
//
|
||||
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatPnpCompletionRoutine (
|
||||
_In_ PDEVICE_OBJECT DeviceObject,
|
||||
_In_ PIRP Irp,
|
||||
_In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt
|
||||
)
|
||||
{
|
||||
PKEVENT Event = (PKEVENT) Contxt;
|
||||
|
||||
KeSetEvent( Event, 0, FALSE );
|
||||
|
||||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||||
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
UNREFERENCED_PARAMETER( Contxt );
|
||||
UNREFERENCED_PARAMETER( Irp );
|
||||
}
|
||||
|
||||
|
||||
1755
drivers/filesystems/fastfat_new/read.c
Normal file
1755
drivers/filesystems/fastfat_new/read.c
Normal file
File diff suppressed because it is too large
Load diff
966
drivers/filesystems/fastfat_new/resrcsup.c
Normal file
966
drivers/filesystems/fastfat_new/resrcsup.c
Normal file
|
|
@ -0,0 +1,966 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
ResrcSup.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Fat Resource acquisition routines
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatAcquireFcbForLazyWrite)
|
||||
#pragma alloc_text(PAGE, FatAcquireFcbForReadAhead)
|
||||
#pragma alloc_text(PAGE, FatAcquireExclusiveFcb)
|
||||
#pragma alloc_text(PAGE, FatAcquireSharedFcb)
|
||||
#pragma alloc_text(PAGE, FatAcquireSharedFcbWaitForEx)
|
||||
#pragma alloc_text(PAGE, FatAcquireExclusiveVcb_Real)
|
||||
#pragma alloc_text(PAGE, FatAcquireSharedVcb)
|
||||
#pragma alloc_text(PAGE, FatNoOpAcquire)
|
||||
#pragma alloc_text(PAGE, FatNoOpRelease)
|
||||
#pragma alloc_text(PAGE, FatReleaseFcbFromLazyWrite)
|
||||
#pragma alloc_text(PAGE, FatReleaseFcbFromReadAhead)
|
||||
#pragma alloc_text(PAGE, FatAcquireForCcFlush)
|
||||
#pragma alloc_text(PAGE, FatReleaseForCcFlush)
|
||||
#pragma alloc_text(PAGE, FatFilterCallbackAcquireForCreateSection)
|
||||
#endif
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_When_(return != FALSE && NoOpCheck != FALSE, _Acquires_exclusive_lock_(Vcb->Resource))
|
||||
FINISHED
|
||||
FatAcquireExclusiveVcb_Real (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PVCB Vcb,
|
||||
IN BOOLEAN NoOpCheck
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine acquires exclusive access to the Vcb.
|
||||
|
||||
After we acquire the resource check to see if this operation is legal.
|
||||
If it isn't (ie. we get an exception), release the resource.
|
||||
|
||||
Arguments:
|
||||
|
||||
Vcb - Supplies the Vcb to acquire
|
||||
|
||||
NoOpCheck - if TRUE then don't do any verification of the request/volume state.
|
||||
|
||||
Return Value:
|
||||
|
||||
FINISHED - TRUE if we have the resource and FALSE if we needed to block
|
||||
for the resource but Wait is FALSE.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
|
||||
#endif
|
||||
if (ExAcquireResourceExclusiveLite( &Vcb->Resource, BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
|
||||
|
||||
if (!NoOpCheck) {
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
FatVerifyOperationIsLegal( IrpContext );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
if ( _SEH2_AbnormalTermination() ) {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_When_(return != 0, _Acquires_shared_lock_(Vcb->Resource))
|
||||
FINISHED
|
||||
FatAcquireSharedVcb (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PVCB Vcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine acquires shared access to the Vcb.
|
||||
|
||||
After we acquire the resource check to see if this operation is legal.
|
||||
If it isn't (ie. we get an exception), release the resource.
|
||||
|
||||
Arguments:
|
||||
|
||||
Vcb - Supplies the Vcb to acquire
|
||||
|
||||
Return Value:
|
||||
|
||||
FINISHED - TRUE if we have the resource and FALSE if we needed to block
|
||||
for the resource but Wait is FALSE.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
if (ExAcquireResourceSharedLite( &Vcb->Resource,
|
||||
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
FatVerifyOperationIsLegal( IrpContext );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
if ( _SEH2_AbnormalTermination() ) {
|
||||
|
||||
FatReleaseVcb( IrpContext, Vcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_Acquires_exclusive_lock_(*Fcb->Header.Resource)
|
||||
FINISHED
|
||||
FatAcquireExclusiveFcb (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine acquires exclusive access to the Fcb.
|
||||
|
||||
After we acquire the resource check to see if this operation is legal.
|
||||
If it isn't (ie. we get an exception), release the resource.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - Supplies the Fcb to acquire
|
||||
|
||||
Return Value:
|
||||
|
||||
FINISHED - TRUE if we have the resource and FALSE if we needed to block
|
||||
for the resource but Wait is FALSE.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
RetryFcbExclusive:
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
|
||||
#endif
|
||||
if (ExAcquireResourceExclusiveLite( Fcb->Header.Resource, BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
|
||||
|
||||
//
|
||||
// Check for anything other than a non-cached write if the
|
||||
// async count is non-zero in the Fcb, or if others are waiting
|
||||
// for the resource. Then wait for all outstanding I/O to finish,
|
||||
// drop the resource, and wait again.
|
||||
//
|
||||
|
||||
if ((Fcb->NonPaged->OutstandingAsyncWrites != 0) &&
|
||||
((IrpContext->MajorFunction != IRP_MJ_WRITE) ||
|
||||
!FlagOn(IrpContext->OriginatingIrp->Flags, IRP_NOCACHE) ||
|
||||
(ExGetSharedWaiterCount(Fcb->Header.Resource) != 0) ||
|
||||
(ExGetExclusiveWaiterCount(Fcb->Header.Resource) != 0))) {
|
||||
|
||||
KeWaitForSingleObject( Fcb->NonPaged->OutstandingAsyncEvent,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
(PLARGE_INTEGER) NULL );
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
|
||||
goto RetryFcbExclusive;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
FatVerifyOperationIsLegal( IrpContext );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
if ( _SEH2_AbnormalTermination() ) {
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_Acquires_shared_lock_(*Fcb->Header.Resource)
|
||||
FINISHED
|
||||
FatAcquireSharedFcb (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine acquires shared access to the Fcb.
|
||||
|
||||
After we acquire the resource check to see if this operation is legal.
|
||||
If it isn't (ie. we get an exception), release the resource.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - Supplies the Fcb to acquire
|
||||
|
||||
Return Value:
|
||||
|
||||
FINISHED - TRUE if we have the resource and FALSE if we needed to block
|
||||
for the resource but Wait is FALSE.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
RetryFcbShared:
|
||||
|
||||
if (ExAcquireResourceSharedLite( Fcb->Header.Resource, BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
|
||||
|
||||
//
|
||||
// Check for anything other than a non-cached write if the
|
||||
// async count is non-zero in the Fcb, or if others are waiting
|
||||
// for the resource. Then wait for all outstanding I/O to finish,
|
||||
// drop the resource, and wait again.
|
||||
//
|
||||
|
||||
if ((Fcb->NonPaged->OutstandingAsyncWrites != 0) &&
|
||||
((IrpContext->MajorFunction != IRP_MJ_WRITE) ||
|
||||
!FlagOn(IrpContext->OriginatingIrp->Flags, IRP_NOCACHE) ||
|
||||
(ExGetSharedWaiterCount(Fcb->Header.Resource) != 0) ||
|
||||
(ExGetExclusiveWaiterCount(Fcb->Header.Resource) != 0))) {
|
||||
|
||||
KeWaitForSingleObject( Fcb->NonPaged->OutstandingAsyncEvent,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
(PLARGE_INTEGER) NULL );
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
|
||||
goto RetryFcbShared;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
FatVerifyOperationIsLegal( IrpContext );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
if ( _SEH2_AbnormalTermination() ) {
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
|
||||
|
||||
return TRUE;
|
||||
|
||||
} else {
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
_When_(return != 0, _Acquires_shared_lock_(*Fcb->Header.Resource))
|
||||
FINISHED
|
||||
FatAcquireSharedFcbWaitForEx (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine acquires shared access to the Fcb, waiting first for any
|
||||
exclusive accessors to get the Fcb first.
|
||||
|
||||
After we acquire the resource check to see if this operation is legal.
|
||||
If it isn't (ie. we get an exception), release the resource.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - Supplies the Fcb to acquire
|
||||
|
||||
Return Value:
|
||||
|
||||
FINISHED - TRUE if we have the resource and FALSE if we needed to block
|
||||
for the resource but Wait is FALSE.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NT_ASSERT( FlagOn(IrpContext->OriginatingIrp->Flags, IRP_NOCACHE) );
|
||||
NT_ASSERT( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||||
|
||||
RetryFcbSharedWaitEx:
|
||||
|
||||
if (ExAcquireSharedWaitForExclusive( Fcb->Header.Resource, FALSE )) {
|
||||
|
||||
//
|
||||
// Check for anything other than a non-cached write if the
|
||||
// async count is non-zero in the Fcb. Then wait for all
|
||||
// outstanding I/O to finish, drop the resource, and wait again.
|
||||
//
|
||||
|
||||
if ((Fcb->NonPaged->OutstandingAsyncWrites != 0) &&
|
||||
(IrpContext->MajorFunction != IRP_MJ_WRITE)) {
|
||||
|
||||
KeWaitForSingleObject( Fcb->NonPaged->OutstandingAsyncEvent,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
(PLARGE_INTEGER) NULL );
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
|
||||
goto RetryFcbSharedWaitEx;
|
||||
}
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
FatVerifyOperationIsLegal( IrpContext );
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
if ( _SEH2_AbnormalTermination() ) {
|
||||
|
||||
FatReleaseFcb( IrpContext, Fcb );
|
||||
}
|
||||
} _SEH2_END;
|
||||
|
||||
|
||||
return TRUE;
|
||||
|
||||
} else {
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatAcquireFcbForLazyWrite (
|
||||
IN PVOID Fcb,
|
||||
IN BOOLEAN Wait
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The address of this routine is specified when creating a CacheMap for
|
||||
a file. It is subsequently called by the Lazy Writer prior to its
|
||||
performing lazy writes to the file.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Wait - TRUE if the caller is willing to block.
|
||||
|
||||
Return Value:
|
||||
|
||||
FALSE - if Wait was specified as FALSE and blocking would have
|
||||
been required. The Fcb is not acquired.
|
||||
|
||||
TRUE - if the Fcb has been acquired
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Check here for the EA File. It turns out we need the normal
|
||||
// resource shared in this case. Otherwise we take the paging
|
||||
// I/O resource shared.
|
||||
//
|
||||
|
||||
//
|
||||
// Note that we do not need to disable APC delivery to guard
|
||||
// against a rogue user issuing a suspend APC. That is because
|
||||
// it is guaranteed that the caller is either in the system context,
|
||||
// to which a user cannot deliver a suspend APC, or the caller has
|
||||
// already disabled kernel APC delivery before calling. This is true
|
||||
// for all the other pre-acquire routines as well.
|
||||
//
|
||||
|
||||
if (!ExAcquireResourceSharedLite( Fcb == ((PFCB)Fcb)->Vcb->EaFcb ?
|
||||
((PFCB)Fcb)->Header.Resource :
|
||||
((PFCB)Fcb)->Header.PagingIoResource,
|
||||
Wait )) {
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
//
|
||||
// We assume the Lazy Writer only acquires this Fcb once.
|
||||
// Therefore, it should be guaranteed that this flag is currently
|
||||
// clear (the ASSERT), and then we will set this flag, to insure
|
||||
// that the Lazy Writer will never try to advance Valid Data, and
|
||||
// also not deadlock by trying to get the Fcb exclusive.
|
||||
//
|
||||
|
||||
|
||||
NT_ASSERT( NodeType(((PFCB)Fcb)) == FAT_NTC_FCB );
|
||||
NT_ASSERT( ((PFCB)Fcb)->Specific.Fcb.LazyWriteThread == NULL );
|
||||
|
||||
((PFCB)Fcb)->Specific.Fcb.LazyWriteThread = PsGetCurrentThread();
|
||||
|
||||
NT_ASSERT( NULL != PsGetCurrentThread() );
|
||||
|
||||
if (NULL == FatData.LazyWriteThread) {
|
||||
|
||||
FatData.LazyWriteThread = PsGetCurrentThread();
|
||||
}
|
||||
|
||||
//
|
||||
// This is a kludge because Cc is really the top level. When it
|
||||
// enters the file system, we will think it is a resursive call
|
||||
// and complete the request with hard errors or verify. It will
|
||||
// then have to deal with them, somehow....
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == NULL);
|
||||
|
||||
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
VOID
|
||||
NTAPI
|
||||
FatReleaseFcbFromLazyWrite (
|
||||
IN PVOID Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The address of this routine is specified when creating a CacheMap for
|
||||
a file. It is subsequently called by the Lazy Writer after its
|
||||
performing lazy writes to the file.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Assert that this really is an fcb and that this thread really owns
|
||||
// the lazy writer mark in the fcb.
|
||||
//
|
||||
|
||||
NT_ASSERT( NodeType(((PFCB)Fcb)) == FAT_NTC_FCB );
|
||||
NT_ASSERT( NULL != PsGetCurrentThread() );
|
||||
NT_ASSERT( ((PFCB)Fcb)->Specific.Fcb.LazyWriteThread == PsGetCurrentThread() );
|
||||
|
||||
//
|
||||
// Release the lazy writer mark.
|
||||
//
|
||||
|
||||
((PFCB)Fcb)->Specific.Fcb.LazyWriteThread = NULL;
|
||||
|
||||
//
|
||||
// Check here for the EA File. It turns out we needed the normal
|
||||
// resource shared in this case. Otherwise it was the PagingIoResource.
|
||||
//
|
||||
|
||||
ExReleaseResourceLite( Fcb == ((PFCB)Fcb)->Vcb->EaFcb ?
|
||||
((PFCB)Fcb)->Header.Resource :
|
||||
((PFCB)Fcb)->Header.PagingIoResource );
|
||||
|
||||
//
|
||||
// Clear the kludge at this point.
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
IoSetTopLevelIrp( NULL );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatAcquireFcbForReadAhead (
|
||||
IN PVOID Fcb,
|
||||
IN BOOLEAN Wait
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The address of this routine is specified when creating a CacheMap for
|
||||
a file. It is subsequently called by the Lazy Writer prior to its
|
||||
performing read ahead to the file.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Wait - TRUE if the caller is willing to block.
|
||||
|
||||
Return Value:
|
||||
|
||||
FALSE - if Wait was specified as FALSE and blocking would have
|
||||
been required. The Fcb is not acquired.
|
||||
|
||||
TRUE - if the Fcb has been acquired
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// We acquire the normal file resource shared here to synchronize
|
||||
// correctly with purges.
|
||||
//
|
||||
|
||||
//
|
||||
// Note that we do not need to disable APC delivery to guard
|
||||
// against a rogue user issuing a suspend APC. That is because
|
||||
// it is guaranteed that the caller is either in the system context,
|
||||
// to which a user cannot deliver a suspend APC, or the caller has
|
||||
// already disabled kernel APC delivery before calling. This is true
|
||||
// for all the other pre-acquire routines as well.
|
||||
//
|
||||
|
||||
if (!ExAcquireResourceSharedLite( ((PFCB)Fcb)->Header.Resource,
|
||||
Wait )) {
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
//
|
||||
// This is a kludge because Cc is really the top level. We it
|
||||
// enters the file system, we will think it is a resursive call
|
||||
// and complete the request with hard errors or verify. It will
|
||||
// have to deal with them, somehow....
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == NULL);
|
||||
|
||||
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
VOID
|
||||
NTAPI
|
||||
FatReleaseFcbFromReadAhead (
|
||||
IN PVOID Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The address of this routine is specified when creating a CacheMap for
|
||||
a file. It is subsequently called by the Lazy Writer after its
|
||||
read ahead.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Clear the kludge at this point.
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
IoSetTopLevelIrp( NULL );
|
||||
|
||||
ExReleaseResourceLite( ((PFCB)Fcb)->Header.Resource );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
_Function_class_(FAST_IO_ACQUIRE_FOR_CCFLUSH)
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatAcquireForCcFlush (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
{
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
PVCB Vcb;
|
||||
PFSRTL_COMMON_FCB_HEADER Header;
|
||||
TYPE_OF_OPEN Type;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
//
|
||||
// Once again, the hack for making this look like
|
||||
// a recursive call if needed. We cannot let ourselves
|
||||
// verify under something that has resources held.
|
||||
//
|
||||
// This value is good. We should never try to acquire
|
||||
// the file this way underneath of the cache.
|
||||
//
|
||||
|
||||
NT_ASSERT( IoGetTopLevelIrp() != (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP );
|
||||
|
||||
if (IoGetTopLevelIrp() == NULL) {
|
||||
|
||||
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
}
|
||||
|
||||
//
|
||||
// Time for some exposition.
|
||||
//
|
||||
// Lockorder for FAT is main->bcb->pagingio. Invert this at your obvious peril.
|
||||
// The default logic for AcquireForCcFlush breaks this since in writethrough
|
||||
// unpinrepinned we will grab the bcb then Mm will use the callback (which
|
||||
// orders us with respect to the MmCollidedFlushEvent) to help us. If for
|
||||
// directories/ea we then grab the main we are out of order.
|
||||
//
|
||||
// Fortunately, we do not need main. We only need paging - just look at the write
|
||||
// path. This is basic pre-acquisition.
|
||||
//
|
||||
// Regular files require both resources, and are safe since we never pin them.
|
||||
//
|
||||
|
||||
//
|
||||
// Note that we do not need to disable APC delivery to guard
|
||||
// against a rogue user issuing a suspend APC. That is because
|
||||
// it is guaranteed that the caller is either in the system context,
|
||||
// to which a user cannot deliver a suspend APC, or the caller has
|
||||
// already disabled kernel APC delivery before calling. This is true
|
||||
// for all the other pre-acquire routines as well.
|
||||
//
|
||||
|
||||
Type = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
||||
Header = (PFSRTL_COMMON_FCB_HEADER) FileObject->FsContext;
|
||||
|
||||
if (Type < DirectoryFile) {
|
||||
|
||||
if (Header->Resource) {
|
||||
|
||||
if (!ExIsResourceAcquiredSharedLite( Header->Resource )) {
|
||||
|
||||
ExAcquireResourceExclusiveLite( Header->Resource, TRUE );
|
||||
|
||||
} else {
|
||||
|
||||
ExAcquireResourceSharedLite( Header->Resource, TRUE );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Header->PagingIoResource) {
|
||||
|
||||
ExAcquireResourceSharedLite( Header->PagingIoResource, TRUE );
|
||||
}
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatReleaseForCcFlush (
|
||||
IN PFILE_OBJECT FileObject,
|
||||
IN PDEVICE_OBJECT DeviceObject
|
||||
)
|
||||
{
|
||||
PFCB Fcb;
|
||||
PCCB Ccb;
|
||||
PVCB Vcb;
|
||||
PFSRTL_COMMON_FCB_HEADER Header;
|
||||
TYPE_OF_OPEN Type;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( DeviceObject );
|
||||
|
||||
//
|
||||
// Clear up our hint.
|
||||
//
|
||||
|
||||
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP) {
|
||||
|
||||
IoSetTopLevelIrp( NULL );
|
||||
}
|
||||
|
||||
Type = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
||||
Header = (PFSRTL_COMMON_FCB_HEADER) FileObject->FsContext;
|
||||
|
||||
if (Type < DirectoryFile) {
|
||||
|
||||
if (Header->Resource) {
|
||||
|
||||
ExReleaseResourceLite( Header->Resource );
|
||||
}
|
||||
}
|
||||
|
||||
if (Header->PagingIoResource) {
|
||||
|
||||
ExReleaseResourceLite( Header->PagingIoResource );
|
||||
}
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
BOOLEAN
|
||||
NTAPI
|
||||
FatNoOpAcquire (
|
||||
IN PVOID Fcb,
|
||||
IN BOOLEAN Wait
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine does nothing.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb/Dcb/Vcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Wait - TRUE if the caller is willing to block.
|
||||
|
||||
Return Value:
|
||||
|
||||
TRUE
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
UNREFERENCED_PARAMETER( Fcb );
|
||||
UNREFERENCED_PARAMETER( Wait );
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// This is a kludge because Cc is really the top level. We it
|
||||
// enters the file system, we will think it is a resursive call
|
||||
// and complete the request with hard errors or verify. It will
|
||||
// have to deal with them, somehow....
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == NULL);
|
||||
|
||||
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
NTAPI
|
||||
FatNoOpRelease (
|
||||
IN PVOID Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine does nothing.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fcb - The Fcb/Dcb/Vcb which was specified as a context parameter for this
|
||||
routine.
|
||||
|
||||
Return Value:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Clear the kludge at this point.
|
||||
//
|
||||
|
||||
NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
|
||||
|
||||
IoSetTopLevelIrp( NULL );
|
||||
|
||||
UNREFERENCED_PARAMETER( Fcb );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatFilterCallbackAcquireForCreateSection (
|
||||
IN PFS_FILTER_CALLBACK_DATA CallbackData,
|
||||
OUT PVOID *CompletionContext
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the callback routine for MM to use to acquire the file exclusively.
|
||||
|
||||
NOTE: This routine expects the default FSRTL routine to be used to release
|
||||
the resource. If this routine is ever changed to acquire something
|
||||
other than main, a corresponding release routine will be required.
|
||||
|
||||
Arguments:
|
||||
|
||||
FS_FILTER_CALLBACK_DATA - Filter based callback data that provides the file object we
|
||||
want to acquire.
|
||||
|
||||
CompletionContext - Ignored.
|
||||
|
||||
Return Value:
|
||||
|
||||
On success we return STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY.
|
||||
|
||||
If SyncType is SyncTypeCreateSection, we return a status that indicates whether there
|
||||
are any writers to this file. Note that main is acquired, so new handles cannot be opened.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PFCB Fcb;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
NT_ASSERT( CallbackData->Operation == FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION );
|
||||
NT_ASSERT( CallbackData->SizeOfFsFilterCallbackData == sizeof(FS_FILTER_CALLBACK_DATA) );
|
||||
|
||||
//
|
||||
// Grab the Fcb from the callback data file object.
|
||||
//
|
||||
|
||||
Fcb = CallbackData->FileObject->FsContext;
|
||||
|
||||
//
|
||||
// Take main exclusive.
|
||||
//
|
||||
|
||||
//
|
||||
// Note that we do not need to disable APC delivery to guard
|
||||
// against a rogue user issuing a suspend APC. That is because
|
||||
// it is guaranteed that the caller is either in the system context,
|
||||
// to which a user cannot deliver a suspend APC, or the caller has
|
||||
// already disabled kernel APC delivery before calling. This is true
|
||||
// for all the other pre-acquire routines as well.
|
||||
//
|
||||
|
||||
if (Fcb->Header.Resource) {
|
||||
|
||||
ExAcquireResourceExclusiveLite( Fcb->Header.Resource, TRUE );
|
||||
}
|
||||
|
||||
//
|
||||
// Return the appropriate status based on the type of synchronization and whether anyone
|
||||
// has write access to this file.
|
||||
//
|
||||
|
||||
if (CallbackData->Parameters.AcquireForSectionSynchronization.SyncType != SyncTypeCreateSection) {
|
||||
|
||||
return STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY;
|
||||
|
||||
} else if (Fcb->ShareAccess.Writers == 0) {
|
||||
|
||||
return STATUS_FILE_LOCKED_WITH_ONLY_READERS;
|
||||
|
||||
} else {
|
||||
|
||||
return STATUS_FILE_LOCKED_WITH_WRITERS;
|
||||
}
|
||||
|
||||
UNREFERENCED_PARAMETER( CompletionContext );
|
||||
}
|
||||
|
||||
318
drivers/filesystems/fastfat_new/shutdown.c
Normal file
318
drivers/filesystems/fastfat_new/shutdown.c
Normal file
|
|
@ -0,0 +1,318 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
Shutdown.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the file system shutdown routine for Fat
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// Local debug trace level
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_SHUTDOWN)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatCommonShutdown)
|
||||
#pragma alloc_text(PAGE, FatFsdShutdown)
|
||||
#endif
|
||||
|
||||
|
||||
_Function_class_(IRP_MJ_SHUTDOWN)
|
||||
_Function_class_(DRIVER_DISPATCH)
|
||||
NTSTATUS
|
||||
NTAPI
|
||||
FatFsdShutdown (
|
||||
_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
||||
_Inout_ PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine implements the FSD part of shutdown. Note that Shutdown will
|
||||
never be done asynchronously so we will never need the Fsp counterpart
|
||||
to shutdown.
|
||||
|
||||
This is the shutdown routine for the Fat file system device driver.
|
||||
This routine locks the global file system lock and then syncs all the
|
||||
mounted volumes.
|
||||
|
||||
Arguments:
|
||||
|
||||
VolumeDeviceObject - Supplies the volume device object where the
|
||||
file exists
|
||||
|
||||
Irp - Supplies the Irp being processed
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - Always STATUS_SUCCESS
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
NTSTATUS Status;
|
||||
PIRP_CONTEXT IrpContext = NULL;
|
||||
|
||||
BOOLEAN TopLevel;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
DebugTrace(+1, Dbg, "FatFsdShutdown\n", 0);
|
||||
|
||||
//
|
||||
// Call the common shutdown routine.
|
||||
//
|
||||
|
||||
FsRtlEnterFileSystem();
|
||||
|
||||
TopLevel = FatIsIrpTopLevel( Irp );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
IrpContext = FatCreateIrpContext( Irp, TRUE );
|
||||
|
||||
Status = FatCommonShutdown( IrpContext, Irp );
|
||||
|
||||
} _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
|
||||
|
||||
//
|
||||
// We had some trouble trying to perform the requested
|
||||
// operation, so we'll abort the I/O request with
|
||||
// the error status that we get back from the
|
||||
// execption code
|
||||
//
|
||||
|
||||
Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
|
||||
} _SEH2_END;
|
||||
|
||||
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
||||
|
||||
FsRtlExitFileSystem();
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFsdShutdown -> %08lx\n", Status);
|
||||
|
||||
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
_Requires_lock_held_(_Global_critical_region_)
|
||||
NTSTATUS
|
||||
FatCommonShutdown (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This is the common routine for shutdown called by both the fsd and
|
||||
fsp threads.
|
||||
|
||||
Arguments:
|
||||
|
||||
Irp - Supplies the Irp being processed
|
||||
|
||||
Return Value:
|
||||
|
||||
NTSTATUS - The return status for the operation
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
KEVENT Event;
|
||||
PLIST_ENTRY Links;
|
||||
PVCB Vcb;
|
||||
PIRP NewIrp;
|
||||
IO_STATUS_BLOCK Iosb;
|
||||
BOOLEAN VcbDeleted;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Make sure we don't get any pop-ups, and write everything through.
|
||||
//
|
||||
|
||||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS |
|
||||
IRP_CONTEXT_FLAG_WRITE_THROUGH);
|
||||
|
||||
//
|
||||
// Initialize an event for doing calls down to
|
||||
// our target device objects.
|
||||
//
|
||||
|
||||
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
||||
|
||||
//
|
||||
// Indicate that shutdown has started. This is used in FatFspClose.
|
||||
//
|
||||
|
||||
FatData.ShutdownStarted = TRUE;
|
||||
|
||||
//
|
||||
// Get everyone else out of the way
|
||||
//
|
||||
|
||||
NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( push )
|
||||
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
|
||||
#pragma prefast( disable: 28193, "this will always wait" )
|
||||
#endif
|
||||
|
||||
(VOID) FatAcquireExclusiveGlobal( IrpContext );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( pop )
|
||||
#endif
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
//
|
||||
// For every volume that is mounted we will flush the
|
||||
// volume and then shutdown the target device objects.
|
||||
//
|
||||
|
||||
Links = FatData.VcbQueue.Flink;
|
||||
while (Links != &FatData.VcbQueue) {
|
||||
|
||||
Vcb = CONTAINING_RECORD(Links, VCB, VcbLinks);
|
||||
|
||||
Links = Links->Flink;
|
||||
|
||||
//
|
||||
// If we have already been called before for this volume
|
||||
// (and yes this does happen), skip this volume as no writes
|
||||
// have been allowed since the first shutdown.
|
||||
//
|
||||
|
||||
if ( FlagOn( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN) ||
|
||||
(Vcb->VcbCondition != VcbGood) ) {
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
FatAcquireExclusiveVolume( IrpContext, Vcb );
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
(VOID)FatFlushVolume( IrpContext, Vcb, Flush );
|
||||
|
||||
//
|
||||
// The volume is now clean, note it. We purge the
|
||||
// volume file cache map before marking the volume
|
||||
// clean incase there is a stale Bpb in the cache.
|
||||
//
|
||||
|
||||
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
|
||||
|
||||
CcPurgeCacheSection( &Vcb->SectionObjectPointers,
|
||||
NULL,
|
||||
0,
|
||||
FALSE );
|
||||
|
||||
FatMarkVolume( IrpContext, Vcb, VolumeClean );
|
||||
}
|
||||
|
||||
} _SEH2_EXCEPT( EXCEPTION_EXECUTE_HANDLER ) {
|
||||
|
||||
FatResetExceptionState( IrpContext );
|
||||
} _SEH2_END;
|
||||
|
||||
//
|
||||
// Sometimes we take an excepion while flushing the volume, such
|
||||
// as when autoconv has converted the volume and is rebooting.
|
||||
// Even in that case we want to send the shutdown irp to the
|
||||
// target device so it can know to flush its cache, if it has one.
|
||||
//
|
||||
|
||||
_SEH2_TRY {
|
||||
|
||||
NewIrp = IoBuildSynchronousFsdRequest( IRP_MJ_SHUTDOWN,
|
||||
Vcb->TargetDeviceObject,
|
||||
NULL,
|
||||
0,
|
||||
NULL,
|
||||
&Event,
|
||||
&Iosb );
|
||||
|
||||
if (NewIrp != NULL) {
|
||||
|
||||
if (NT_SUCCESS(IoCallDriver( Vcb->TargetDeviceObject, NewIrp ))) {
|
||||
|
||||
(VOID) KeWaitForSingleObject( &Event,
|
||||
Executive,
|
||||
KernelMode,
|
||||
FALSE,
|
||||
NULL );
|
||||
|
||||
KeClearEvent( &Event );
|
||||
}
|
||||
}
|
||||
|
||||
} _SEH2_EXCEPT( EXCEPTION_EXECUTE_HANDLER ) {
|
||||
|
||||
FatResetExceptionState( IrpContext );
|
||||
} _SEH2_END;
|
||||
|
||||
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN );
|
||||
|
||||
//
|
||||
// Attempt to punch the volume down.
|
||||
//
|
||||
|
||||
VcbDeleted = FatCheckForDismount( IrpContext,
|
||||
Vcb,
|
||||
FALSE );
|
||||
|
||||
if (!VcbDeleted) {
|
||||
|
||||
FatReleaseVolume( IrpContext, Vcb );
|
||||
}
|
||||
}
|
||||
|
||||
} _SEH2_FINALLY {
|
||||
|
||||
|
||||
FatReleaseGlobal( IrpContext );
|
||||
|
||||
//
|
||||
// Unregister the file system.
|
||||
//
|
||||
|
||||
IoUnregisterFileSystem( FatDiskFileSystemDeviceObject);
|
||||
IoUnregisterFileSystem( FatCdromFileSystemDeviceObject);
|
||||
IoDeleteDevice( FatDiskFileSystemDeviceObject);
|
||||
IoDeleteDevice( FatCdromFileSystemDeviceObject);
|
||||
|
||||
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
|
||||
} _SEH2_END;
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
DebugTrace(-1, Dbg, "FatFsdShutdown -> STATUS_SUCCESS\n", 0);
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
488
drivers/filesystems/fastfat_new/splaysup.c
Normal file
488
drivers/filesystems/fastfat_new/splaysup.c
Normal file
|
|
@ -0,0 +1,488 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
PrefxSup.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Fat Name lookup Suport routines
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The Bug check file id for this module
|
||||
//
|
||||
|
||||
#define BugCheckFileId (FAT_BUG_CHECK_SPLAYSUP)
|
||||
|
||||
//
|
||||
// The debug trace level for this module
|
||||
//
|
||||
|
||||
#define Dbg (DEBUG_TRACE_SPLAYSUP)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatInsertName)
|
||||
#pragma alloc_text(PAGE, FatRemoveNames)
|
||||
#pragma alloc_text(PAGE, FatFindFcb)
|
||||
#pragma alloc_text(PAGE, FatCompareNames)
|
||||
#endif
|
||||
|
||||
|
||||
VOID
|
||||
FatInsertName (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PRTL_SPLAY_LINKS *RootNode,
|
||||
IN PFILE_NAME_NODE Name
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine will insert a name in the splay tree pointed to
|
||||
by RootNode.
|
||||
|
||||
The name must not already exist in the splay tree.
|
||||
|
||||
Arguments:
|
||||
|
||||
RootNode - Supplies a pointer to the table.
|
||||
|
||||
Name - Contains the New name to enter.
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
COMPARISON Comparison;
|
||||
PFILE_NAME_NODE Node;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
RtlInitializeSplayLinks(&Name->Links);
|
||||
|
||||
Restart:
|
||||
|
||||
//
|
||||
// If we are the first entry in the tree, just become the root.
|
||||
//
|
||||
|
||||
if (*RootNode == NULL) {
|
||||
|
||||
*RootNode = &Name->Links;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
Node = CONTAINING_RECORD( *RootNode, FILE_NAME_NODE, Links );
|
||||
|
||||
while (TRUE) {
|
||||
|
||||
//
|
||||
// Compare the prefix in the tree with the prefix we want
|
||||
// to insert. Note that Oem here doesn't mean anything.
|
||||
//
|
||||
|
||||
Comparison = CompareNames(&Node->Name.Oem, &Name->Name.Oem);
|
||||
|
||||
//
|
||||
// We should never find the name in the table already.
|
||||
//
|
||||
|
||||
if (Comparison == IsEqual) {
|
||||
|
||||
//
|
||||
// Almost. If the removable media was taken to another machine and
|
||||
// back, and we have something like:
|
||||
//
|
||||
// Old: abcdef~1 / abcdefxyz
|
||||
// New: abcdef~1 / abcdefxyzxyz
|
||||
//
|
||||
// but a handle was kept open to abcdefxyz so we couldn't purge
|
||||
// away the Fcb in the verify path ... opening abcdefxyzxyz will
|
||||
// try to insert a duplicate shortname. Bang!
|
||||
//
|
||||
// Invalidate it and the horse it came in on. This new one wins.
|
||||
// The old one is gone. Only if the old one is in normal state
|
||||
// do we really have a problem.
|
||||
//
|
||||
|
||||
if (Node->Fcb->FcbState == FcbGood) {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
|
||||
#endif
|
||||
FatBugCheck( (ULONG_PTR)*RootNode, (ULONG_PTR)Name, (ULONG_PTR)Node );
|
||||
}
|
||||
|
||||
//
|
||||
// Note, once we zap the prefix links we need to restart our walk
|
||||
// of the tree. Note that we aren't properly synchronized to
|
||||
// recursively mark bad.
|
||||
//
|
||||
|
||||
FatMarkFcbCondition( IrpContext, Node->Fcb, FcbBad, FALSE );
|
||||
FatRemoveNames( IrpContext, Node->Fcb );
|
||||
|
||||
goto Restart;
|
||||
}
|
||||
|
||||
//
|
||||
// If the tree prefix is greater than the new prefix then
|
||||
// we go down the left subtree
|
||||
//
|
||||
|
||||
if (Comparison == IsGreaterThan) {
|
||||
|
||||
//
|
||||
// We want to go down the left subtree, first check to see
|
||||
// if we have a left subtree
|
||||
//
|
||||
|
||||
if (RtlLeftChild(&Node->Links) == NULL) {
|
||||
|
||||
//
|
||||
// there isn't a left child so we insert ourselves as the
|
||||
// new left child
|
||||
//
|
||||
|
||||
RtlInsertAsLeftChild(&Node->Links, &Name->Links);
|
||||
|
||||
//
|
||||
// and exit the while loop
|
||||
//
|
||||
|
||||
break;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// there is a left child so simply go down that path, and
|
||||
// go back to the top of the loop
|
||||
//
|
||||
|
||||
Node = CONTAINING_RECORD( RtlLeftChild(&Node->Links),
|
||||
FILE_NAME_NODE,
|
||||
Links );
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// The tree prefix is either less than or a proper prefix
|
||||
// of the new string. We treat both cases a less than when
|
||||
// we do insert. So we want to go down the right subtree,
|
||||
// first check to see if we have a right subtree
|
||||
//
|
||||
|
||||
if (RtlRightChild(&Node->Links) == NULL) {
|
||||
|
||||
//
|
||||
// These isn't a right child so we insert ourselves as the
|
||||
// new right child
|
||||
//
|
||||
|
||||
RtlInsertAsRightChild(&Node->Links, &Name->Links);
|
||||
|
||||
//
|
||||
// and exit the while loop
|
||||
//
|
||||
|
||||
break;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// there is a right child so simply go down that path, and
|
||||
// go back to the top of the loop
|
||||
//
|
||||
|
||||
Node = CONTAINING_RECORD( RtlRightChild(&Node->Links),
|
||||
FILE_NAME_NODE,
|
||||
Links );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
VOID
|
||||
FatRemoveNames (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PFCB Fcb
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine will remove the short name and any long names associated
|
||||
with the files from their repsective splay tree.
|
||||
|
||||
Arguments:
|
||||
|
||||
Name - Supplies the Fcb to process.
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PDCB Parent;
|
||||
PRTL_SPLAY_LINKS NewRoot;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
Parent = Fcb->ParentDcb;
|
||||
|
||||
//
|
||||
// We used to assert this condition, but it really isn't good. If
|
||||
// someone rapidly renames a directory multiple times and we can't
|
||||
// flush the lower fcbs fast enough (that didn't go away synch.)
|
||||
// well, well hit some of them again.
|
||||
//
|
||||
// NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE ));
|
||||
//
|
||||
|
||||
if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
|
||||
|
||||
//
|
||||
// Delete the node short name.
|
||||
//
|
||||
|
||||
NewRoot = RtlDelete(&Fcb->ShortName.Links);
|
||||
|
||||
Parent->Specific.Dcb.RootOemNode = NewRoot;
|
||||
|
||||
//
|
||||
// Now check for the presence of long name and delete it.
|
||||
//
|
||||
|
||||
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME )) {
|
||||
|
||||
NewRoot = RtlDelete(&Fcb->LongName.Oem.Links);
|
||||
|
||||
Parent->Specific.Dcb.RootOemNode = NewRoot;
|
||||
|
||||
RtlFreeOemString( &Fcb->LongName.Oem.Name.Oem );
|
||||
|
||||
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
|
||||
}
|
||||
|
||||
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME )) {
|
||||
|
||||
NewRoot = RtlDelete(&Fcb->LongName.Unicode.Links);
|
||||
|
||||
Parent->Specific.Dcb.RootUnicodeNode = NewRoot;
|
||||
|
||||
RtlFreeUnicodeString( &Fcb->LongName.Unicode.Name.Unicode );
|
||||
|
||||
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME );
|
||||
}
|
||||
|
||||
ClearFlag( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
PFCB
|
||||
FatFindFcb (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN OUT PRTL_SPLAY_LINKS *RootNode,
|
||||
IN PSTRING Name,
|
||||
OUT PBOOLEAN FileNameDos OPTIONAL
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine searches either the Oem or Unicode splay tree looking
|
||||
for an Fcb with the specified name. In the case the Fcb is found,
|
||||
rebalance the tree.
|
||||
|
||||
Arguments:
|
||||
|
||||
RootNode - Supplies the parent to search.
|
||||
|
||||
Name - If present, search the Oem tree.
|
||||
|
||||
UnicodeName - If present, search the Unicode tree.
|
||||
|
||||
Return Value:
|
||||
|
||||
PFCB - The Fcb, or NULL if none was found.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
COMPARISON Comparison;
|
||||
PFILE_NAME_NODE Node;
|
||||
PRTL_SPLAY_LINKS Links;
|
||||
|
||||
PAGED_CODE();
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
Links = *RootNode;
|
||||
|
||||
while (Links != NULL) {
|
||||
|
||||
Node = CONTAINING_RECORD(Links, FILE_NAME_NODE, Links);
|
||||
|
||||
//
|
||||
// Compare the prefix in the tree with the full name
|
||||
//
|
||||
|
||||
Comparison = CompareNames(&Node->Name.Oem, Name);
|
||||
|
||||
//
|
||||
// See if they don't match
|
||||
//
|
||||
|
||||
if (Comparison == IsGreaterThan) {
|
||||
|
||||
//
|
||||
// The prefix is greater than the full name
|
||||
// so we go down the left child
|
||||
//
|
||||
|
||||
Links = RtlLeftChild(Links);
|
||||
|
||||
//
|
||||
// And continue searching down this tree
|
||||
//
|
||||
|
||||
} else if (Comparison == IsLessThan) {
|
||||
|
||||
//
|
||||
// The prefix is less than the full name
|
||||
// so we go down the right child
|
||||
//
|
||||
|
||||
Links = RtlRightChild(Links);
|
||||
|
||||
//
|
||||
// And continue searching down this tree
|
||||
//
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// We found it.
|
||||
//
|
||||
// Splay the tree and save the new root.
|
||||
//
|
||||
|
||||
*RootNode = RtlSplay(Links);
|
||||
|
||||
//
|
||||
// Tell the caller what kind of name we hit
|
||||
//
|
||||
|
||||
if (FileNameDos) {
|
||||
|
||||
*FileNameDos = Node->FileNameDos;
|
||||
}
|
||||
|
||||
return Node->Fcb;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// We didn't find the Fcb.
|
||||
//
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Local support routine
|
||||
//
|
||||
|
||||
COMPARISON
|
||||
FatCompareNames (
|
||||
IN PSTRING NameA,
|
||||
IN PSTRING NameB
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function compares two names as fast as possible. Note that since
|
||||
this comparison is case sensitive, I neither know nor case if the names
|
||||
are UNICODE or OEM. All that is important is that the result is
|
||||
deterministic.
|
||||
|
||||
Arguments:
|
||||
|
||||
NameA & NameB - The names to compare.
|
||||
|
||||
Return Value:
|
||||
|
||||
COMPARISON - returns
|
||||
|
||||
IsLessThan if NameA < NameB lexicalgraphically,
|
||||
IsGreaterThan if NameA > NameB lexicalgraphically,
|
||||
IsEqual if NameA is equal to NameB
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
ULONG i;
|
||||
ULONG MinLength;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Figure out the minimum of the two lengths
|
||||
//
|
||||
|
||||
MinLength = NameA->Length < NameB->Length ? NameA->Length :
|
||||
NameB->Length;
|
||||
|
||||
//
|
||||
// Loop through looking at all of the characters in both strings
|
||||
// testing for equalilty, less than, and greater than
|
||||
//
|
||||
|
||||
i = (ULONG)RtlCompareMemory( NameA->Buffer, NameB->Buffer, MinLength );
|
||||
|
||||
|
||||
if (i < MinLength) {
|
||||
|
||||
return NameA->Buffer[i] < NameB->Buffer[i] ? IsLessThan :
|
||||
IsGreaterThan;
|
||||
}
|
||||
|
||||
if (NameA->Length < NameB->Length) {
|
||||
|
||||
return IsLessThan;
|
||||
}
|
||||
|
||||
if (NameA->Length > NameB->Length) {
|
||||
|
||||
return IsGreaterThan;
|
||||
}
|
||||
|
||||
return IsEqual;
|
||||
}
|
||||
|
||||
3944
drivers/filesystems/fastfat_new/strucsup.c
Normal file
3944
drivers/filesystems/fastfat_new/strucsup.c
Normal file
File diff suppressed because it is too large
Load diff
375
drivers/filesystems/fastfat_new/timesup.c
Normal file
375
drivers/filesystems/fastfat_new/timesup.c
Normal file
|
|
@ -0,0 +1,375 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
TimeSup.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Fat Time conversion support routines
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatNtTimeToFatTime)
|
||||
#pragma alloc_text(PAGE, FatFatDateToNtTime)
|
||||
#pragma alloc_text(PAGE, FatFatTimeToNtTime)
|
||||
#pragma alloc_text(PAGE, FatGetCurrentFatTime)
|
||||
#endif
|
||||
|
||||
_Success_(return != FALSE)
|
||||
BOOLEAN
|
||||
FatNtTimeToFatTime (
|
||||
_In_ PIRP_CONTEXT IrpContext,
|
||||
_In_ PLARGE_INTEGER NtTime,
|
||||
_In_ BOOLEAN Rounding,
|
||||
_Out_ PFAT_TIME_STAMP FatTime,
|
||||
_Out_opt_ PUCHAR TenMsecs
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine converts an NtTime value to its corresponding Fat time value.
|
||||
|
||||
Arguments:
|
||||
|
||||
NtTime - Supplies the Nt GMT Time value to convert from
|
||||
|
||||
Rounding - Indicates whether the NT time should be rounded up to a FAT boundary.
|
||||
This should only be done *once* in the lifetime of a timestamp (important
|
||||
for tunneling, which will cause a timestamp to pass through at least twice).
|
||||
If true, rounded up. If false, rounded down to 10ms boundary. This obeys
|
||||
the rules for non-creation time and creation times (respectively).
|
||||
|
||||
FatTime - Receives the equivalent Fat time value
|
||||
|
||||
TenMsecs - Optionally receive the number of tens of milliseconds the NtTime, after
|
||||
any rounding, is greater than the FatTime
|
||||
|
||||
Return Value:
|
||||
|
||||
BOOLEAN - TRUE if the Nt time value is within the range of Fat's
|
||||
time range, and FALSE otherwise
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TIME_FIELDS TimeFields;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Convert the input to the a time field record.
|
||||
//
|
||||
|
||||
if (Rounding) {
|
||||
|
||||
//
|
||||
// Add almost two seconds to round up to the nearest double second.
|
||||
//
|
||||
|
||||
NtTime->QuadPart = NtTime->QuadPart + AlmostTwoSeconds;
|
||||
}
|
||||
|
||||
ExSystemTimeToLocalTime( NtTime, NtTime );
|
||||
|
||||
RtlTimeToTimeFields( NtTime, &TimeFields );
|
||||
|
||||
//
|
||||
// Check the range of the date found in the time field record
|
||||
//
|
||||
|
||||
if ((TimeFields.Year < 1980) || (TimeFields.Year > (1980 + 127))) {
|
||||
|
||||
ExLocalTimeToSystemTime( NtTime, NtTime );
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
//
|
||||
// The year will fit in Fat so simply copy over the information
|
||||
//
|
||||
|
||||
FatTime->Time.DoubleSeconds = (USHORT)(TimeFields.Second / 2);
|
||||
FatTime->Time.Minute = (USHORT)(TimeFields.Minute);
|
||||
FatTime->Time.Hour = (USHORT)(TimeFields.Hour);
|
||||
|
||||
FatTime->Date.Year = (USHORT)(TimeFields.Year - 1980);
|
||||
FatTime->Date.Month = (USHORT)(TimeFields.Month);
|
||||
FatTime->Date.Day = (USHORT)(TimeFields.Day);
|
||||
|
||||
if (TenMsecs) {
|
||||
|
||||
if (!Rounding) {
|
||||
|
||||
//
|
||||
// If the number of seconds was not divisible by two, then there
|
||||
// is another second of time (1 sec, 3 sec, etc.) Note we round down
|
||||
// the number of milleconds onto tens of milleseconds boundaries.
|
||||
//
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable: 4244 )
|
||||
#endif
|
||||
*TenMsecs = (TimeFields.Milliseconds / 10) +
|
||||
((TimeFields.Second % 2) * 100);
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( pop )
|
||||
#endif
|
||||
} else {
|
||||
|
||||
//
|
||||
// If we rounded up, we have in effect changed the NT time. Therefore,
|
||||
// it does not differ from the FAT time.
|
||||
//
|
||||
|
||||
*TenMsecs = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (Rounding) {
|
||||
|
||||
//
|
||||
// Slice off non-FAT boundary time and convert back to 64bit form
|
||||
//
|
||||
|
||||
TimeFields.Milliseconds = 0;
|
||||
TimeFields.Second -= TimeFields.Second % 2;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// Round down to 10ms boundary
|
||||
//
|
||||
|
||||
TimeFields.Milliseconds -= TimeFields.Milliseconds % 10;
|
||||
}
|
||||
|
||||
//
|
||||
// Convert back to NT time
|
||||
//
|
||||
|
||||
(VOID) RtlTimeFieldsToTime(&TimeFields, NtTime);
|
||||
|
||||
ExLocalTimeToSystemTime( NtTime, NtTime );
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
LARGE_INTEGER
|
||||
FatFatDateToNtTime (
|
||||
_In_ PIRP_CONTEXT IrpContext,
|
||||
_In_ FAT_DATE FatDate
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine converts a Fat datev value to its corresponding Nt GMT
|
||||
Time value.
|
||||
|
||||
Arguments:
|
||||
|
||||
FatDate - Supplies the Fat Date to convert from
|
||||
|
||||
Return Value:
|
||||
|
||||
LARGE_INTEGER - Receives the corresponding Nt Time value
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TIME_FIELDS TimeFields;
|
||||
LARGE_INTEGER Time;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Pack the input time/date into a time field record
|
||||
//
|
||||
|
||||
TimeFields.Year = (USHORT)(FatDate.Year + 1980);
|
||||
TimeFields.Month = (USHORT)(FatDate.Month);
|
||||
TimeFields.Day = (USHORT)(FatDate.Day);
|
||||
TimeFields.Hour = (USHORT)0;
|
||||
TimeFields.Minute = (USHORT)0;
|
||||
TimeFields.Second = (USHORT)0;
|
||||
TimeFields.Milliseconds = (USHORT)0;
|
||||
|
||||
//
|
||||
// Convert the time field record to Nt LARGE_INTEGER, and set it to zero
|
||||
// if we were given a bogus time.
|
||||
//
|
||||
|
||||
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
|
||||
|
||||
Time.LowPart = 0;
|
||||
Time.HighPart = 0;
|
||||
|
||||
} else {
|
||||
|
||||
ExLocalTimeToSystemTime( &Time, &Time );
|
||||
}
|
||||
|
||||
return Time;
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
}
|
||||
|
||||
|
||||
LARGE_INTEGER
|
||||
FatFatTimeToNtTime (
|
||||
_In_ PIRP_CONTEXT IrpContext,
|
||||
_In_ FAT_TIME_STAMP FatTime,
|
||||
_In_ UCHAR TenMilliSeconds
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine converts a Fat time value pair to its corresponding Nt GMT
|
||||
Time value.
|
||||
|
||||
Arguments:
|
||||
|
||||
FatTime - Supplies the Fat Time to convert from
|
||||
|
||||
TenMilliSeconds - A 10 Milisecond resolution
|
||||
|
||||
Return Value:
|
||||
|
||||
LARGE_INTEGER - Receives the corresponding Nt GMT Time value
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
TIME_FIELDS TimeFields;
|
||||
LARGE_INTEGER Time;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Pack the input time/date into a time field record
|
||||
//
|
||||
|
||||
TimeFields.Year = (USHORT)(FatTime.Date.Year + 1980);
|
||||
TimeFields.Month = (USHORT)(FatTime.Date.Month);
|
||||
TimeFields.Day = (USHORT)(FatTime.Date.Day);
|
||||
TimeFields.Hour = (USHORT)(FatTime.Time.Hour);
|
||||
TimeFields.Minute = (USHORT)(FatTime.Time.Minute);
|
||||
TimeFields.Second = (USHORT)(FatTime.Time.DoubleSeconds * 2);
|
||||
|
||||
if (TenMilliSeconds != 0) {
|
||||
|
||||
TimeFields.Second += (USHORT)(TenMilliSeconds / 100);
|
||||
TimeFields.Milliseconds = (USHORT)((TenMilliSeconds % 100) * 10);
|
||||
|
||||
} else {
|
||||
|
||||
TimeFields.Milliseconds = (USHORT)0;
|
||||
}
|
||||
|
||||
//
|
||||
// If the second value is greater than 59 then we truncate it to 0.
|
||||
// Note that this can't happen with a proper FAT timestamp.
|
||||
//
|
||||
|
||||
if (TimeFields.Second > 59) {
|
||||
|
||||
TimeFields.Second = 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Convert the time field record to Nt LARGE_INTEGER, and set it to zero
|
||||
// if we were given a bogus time.
|
||||
//
|
||||
|
||||
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
|
||||
|
||||
Time.LowPart = 0;
|
||||
Time.HighPart = 0;
|
||||
|
||||
} else {
|
||||
|
||||
ExLocalTimeToSystemTime( &Time, &Time );
|
||||
}
|
||||
|
||||
return Time;
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
}
|
||||
|
||||
|
||||
FAT_TIME_STAMP
|
||||
FatGetCurrentFatTime (
|
||||
_In_ PIRP_CONTEXT IrpContext
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine returns the current system time in Fat time
|
||||
|
||||
Arguments:
|
||||
|
||||
Return Value:
|
||||
|
||||
FAT_TIME_STAMP - Receives the current system time
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
LARGE_INTEGER Time;
|
||||
TIME_FIELDS TimeFields;
|
||||
FAT_TIME_STAMP FatTime;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Get the current system time, and map it into a time field record.
|
||||
//
|
||||
|
||||
KeQuerySystemTime( &Time );
|
||||
|
||||
ExSystemTimeToLocalTime( &Time, &Time );
|
||||
|
||||
//
|
||||
// Always add almost two seconds to round up to the nearest double second.
|
||||
//
|
||||
|
||||
Time.QuadPart = Time.QuadPart + AlmostTwoSeconds;
|
||||
|
||||
(VOID)RtlTimeToTimeFields( &Time, &TimeFields );
|
||||
|
||||
//
|
||||
// Now simply copy over the information
|
||||
//
|
||||
|
||||
FatTime.Time.DoubleSeconds = (USHORT)(TimeFields.Second / 2);
|
||||
FatTime.Time.Minute = (USHORT)(TimeFields.Minute);
|
||||
FatTime.Time.Hour = (USHORT)(TimeFields.Hour);
|
||||
|
||||
FatTime.Date.Year = (USHORT)(TimeFields.Year - 1980);
|
||||
FatTime.Date.Month = (USHORT)(TimeFields.Month);
|
||||
FatTime.Date.Day = (USHORT)(TimeFields.Day);
|
||||
|
||||
UNREFERENCED_PARAMETER( IrpContext );
|
||||
|
||||
return FatTime;
|
||||
}
|
||||
|
||||
|
||||
2036
drivers/filesystems/fastfat_new/verfysup.c
Normal file
2036
drivers/filesystems/fastfat_new/verfysup.c
Normal file
File diff suppressed because it is too large
Load diff
1372
drivers/filesystems/fastfat_new/volinfo.c
Normal file
1372
drivers/filesystems/fastfat_new/volinfo.c
Normal file
File diff suppressed because it is too large
Load diff
372
drivers/filesystems/fastfat_new/workque.c
Normal file
372
drivers/filesystems/fastfat_new/workque.c
Normal file
|
|
@ -0,0 +1,372 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 1989-2000 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
WorkQue.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module implements the Work queue routines for the Fat File
|
||||
system.
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#include "fatprocs.h"
|
||||
|
||||
//
|
||||
// The following constant is the maximum number of ExWorkerThreads that we
|
||||
// will allow to be servicing a particular target device at any one time.
|
||||
//
|
||||
|
||||
#define FSP_PER_DEVICE_THRESHOLD (2)
|
||||
|
||||
#ifdef ALLOC_PRAGMA
|
||||
#pragma alloc_text(PAGE, FatOplockComplete)
|
||||
#pragma alloc_text(PAGE, FatPrePostIrp)
|
||||
#pragma alloc_text(PAGE, FatFsdPostRequest)
|
||||
#endif
|
||||
|
||||
|
||||
VOID
|
||||
NTAPI
|
||||
FatOplockComplete (
|
||||
IN PVOID Context,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine is called by the oplock package when an oplock break has
|
||||
completed, allowing an Irp to resume execution. If the status in
|
||||
the Irp is STATUS_SUCCESS, then we queue the Irp to the Fsp queue.
|
||||
Otherwise we complete the Irp with the status in the Irp.
|
||||
|
||||
Arguments:
|
||||
|
||||
Context - Pointer to the IrpContext to be queued to the Fsp
|
||||
|
||||
Irp - I/O Request Packet.
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// Check on the return value in the Irp.
|
||||
//
|
||||
|
||||
if (Irp->IoStatus.Status == STATUS_SUCCESS) {
|
||||
|
||||
//
|
||||
// Insert the Irp context in the workqueue.
|
||||
//
|
||||
|
||||
FatAddToWorkque( (PIRP_CONTEXT) Context, Irp );
|
||||
|
||||
//
|
||||
// Otherwise complete the request.
|
||||
//
|
||||
|
||||
} else {
|
||||
|
||||
FatCompleteRequest( (PIRP_CONTEXT) Context, Irp, Irp->IoStatus.Status );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
NTAPI
|
||||
FatPrePostIrp (
|
||||
IN PVOID Context,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine performs any neccessary work before STATUS_PENDING is
|
||||
returned with the Fsd thread. This routine is called within the
|
||||
filesystem and by the oplock package.
|
||||
|
||||
Arguments:
|
||||
|
||||
Context - Pointer to the IrpContext to be queued to the Fsp
|
||||
|
||||
Irp - I/O Request Packet.
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
PIRP_CONTEXT IrpContext;
|
||||
|
||||
PAGED_CODE();
|
||||
|
||||
//
|
||||
// If there is no Irp, we are done.
|
||||
//
|
||||
|
||||
if (Irp == NULL) {
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
IrpContext = (PIRP_CONTEXT) Context;
|
||||
|
||||
//
|
||||
// If there is a STACK FatIoContext pointer, clean and NULL it.
|
||||
//
|
||||
|
||||
if ((IrpContext->FatIoContext != NULL) &&
|
||||
FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
|
||||
|
||||
ClearFlag(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT);
|
||||
IrpContext->FatIoContext = NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// We need to lock the user's buffer, unless this is an MDL-read,
|
||||
// in which case there is no user buffer.
|
||||
//
|
||||
// **** we need a better test than non-MDL (read or write)!
|
||||
|
||||
if (IrpContext->MajorFunction == IRP_MJ_READ ||
|
||||
IrpContext->MajorFunction == IRP_MJ_WRITE) {
|
||||
|
||||
//
|
||||
// If not an Mdl request, lock the user's buffer.
|
||||
//
|
||||
|
||||
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
|
||||
|
||||
FatLockUserBuffer( IrpContext,
|
||||
Irp,
|
||||
(IrpContext->MajorFunction == IRP_MJ_READ) ?
|
||||
IoWriteAccess : IoReadAccess,
|
||||
(IrpContext->MajorFunction == IRP_MJ_READ) ?
|
||||
IrpSp->Parameters.Read.Length : IrpSp->Parameters.Write.Length );
|
||||
}
|
||||
|
||||
//
|
||||
// We also need to check whether this is a query file operation.
|
||||
//
|
||||
|
||||
} else if (IrpContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL
|
||||
&& IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
|
||||
|
||||
FatLockUserBuffer( IrpContext,
|
||||
Irp,
|
||||
IoWriteAccess,
|
||||
IrpSp->Parameters.QueryDirectory.Length );
|
||||
|
||||
//
|
||||
// We also need to check whether this is a query ea operation.
|
||||
//
|
||||
|
||||
} else if (IrpContext->MajorFunction == IRP_MJ_QUERY_EA) {
|
||||
|
||||
FatLockUserBuffer( IrpContext,
|
||||
Irp,
|
||||
IoWriteAccess,
|
||||
IrpSp->Parameters.QueryEa.Length );
|
||||
|
||||
//
|
||||
// We also need to check whether this is a set ea operation.
|
||||
//
|
||||
|
||||
} else if (IrpContext->MajorFunction == IRP_MJ_SET_EA) {
|
||||
|
||||
FatLockUserBuffer( IrpContext,
|
||||
Irp,
|
||||
IoReadAccess,
|
||||
IrpSp->Parameters.SetEa.Length );
|
||||
|
||||
//
|
||||
// These two FSCTLs use neither I/O, so check for them.
|
||||
//
|
||||
|
||||
} else if ((IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
|
||||
(IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST) &&
|
||||
((IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_VOLUME_BITMAP) ||
|
||||
(IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTERS))) {
|
||||
|
||||
FatLockUserBuffer( IrpContext,
|
||||
Irp,
|
||||
IoWriteAccess,
|
||||
IrpSp->Parameters.FileSystemControl.OutputBufferLength );
|
||||
}
|
||||
|
||||
//
|
||||
// Mark that we've already returned pending to the user
|
||||
//
|
||||
|
||||
IoMarkIrpPending( Irp );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
NTSTATUS
|
||||
FatFsdPostRequest(
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine enqueues the request packet specified by IrpContext to the
|
||||
Ex Worker threads. This is a FSD routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
IrpContext - Pointer to the IrpContext to be queued to the Fsp
|
||||
|
||||
Irp - I/O Request Packet, or NULL if it has already been completed.
|
||||
|
||||
Return Value:
|
||||
|
||||
STATUS_PENDING
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
PAGED_CODE();
|
||||
|
||||
NT_ASSERT( ARGUMENT_PRESENT(Irp) );
|
||||
NT_ASSERT( IrpContext->OriginatingIrp == Irp );
|
||||
|
||||
FatPrePostIrp( IrpContext, Irp );
|
||||
|
||||
FatAddToWorkque( IrpContext, Irp );
|
||||
|
||||
//
|
||||
// And return to our caller
|
||||
//
|
||||
|
||||
return STATUS_PENDING;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Local support routine.
|
||||
//
|
||||
|
||||
VOID
|
||||
FatAddToWorkque (
|
||||
IN PIRP_CONTEXT IrpContext,
|
||||
IN PIRP Irp
|
||||
)
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine is called to acually store the posted Irp to the Fsp
|
||||
workque.
|
||||
|
||||
Arguments:
|
||||
|
||||
IrpContext - Pointer to the IrpContext to be queued to the Fsp
|
||||
|
||||
Irp - I/O Request Packet.
|
||||
|
||||
Return Value:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
|
||||
{
|
||||
KIRQL SavedIrql;
|
||||
PIO_STACK_LOCATION IrpSp;
|
||||
|
||||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||||
|
||||
//
|
||||
// Check if this request has an associated file object, and thus volume
|
||||
// device object.
|
||||
//
|
||||
|
||||
if ( IrpSp->FileObject != NULL ) {
|
||||
|
||||
PVOLUME_DEVICE_OBJECT Vdo;
|
||||
|
||||
Vdo = CONTAINING_RECORD( IrpSp->DeviceObject,
|
||||
VOLUME_DEVICE_OBJECT,
|
||||
DeviceObject );
|
||||
|
||||
//
|
||||
// Check to see if this request should be sent to the overflow
|
||||
// queue. If not, then send it off to an exworker thread.
|
||||
//
|
||||
|
||||
KeAcquireSpinLock( &Vdo->OverflowQueueSpinLock, &SavedIrql );
|
||||
|
||||
if ( Vdo->PostedRequestCount > FSP_PER_DEVICE_THRESHOLD) {
|
||||
|
||||
//
|
||||
// We cannot currently respond to this IRP so we'll just enqueue it
|
||||
// to the overflow queue on the volume.
|
||||
//
|
||||
|
||||
InsertTailList( &Vdo->OverflowQueue,
|
||||
&IrpContext->WorkQueueItem.List );
|
||||
|
||||
Vdo->OverflowQueueCount += 1;
|
||||
|
||||
KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
|
||||
|
||||
return;
|
||||
|
||||
} else {
|
||||
|
||||
//
|
||||
// We are going to send this Irp to an ex worker thread so up
|
||||
// the count.
|
||||
//
|
||||
|
||||
Vdo->PostedRequestCount += 1;
|
||||
|
||||
KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Send it off.....
|
||||
//
|
||||
|
||||
ExInitializeWorkItem( &IrpContext->WorkQueueItem,
|
||||
FatFspDispatch,
|
||||
IrpContext );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma prefast( suppress:28159, "prefast indicates this is an obsolete API but it is ok for fastfat to keep using it." )
|
||||
#endif
|
||||
ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
3089
drivers/filesystems/fastfat_new/write.c
Normal file
3089
drivers/filesystems/fastfat_new/write.c
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -15,3 +15,6 @@ The following FSD are shared with: http://www.acc.umu.se/~bosse/
|
|||
|
||||
reactos/drivers/filesystems/ffs # Synced to 0.5.2
|
||||
reactos/drivers/filesystems/reiserfs # Synced to 0.26
|
||||
|
||||
The following FSD are shared with: https://github.com/Microsoft/Windows-driver-samples.
|
||||
reactos/drivers/filesystems/fastfat_new # Synced to 2817004
|
||||
|
|
|
|||
Loading…
Reference in a new issue