<?xml version="1.0"?>
<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
-<module name="ext2fs" type="kernelmodedriver" installbase="system32/drivers" installname="ext2.sys" allowwarnings="true">
+<module name="ext2fs" type="kernelmodedriver" installbase="system32/drivers" installname="ext2.sys">
<bootstrap installbase="$(CDOUTPUT)" />
<include base="ext2fs">inc</include>
<library>ntoskrnl</library>
extern BOOLEAN NTAPI Ext2FastIoUnlockAllByKey(
IN PFILE_OBJECT FileObject,
-PEPROCESS ProcessId,
+PVOID ProcessId,
ULONG Key,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
#define except(x) if (0 && (x))
#define finally if (1)
#define GetExceptionInformation() 0
+#define GetExceptionCode() 0
// we will use the LARGE_INTEGER structure as defined by NT
{
DebugTrace(DEBUG_TRACE_MISC, " !!!! Unable to create an IRP", 0 );
Status = STATUS_INSUFFICIENT_RESOURCES;
- try_return( Status );
+ try_return();
}
//
{
DebugTrace( DEBUG_TRACE_FILE_OBJ, "###### File Pointer 0x%LX [Cleanup]", PtrFileObject);
}
- try_return( RC );
+ try_return();
}
CompleteIrp = TRUE;
}
- try_return( RC );
+ try_return();
try_exit: NOTHING;
{
DebugTrace( DEBUG_TRACE_SPECIAL, "###### File Pointer 0x%LX [Close]", PtrFileObject);
}
- try_return( RC );
+ try_return();
}
// Get the FCB and CCB pointers
DebugTrace(DEBUG_TRACE_MISC, "VCB Close Requested !!!", 0);
CompleteIrp = TRUE;
}
- try_return( RC );
+ try_return();
try_exit: NOTHING;
UNICODE_STRING AbsolutePathName;
UNICODE_STRING RenameLinkTargetFileName;
+ /* Silence GCC warnings */
+ RtlZeroMemory(&RelatedObjectName, sizeof(UNICODE_STRING));
+
ASSERT(PtrIrpContext);
ASSERT(PtrIrp);
// Asynchronous processing required...
RC = Ext2PostRequest(PtrIrpContext, PtrIrp);
DeferredProcessing = TRUE;
- try_return(RC);
+ try_return();
}
// Obtaining the parameters specified by the user.
if (PtrIrp->Overlay.AllocationSize.HighPart)
{
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
// Getting a pointer to the supplied security context
// Verify Volume...
// if (!NT_SUCCESS(RC = Ext2VerifyVolume(PtrVCB)))
// {
- // try_return(RC);
+ // try_return();
// }
// If the volume has been locked, fail the request
{
DebugTrace(DEBUG_TRACE_MISC, "Volume locked. Failing Create", 0 );
RC = STATUS_ACCESS_DENIED;
- try_return(RC);
+ try_return();
}
if ((OpenTargetDirectory) || (PtrExtAttrBuffer))
{
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
if (DirectoryOnlyRequested)
{
// a volume is not a directory
RC = STATUS_NOT_A_DIRECTORY;
- try_return(RC);
+ try_return();
}
if ((RequestedDisposition != FILE_OPEN) && (RequestedDisposition != FILE_OPEN_IF))
{
// cannot create a new volume, I'm afraid ...
RC = STATUS_ACCESS_DENIED;
- try_return(RC);
+ try_return();
}
DebugTrace(DEBUG_TRACE_MISC, "Volume open requested", 0 );
RC = Ext2OpenVolume(PtrVCB, PtrIrpContext, PtrIrp, ShareAccess, PtrSecurityContext, PtrNewFileObject);
ReturnedInformation = PtrIrp->IoStatus.Information;
- try_return(RC);
+ try_return();
}
if (OpenByFileId)
{
DebugTrace(DEBUG_TRACE_MISC, "Open by File Id requested", 0 );
RC = STATUS_ACCESS_DENIED;
- try_return(RC);
+ try_return();
}
// Relative path name specified...
{
// we must have a directory as the "related" object
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
// Performing validity checks...
if ((RelatedObjectName.Length == 0) || (RelatedObjectName.Buffer[0] != L'\\'))
{
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
if ((TargetObjectName.Length != 0) && (TargetObjectName.Buffer[0] == L'\\'))
{
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
// Creating an absolute path-name.
if (!(AbsolutePathName.Buffer = Ext2AllocatePool(PagedPool, AbsolutePathName.MaximumLength )))
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
RtlZeroMemory(AbsolutePathName.Buffer, AbsolutePathName.MaximumLength);
if (TargetObjectName.Buffer[0] != L'\\')
{
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
{
AbsolutePathName.MaximumLength = TargetObjectName.Length;
if (!(AbsolutePathName.Buffer = Ext2AllocatePool(PagedPool, AbsolutePathName.MaximumLength ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
RtlZeroMemory(AbsolutePathName.Buffer, AbsolutePathName.MaximumLength);
(RequestedDisposition == FILE_OVERWRITE_IF))
{
RC = STATUS_FILE_IS_A_DIRECTORY;
- try_return(RC);
+ try_return();
}
RC = Ext2OpenRootDirectory(PtrVCB, PtrIrpContext, PtrIrp, ShareAccess, PtrSecurityContext, PtrNewFileObject);
DebugTrace(DEBUG_TRACE_MISC, " === Root directory opened", 0 );
- try_return(RC);
+ try_return();
}
// Can have only a directory in the middle of the path...
//
RC = STATUS_OBJECT_PATH_NOT_FOUND;
- try_return( RC );
+ try_return();
}
}
else // searching on the disk...
if( !CurrInodeNo )
{
RC = STATUS_OBJECT_PATH_NOT_FOUND;
- try_return( RC );
+ try_return();
}
// Set the allocation size for the object is specified
//IoSetShareAccess(DesiredAccess, ShareAccess, PtrNewFileObject, &(PtrNewFCB->FCBShareAccess));
else
{
RC = STATUS_OBJECT_PATH_NOT_FOUND;
- try_return( RC );
+ try_return();
}
}
// Can have only a directory in the middle of the path...
//
RC = STATUS_OBJECT_PATH_NOT_FOUND;
- try_return( RC );
+ try_return();
}
PtrCurrFileObject = NULL;
{
ReturnedInformation = FILE_EXISTS;
RC = STATUS_OBJECT_NAME_COLLISION;
- try_return(RC);
+ try_return();
}
// Is this the type of file I was looking for?
// Deny access!
// Cannot open a special file...
RC = STATUS_ACCESS_DENIED;
- try_return( RC );
+ try_return();
}
if( DirectoryOnlyRequested && Type != EXT2_FT_DIR )
{
RC = STATUS_NOT_A_DIRECTORY;
- try_return( RC );
+ try_return();
}
if( FileOnlyRequested && Type == EXT2_FT_DIR )
{
RC = STATUS_FILE_IS_A_DIRECTORY;
- try_return(RC);
+ try_return();
}
PtrCurrFileObject = PtrNewFileObject;
PtrObjectName ) ) )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
if( Type == EXT2_FT_DIR )
(RequestedDisposition == FILE_OVERWRITE) || (RequestedDisposition == FILE_OVERWRITE_IF )))
{
RC = STATUS_FILE_IS_A_DIRECTORY;
- try_return(RC);
+ try_return();
}
&(PtrNewFCB->FCBShareAccess), TRUE)))
{
// Ext2CloseCCB(PtrNewCCB);
- try_return(RC);
+ try_return();
}
}
else
if (!(PtrCCB = Ext2AllocateCCB()))
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
// initialize the CCB
{
// Read Failure
DebugTrace(DEBUG_TRACE_MISC, "Cache read failiure while reading in volume meta data", 0);
- try_return( STATUS_ACCESS_DENIED );
+ try_return( RC = STATUS_ACCESS_DENIED );
}
else
{
case FileFullDirectoryInformation:
// FullDirInformation->
DebugTrace(DEBUG_TRACE_DIRINFO, " === FileFullDirectoryInformation - Not handled", 0 );
- try_return( RC );
+ try_return();
case FileNamesInformation:
// NamesInformation->
DebugTrace(DEBUG_TRACE_DIRINFO, " === FileNamesInformation - Not handled", 0 );
- try_return( RC );
+ try_return();
default:
DebugTrace(DEBUG_TRACE_DIRINFO, " === Invalid Dir Info class - Not handled", 0 );
try_return( RC = STATUS_INVALID_INFO_CLASS );
RC = STATUS_NO_SUCH_FILE;
else
RC = STATUS_NO_MORE_FILES;
- try_return( RC );
+ try_return();
}
else if( BytesReturned )
{
// in your commercial driver implementation, it would be
// advisable for your driver to print an appropriate error
// message to the system error log before leaving
- // try_return(RC);
+ // try_return();
// }
// we should have the registry data (if any), allocate zone memory ...
if (!NT_SUCCESS(RC = Ext2InitializeZones()))
{
// we failed, print a message and leave ...
- try_return(RC);
+ try_return();
}
#endif
&(Ext2GlobalData.Ext2DeviceObject))))
{
// failed to create a device object, leave ...
- try_return(RC);
+ try_return();
}
*************************************************************************/
BOOLEAN NTAPI Ext2FastIoUnlockAllByKey(
IN PFILE_OBJECT FileObject,
-PEPROCESS ProcessId,
+PVOID ProcessId,
ULONG Key,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject)
{
// This is not allowed. Caller must use get/set volume information instead.
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
// ASSERT(PtrFCB->NodeIdentifier.NodeType == EXT2_NODE_TYPE_FCB);
DebugTrace(DEBUG_TRACE_FILEINFO, "FileNetworkOpenInformation requested for %S", PtrFCB->FCBName->ObjectName.Buffer );
RC = Ext2GetNetworkOpenInformation(PtrFCB, (PFILE_NETWORK_OPEN_INFORMATION)PtrSystemBuffer, &BufferLength);
// RC = STATUS_INVALID_PARAMETER;
- // try_return(RC);
+ // try_return();
break;
#endif // _WIN32_WINNT >= 0x0400
case FileInternalInformation:
DebugTrace(DEBUG_TRACE_FILEINFO, "FileInternalInformation requested for %S", PtrFCB->FCBName->ObjectName.Buffer );
// RC = Ext2GetInternalInformation(...);
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
break;
case FileEaInformation:
DebugTrace(DEBUG_TRACE_FILEINFO, "FileEaInformation requested for %S", PtrFCB->FCBName->ObjectName.Buffer );
// RC = Ext2GetFileStreamInformation(...);
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
break;
case FileAllInformation:
if (!NT_SUCCESS(RC = Ext2GetBasicInformation(PtrFCB, (PFILE_BASIC_INFORMATION)&(PtrAllInfo->BasicInformation),
&BufferLength)))
{
- try_return(RC);
+ try_return();
}
if (!NT_SUCCESS(RC = Ext2GetStandardInformation(PtrFCB, &(PtrAllInfo->StandardInformation), &BufferLength)))
{
- try_return(RC);
+ try_return();
}
// Similarly, get all of the others ...
}
case FileAlternateNameInformation:
DebugTrace(DEBUG_TRACE_FILEINFO, "FileAlternateNameInformation requested for %S", PtrFCB->FCBName->ObjectName.Buffer );
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
// RC = Ext2GetAltNameInformation(...);
break;
case FileCompressionInformation:
DebugTrace(DEBUG_TRACE_FILEINFO, "FileCompressionInformation requested for %S", PtrFCB->FCBName->ObjectName.Buffer );
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
// RC = Ext2GetCompressionInformation(...);
break;
default:
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
// If we completed successfully, the return the amount of information transferred.
DebugTrace(DEBUG_TRACE_FILEINFO, "Attempt to set FileEndOfFileInformation for %S", PtrFCB->FCBName->ObjectName.Buffer );
// RC = Ext2SetEOF(...);
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
break;
case FilePositionInformation:
case FileLinkInformation:
DebugTrace(DEBUG_TRACE_FILEINFO, "Attempt to set FileLinkInformation for %S", PtrFCB->FCBName->ObjectName.Buffer );
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
// When you implement your rename/link routine, be careful to
// check the following two arguments:
// TargetFileObject = PtrIoStackLocation->Parameters.SetFile.FileObject;
default:
DebugTrace(DEBUG_TRACE_FILEINFO, "Unrecoganised SetFileInformation code for %S", PtrFCB->FCBName->ObjectName.Buffer );
RC = STATUS_INVALID_PARAMETER;
- try_return(RC);
+ try_return();
}
}
// "un-delete" the file.
Ext2ClearFlag(PtrFCB->FCBFlags, EXT2_FCB_DELETE_ON_CLOSE);
PtrFileObject->DeletePending = FALSE;
- try_return(RC);
+ try_return();
}
// Do some checking to see if the file can even be deleted.
if (PtrFCB->FCBFlags & EXT2_FCB_DELETE_ON_CLOSE)
{
// All done!
- try_return(RC);
+ try_return();
}
if (PtrFCB->FCBFlags & EXT2_FCB_READ_ONLY)
// If we cannot wait, post the request immediately since a flush is inherently blocking/synchronous.
if (!CanWait) {
PostRequest = TRUE;
- try_return(RC);
+ try_return();
}
// Check the type of object passed-in. That will determine the course of
Ext2FlushLogicalVolume(PtrIrpContext, PtrIrp, PtrVCB);
- try_return(RC);
+ try_return();
}
if (!(PtrFCB->FCBFlags & EXT2_FCB_DIRECTORY))
PEXT2_GROUP_DESCRIPTOR PtrGroupDescriptor = NULL;
- PEXT2_INODE PtrInode = NULL;
-
// Inititalising variables
PtrVPB = IrpSp->Parameters.MountVolume.Vpb;
DebugTrace(DEBUG_TRACE_MOUNT, "OEM[%s]", BootSector->Oem);
if (BootSector->Oem[0])
{
- try_return (STATUS_WRONG_VOLUME);
+ try_return (Status = STATUS_WRONG_VOLUME);
}
// Allocating memory for reading in Super Block...
(PDEVICE_OBJECT *)&PtrVolumeDeviceObject)) // The Volume Device Object
)
{
- try_return( Status );
+ try_return();
}
//
PtrRootFileObject = IoCreateStreamFileObject(NULL, TargetDeviceObject );
if( !PtrRootFileObject )
{
- try_return( Status );
+ try_return();
}
//
// Associate the file stream with the Volume parameter block...
PtrVCB,
PtrObjectName ) ) )
{
- try_return( Status );
+ try_return();
}
if ( !PtrSyncEvent )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return ( RC );
+ try_return();
}
KeInitializeEvent( PtrSyncEvent, SynchronizationEvent, FALSE );
}
if ( !PtrIoContext )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return ( RC );
+ try_return();
}
RtlZeroMemory( PtrIoContext, sizeof(EXT2_IO_CONTEXT) );
KeWaitForSingleObject( PtrSyncEvent,
Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
DbgPrint("DEADLY WAIT DONE\n");
- try_return ( RC );
+ try_return();
}
else
{
// Asynchronous IO...
RC = STATUS_PENDING;
- try_return ( RC );
+ try_return();
}
try_exit: NOTHING;
if ( !PtrSyncEvent )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return ( RC );
+ try_return();
}
KeInitializeEvent( PtrSyncEvent, SynchronizationEvent, FALSE );
}
if ( !PtrIoContext )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return ( RC );
+ try_return();
}
RtlZeroMemory( PtrIoContext, sizeof(EXT2_IO_CONTEXT) );
DebugTrace(DEBUG_TRACE_MISC, "&&&&&& Invalid Inode no. Group no %d - too big", GroupNo );
DebugTrace(DEBUG_TRACE_MISC, "Only %d groups available on disk", PtrVcb->NoOfGroups );
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
//if( PtrVcb->InodeTableBlock[ GroupNo ] == 0 )
{
DebugTrace(DEBUG_TRACE_MISC, "&&&&&& Inode Table Group Invalid - Group no %d ", GroupNo );
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
// Inode numbers start at 1 and not from 0
(PVOID*)&PtrPinnedReadBuffer ))
{
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
else
{
DebugTrace(DEBUG_TRACE_MISC, "&&&&&& Invalid Inode no. Group no %d - too big", GroupNo );
DebugTrace(DEBUG_TRACE_MISC, "Only %d groups available on disk", PtrVcb->NoOfGroups );
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
if( PtrVcb->PtrGroupDescriptors[ GroupNo ].InodeTablesBlock == 0 )
{
DebugTrace(DEBUG_TRACE_MISC, "&&&&&& Inode Table Group Invalid - Group no %d ", GroupNo );
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
Index = ( InodeNo - 1 ) - ( GroupNo * PtrVcb->InodesPerGroup );
(PVOID*)&PtrPinnedBuffer ) )
{
RC = STATUS_UNSUCCESSFUL;
- try_return( RC );
+ try_return();
}
else
{
// allocate memory for each of the zones and initialize the zones ...
if (!(Ext2GlobalData.ObjectNameZone = Ext2AllocatePool(NonPagedPool, SizeOfObjectNameZone ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
if (!(Ext2GlobalData.CCBZone = Ext2AllocatePool(NonPagedPool, SizeOfCCBZone ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
if (!(Ext2GlobalData.FCBZone = Ext2AllocatePool(NonPagedPool, SizeOfFCBZone ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
if (!(Ext2GlobalData.ByteLockZone = Ext2AllocatePool(NonPagedPool, SizeOfByteLockZone ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
if (!(Ext2GlobalData.IrpContextZone = Ext2AllocatePool(NonPagedPool, SizeOfIrpContextZone ))) {
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
// initialize each of the zone headers ...
Ext2QuadAlign(sizeof(Ext2ObjectName)),
Ext2GlobalData.ObjectNameZone, SizeOfObjectNameZone))) {
// failed the initialization, leave ...
- try_return(RC);
+ try_return();
}
if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.CCBZoneHeader),
Ext2GlobalData.CCBZone,
SizeOfCCBZone))) {
// failed the initialization, leave ...
- try_return(RC);
+ try_return();
}
if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.FCBZoneHeader),
Ext2GlobalData.FCBZone,
SizeOfFCBZone))) {
// failed the initialization, leave ...
- try_return(RC);
+ try_return();
}
if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.ByteLockZoneHeader),
Ext2GlobalData.ByteLockZone,
SizeOfByteLockZone))) {
// failed the initialization, leave ...
- try_return(RC);
+ try_return();
}
if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.IrpContextZoneHeader),
Ext2GlobalData.IrpContextZone,
SizeOfIrpContextZone))) {
// failed the initialization, leave ...
- try_return(RC);
+ try_return();
}
try_exit: NOTHING;
if (ReadLength == 0)
{
// a 0 byte read can be immediately succeeded
- try_return(RC);
+ try_return();
}
// Is this a read of the volume itself ?
{
RC = STATUS_END_OF_FILE;
NumberBytesRead = 0;
- try_return( RC );
+ try_return();
}
}
if( PagingIo || NonBufferedIo )
PtrIrpContext, PtrIrp, PtrVCB,
ByteOffset, ReadLength, SynchronousIo);
- try_return(RC);
+ try_return();
}
else
{
RC = STATUS_UNSUCCESSFUL;
NumberBytesRead = 0;
- try_return( RC );
+ try_return();
}
else
{
PtrBCB = NULL;
RC = STATUS_SUCCESS;
NumberBytesRead = ReadLength;
- try_return(RC);
+ try_return();
}
}
if ( ( PtrFCB->FCBFlags & EXT2_FCB_DIRECTORY ) && !PagingIo )
{
RC = STATUS_INVALID_DEVICE_REQUEST;
- try_return(RC);
+ try_return();
}
PtrReqdFCB = &(PtrFCB->NTRequiredFCB);
// If the flush failed, return error to the caller
if (!NT_SUCCESS(RC = PtrIrp->IoStatus.Status))
{
- try_return(RC);
+ try_return();
}
}
}
NumberBytesRead = PtrIrp->IoStatus.Information;
RC = PtrIrp->IoStatus.Status;
- try_return(RC);
+ try_return();
}
// This is a regular run-of-the-mill cached I/O request. Let the
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
}
// We have the data
RC = PtrIrp->IoStatus.Status;
NumberBytesRead = PtrIrp->IoStatus.Information;
- try_return(RC);
+ try_return();
}
else // NonBuffered or Paged IO
{
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
}
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
{
CompleteIrp = FALSE;
}
- try_return( RC );
+ try_return();
}
try_exit: NOTHING;
if (!(PtrMdl = IoAllocateMdl(PtrIrp->UserBuffer, Length, FALSE, FALSE, PtrIrp)))
{
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return(RC);
+ try_return();
}
// Probe and lock the pages described by the MDL
if (WriteLength == 0)
{
// a 0 byte write can be immediately succeeded
- try_return(RC);
+ try_return();
}
// Is this a write of the volume itself ?
//
RC = STATUS_END_OF_FILE;
NumberBytesWritten = 0;
- try_return( RC );
+ try_return();
}
}
// Lock the callers buffer
if (!NT_SUCCESS(RC = Ext2LockCallersBuffer(PtrIrp, TRUE, WriteLength)))
{
- try_return(RC);
+ try_return();
}
// Forward the request to the lower level driver
PtrIrpContext, PtrIrp, PtrVCB,
ByteOffset, WriteLength, SynchronousIo );
- try_return(RC);
+ try_return();
}
else
{
// Go ahead and complete the IRP...
}
- try_return(RC);
+ try_return();
}
// Nope... User initiated directory writes are not allowed!
// Fail this request...
RC = STATUS_INVALID_DEVICE_REQUEST;
- try_return(RC);
+ try_return();
}
}
// If the flush failed, return error to the caller
if (!NT_SUCCESS(RC = PtrIrp->IoStatus.Status))
{
- try_return(RC);
+ try_return();
}
// Attempt the purge and ignore the return code
// Page request for writing outside the file...
// No op this IRP by completing it...
//
- try_return(RC);
+ try_return();
}
if( ByteOffset.QuadPart + WriteLength
> PtrReqdFCB->CommonFCBHeader.AllocationSize.QuadPart )
NumberBytesWritten = PtrIrp->IoStatus.Information;
RC = PtrIrp->IoStatus.Status;
- try_return(RC);
+ try_return();
}
// This is a regular run-of-the-mill cached I/O request. Let the
Ext2DeallocateUnicodeString( &ErrorMessage );
RC = STATUS_INSUFFICIENT_RESOURCES;
- try_return ( RC );
+ try_return();
}
if( ( ByteOffset.QuadPart + WriteLength ) > DirectBlockSize &&
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data", 0);
}
}
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
// Mark Irp Pending ...
IoMarkIrpPending( PtrIrp );
RC = STATUS_PENDING;
- try_return(RC);
+ try_return();
DebugTrace(DEBUG_TRACE_ASYNC, "Cache read failiure while reading in volume meta data - Retrying", 0);
}
{
CompleteIrp = FALSE;
}
- try_return( RC );
+ try_return();
}
try_exit: NOTHING;