void rnd_reseed_now()
{
seed_data seed;
KeQuerySystemTime(&seed.seed20);
seed.seed1 = PsGetCurrentProcess();
seed.seed2 = PsGetCurrentProcessId();
seed.seed3 = KeGetCurrentThread();
seed.seed4 = PsGetCurrentThreadId();
seed.seed5 = KeGetCurrentProcessorNumber();
seed.seed6 = KeQueryInterruptTime();
seed.seed10 = KeQueryPerformanceCounter(NULL);
seed.seed11 = __rdtsc();
seed.seed12 = ExGetPreviousMode();
seed.seed14 = IoGetTopLevelIrp();
seed.seed15 = MmQuerySystemSize();
seed.seed24 = KeGetCurrentIrql();
if (KeGetCurrentIrql() == PASSIVE_LEVEL) {
seed.seed7 = KeQueryPriorityThread(seed.seed3);
seed.seed17 = ExUuidCreate(&seed.seed18);
seed.seed19 = RtlRandom(&seed.seed8);
}
if (KeGetCurrentIrql() <= APC_LEVEL) {
seed.seed13 = IoGetInitialStack();
seed.seed16 = PsGetProcessExitTime();
IoGetStackLimits(&seed.seed22, &seed.seed23);
}
KeQueryTickCount(&seed.seed21);
rnd_add_buff(&seed, sizeof(seed));
/* Prevent leaks */
zeroauto(&seed, sizeof(seed));
}
NTSTATUS
FatFsdCleanup (
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the FSD part of closing down a handle to a
file object.
Arguments:
VolumeDeviceObject - Supplies the volume device object where the
file being Cleanup 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();
#if __NDAS_FAT__
if ((PVOID)FatControlDeviceObject == VolumeDeviceObject) {
Status = Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return Status;
}
#endif
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS
//
if ( FatDeviceIsFatFsdo( VolumeDeviceObject)) {
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
return STATUS_SUCCESS;
}
DebugTrace(+1, Dbg, "FatFsdCleanup\n", 0);
//
// Call the common Cleanup routine, with blocking allowed.
//
FsRtlEnterFileSystem();
TopLevel = FatIsIrpTopLevel( Irp );
#if (__NDAS_FAT_PRIMARY__ || __NDAS_FAT_SECONDARY__)
do {
try {
if (IrpContext == NULL) {
IrpContext = FatCreateIrpContext( Irp, TRUE );
IrpContext->TopLevel = TopLevel;
#if __NDAS_FAT_PRIMARY__
{
ULONG_PTR stackBottom;
ULONG_PTR stackTop;
BOOLEAN validPrimaryRequest = FALSE;
PPRIMARY_REQUEST_INFO primaryRequestInfo;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
primaryRequestInfo = (PPRIMARY_REQUEST_INFO)IoGetTopLevelIrp();
IoGetStackLimits( &stackTop, &stackBottom );
if ( (ULONG_PTR)primaryRequestInfo <= stackBottom - sizeof(PRIMARY_REQUEST_INFO) &&
(ULONG_PTR) primaryRequestInfo >= stackTop &&
(!FlagOn( (ULONG_PTR) primaryRequestInfo, 0x3 )) &&
primaryRequestInfo->PrimaryTag == 0xe2027482) {
validPrimaryRequest = TRUE;
}
if (validPrimaryRequest) {
//ASSERT( FatIsTopLevelRequest(IrpContext) );
IoSetTopLevelIrp( NULL );
TopLevel = FatIsIrpTopLevel( Irp );
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL );
if (IsListEmpty(&VolumeDeviceObject->PrimarySessionQueue)) {
NDAS_ASSERT( FALSE );
}
IrpContext->PrimaryRequestInfo = *primaryRequestInfo;
DebugTrace2( 0, Dbg, ("primaryRequestInfo = %p\n", primaryRequestInfo) );
}
}
#endif
}
#if __NDAS_FAT_SECONDARY__
if (IS_SECONDARY_FILEOBJECT(IoGetCurrentIrpStackLocation(Irp)->FileObject)) {
BOOLEAN secondaryResourceAcquired = FALSE;
BOOLEAN secondaryRecoveryResourceAcquired = FALSE;
ASSERT( FatIsTopLevelRequest(IrpContext) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
Status = STATUS_SUCCESS;
while (TRUE) {
ASSERT( secondaryRecoveryResourceAcquired == FALSE );
ASSERT( secondaryResourceAcquired == FALSE );
if (FlagOn(VolumeDeviceObject->Secondary->Flags, SECONDARY_FLAG_RECONNECTING)) {
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
Status = FatFsdPostRequest( IrpContext, Irp );
break;
}
}
if (FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
Status = FatFsdPostRequest( IrpContext, Irp );
break;
}
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->RecoveryResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (!FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
try {
SecondaryRecoverySessionStart( VolumeDeviceObject->Secondary, IrpContext );
} finally {
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->Resource );
secondaryResourceAcquired = FALSE;
SecondaryReleaseResourceLite( IrpContext, &VolumeDeviceObject->RecoveryResource );
secondaryRecoveryResourceAcquired = FALSE;
}
continue;
}
secondaryResourceAcquired
= SecondaryAcquireResourceSharedLite( IrpContext,
&VolumeDeviceObject->Resource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (secondaryResourceAcquired == FALSE) {
ASSERT( FlagOn(VolumeDeviceObject->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ||
FlagOn(VolumeDeviceObject->Secondary->Flags, SECONDARY_FLAG_RECONNECTING) );
continue;
}
break;
}
if (Status == STATUS_SUCCESS) {
try {
Status = FatCommonCleanup( IrpContext, Irp );
} finally {
ASSERT( ExIsResourceAcquiredSharedLite(&VolumeDeviceObject->Resource) );
SecondaryReleaseResourceLite( NULL, &VolumeDeviceObject->Resource );
}
}
} else
Status = FatCommonCleanup( IrpContext, Irp );
#else
Status = FatCommonCleanup( IrpContext, Irp );
#endif
} except(FatExceptionFilter( IrpContext, 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, GetExceptionCode() );
}
} while (Status == STATUS_CANT_WAIT);
VOID
CdSetThreadContext (
IN PIRP_CONTEXT IrpContext,
IN PTHREAD_CONTEXT ThreadContext
)
/*++
Routine Description:
This routine is called at each Fsd/Fsp entry point set up the IrpContext
and thread local storage to track top level requests. If there is
not a Cdfs context in the thread local storage then we use the input one.
Otherwise we use the one already there. This routine also updates the
IrpContext based on the state of the top-level context.
If the TOP_LEVEL flag in the IrpContext is already set when we are called
then we force this request to appear top level.
Arguments:
ThreadContext - Address on stack for local storage if not already present.
ForceTopLevel - We force this request to appear top level regardless of
any previous stack value.
Return Value:
None
--*/
{
PTHREAD_CONTEXT CurrentThreadContext;
ULONG_PTR StackTop;
ULONG_PTR StackBottom;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
//
// Get the current top-level irp out of the thread storage.
// If NULL then this is the top-level request.
//
CurrentThreadContext = (PTHREAD_CONTEXT) IoGetTopLevelIrp();
if (CurrentThreadContext == NULL) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL );
}
//
// Initialize the input context unless we are using the current
// thread context block. We use the new block if our caller
// specified this or the existing block is invalid.
//
// The following must be true for the current to be a valid Cdfs context.
//
// Structure must lie within current stack.
// Address must be ULONG aligned.
// Cdfs signature must be present.
//
// If this is not a valid Cdfs context then use the input thread
// context and store it in the top level context.
//
IoGetStackLimits( &StackTop, &StackBottom);
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) ||
(((ULONG_PTR) CurrentThreadContext > StackBottom - sizeof( THREAD_CONTEXT )) ||
((ULONG_PTR) CurrentThreadContext <= StackTop) ||
FlagOn( (ULONG_PTR) CurrentThreadContext, 0x3 ) ||
(CurrentThreadContext->Cdfs != 0x53464443))) {
ThreadContext->Cdfs = 0x53464443;
ThreadContext->SavedTopLevelIrp = (PIRP) CurrentThreadContext;
ThreadContext->TopLevelIrpContext = IrpContext;
IoSetTopLevelIrp( (PIRP) ThreadContext );
IrpContext->TopLevel = IrpContext;
IrpContext->ThreadContext = ThreadContext;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS );
//
// Otherwise use the IrpContext in the thread context.
//
} else {
IrpContext->TopLevel = CurrentThreadContext->TopLevelIrpContext;
}
return;
}
