VOID
PrimarySession_CancelStopping (
IN PPRIMARY_SESSION PrimarySession
)
{
PPRIMARY_SESSION_REQUEST primarySessionRequest;
NTSTATUS ntStatus;
LARGE_INTEGER timeOut;
PrimarySession_Reference( PrimarySession );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("PrimarySession_CancelStopping: PrimarySession = %p\n", PrimarySession) );
ASSERT( PrimarySession->ThreadObject != NULL );
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (!FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING)) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
PrimarySession_Dereference( PrimarySession );
return;
}
primarySessionRequest = AllocPrimarySessionRequest( TRUE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_CANCEL_STOPPING;
QueueingPrimarySessionRequest( PrimarySession, primarySessionRequest, TRUE );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
timeOut.QuadPart = -LFS_TIME_OUT;
ntStatus = KeWaitForSingleObject( &primarySessionRequest->CompleteEvent,
Executive,
KernelMode,
FALSE,
&timeOut );
ASSERT( ntStatus == STATUS_SUCCESS );
KeClearEvent( &primarySessionRequest->CompleteEvent );
DereferencePrimarySessionRequest( primarySessionRequest );
if (ntStatus == STATUS_SUCCESS) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySession_CancelStopping: thread close files\n") );
} else {
ASSERT( LFS_BUG );
PrimarySession_Dereference( PrimarySession );
return;
}
PrimarySession_Dereference( PrimarySession );
return;
}
VOID
PrimarySession_Disconnect (
IN PPRIMARY_SESSION PrimarySession
)
{
PPRIMARY_SESSION_REQUEST primarySessionRequest;
NTSTATUS ntStatus;
LARGE_INTEGER timeOut;
PrimarySession_Reference( PrimarySession );
DebugTrace( 0, Dbg2,
("PrimarySession_Disconnect: PrimarySession = %p\n", PrimarySession) );
ASSERT( PrimarySession->ThreadObject != NULL );
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (!FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING)) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
PrimarySession_Dereference( PrimarySession );
return;
}
primarySessionRequest = AllocPrimarySessionRequest( TRUE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_DISCONNECT_AND_TERMINATE;
QueueingPrimarySessionRequest( PrimarySession, primarySessionRequest, TRUE );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
timeOut.QuadPart = -NDASNTFS_TIME_OUT;
ntStatus = KeWaitForSingleObject( &primarySessionRequest->CompleteEvent,
Executive,
KernelMode,
FALSE,
&timeOut );
ASSERT( ntStatus == STATUS_SUCCESS );
KeClearEvent( &primarySessionRequest->CompleteEvent );
DereferencePrimarySessionRequest( primarySessionRequest );
if (ntStatus == STATUS_SUCCESS) {
DebugTrace( 0, Dbg, ("PrimarySession_CloseFiles: thread close files\n") );
} else {
NDAS_BUGON( FALSE );
PrimarySession_Dereference( PrimarySession );
return;
}
PrimarySession_Dereference( PrimarySession );
return;
}
BOOLEAN
xixfs_IHaveLotLock(
IN uint8 * HostMac,
IN uint64 LotNumber,
IN uint8 * VolumeId
)
{
NTSTATUS RC = STATUS_UNSUCCESSFUL;
PXIXFSDG_PKT pPacket = NULL;
PXIXFS_LOCK_BROADCAST pPacketData = NULL;
uint8 DstAddress[6] ={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
//PAGED_CODE();
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Enter xixfs_IHaveLotLock \n"));
// Changed by ILGU HONG
// chesung suggest
/*
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, DstAddress, XIXFS_TYPE_LOCK_BROADCAST))
{
return FALSE;
}
*/
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, NULL, XIXFS_TYPE_LOCK_BROADCAST))
{
return FALSE;
}
pPacketData = &(pPacket->RawDataDG.LockBroadcast);
// Changed by ILGU HONG
RtlCopyMemory(pPacketData->VolumeId, VolumeId, 16);
pPacketData->LotNumber = HTONLL(LotNumber);
pPacket->TimeOut.QuadPart = xixcore_GetCurrentTime64() + DEFAULT_REQUEST_MAX_TIMEOUT;
ExAcquireFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
InsertTailList(&(XiGlobalData.XifsComCtx.SendPktList),
&(pPacket->PktListEntry) );
ExReleaseFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
KeSetEvent(&(XiGlobalData.XifsComCtx.CliSendDataEvent),0, FALSE);
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Exit xixfs_IHaveLotLock \n"));
return TRUE;
}
VOID
PrimarySessionThreadProc (
IN PPRIMARY_SESSION PrimarySession
)
{
BOOLEAN primarySessionTerminate = FALSE;
NTSTATUS status;
UINT16 slotIndex;
PLIST_ENTRY primarySessionRequestEntry;
ASSERT( SESSION_SLOT_COUNT == 1 );
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO, ("PrimarySessionThreadProc: Start PrimarySession = %p\n", PrimarySession) );
PrimarySession_Reference( PrimarySession );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_INITIALIZING );
InitializeListHead( &PrimarySession->Thread.OpenedFileQueue );
KeInitializeSpinLock( &PrimarySession->Thread.OpenedFileQSpinLock );
KeInitializeEvent( &PrimarySession->Thread.WorkCompletionEvent, NotificationEvent, FALSE );
PrimarySession->SessionContext.SessionSlotCount = SESSION_SLOT_COUNT;
for (slotIndex = 0; slotIndex < PrimarySession->SessionContext.SessionSlotCount; slotIndex ++) {
PrimarySession->Thread.SessionSlot[slotIndex].State = SLOT_WAIT;
PrimarySession->Thread.IdleSlotCount ++;
}
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_INITIALIZING );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_START );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_CONNECTED );
KeSetEvent( &PrimarySession->ReadyEvent, IO_DISK_INCREMENT, FALSE );
status = LpxTdiV2Recv( PrimarySession->ConnectionFileObject,
(PUCHAR)&PrimarySession->Thread.NdfsRequestHeader,
sizeof(NDFS_REQUEST_HEADER),
0,
NULL,
&PrimarySession->ReceiveOverlapped,
0,
NULL );
if (!NT_SUCCESS(status)) {
LpxTdiV2CompleteRequest( &PrimarySession->ReceiveOverlapped, 0 );
ASSERT( LFS_BUG );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
primarySessionTerminate = TRUE;
}
while (primarySessionTerminate == FALSE) {
PKEVENT events[3];
LONG eventCount;
NTSTATUS eventStatus;
LARGE_INTEGER timeOut;
NDAS_ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
eventCount = 0;
events[eventCount++] = &PrimarySession->RequestEvent;
if (!FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING)) {
events[eventCount++] = &PrimarySession->Thread.WorkCompletionEvent;
if (FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN)) {
if (PrimarySession->Thread.IdleSlotCount == PrimarySession->SessionContext.SessionSlotCount) {
CloseOpenFiles( PrimarySession, TRUE );
KeSetEvent( &PrimarySession->Thread.ShutdownPrimarySessionRequest->CompleteEvent,
IO_DISK_INCREMENT,
FALSE );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN_WAIT );
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN );
}
}
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN_WAIT)) {
if (LpxTdiV2IsRequestPending(&PrimarySession->ReceiveOverlapped, 0)) {
ASSERT( PrimarySession->Thread.IdleSlotCount != 0 );
events[eventCount++] = &PrimarySession->ReceiveOverlapped.Request[0].CompletionEvent;
}
}
ASSERT( eventCount <= THREAD_WAIT_OBJECTS );
}
timeOut.QuadPart = -5*NANO100_PER_SEC;
eventStatus = KeWaitForMultipleObjects( eventCount,
events,
WaitAny,
Executive,
KernelMode,
TRUE,
&timeOut,
NULL );
if (!FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING)) {
if (eventStatus == STATUS_TIMEOUT || eventStatus == 2) {
if (PrimarySession->Thread.SessionState == SESSION_TREE_CONNECT) {
ASSERT( PrimarySession->NetdiskPartition );
if (!(PrimarySession->NetdiskPartition->NetdiskVolume[NETDISK_PRIMARY].VolumeState == VolumeMounted ||
PrimarySession->NetdiskPartition->NetdiskVolume[NETDISK_SECONDARY2PRIMARY].VolumeState == VolumeMounted)) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("Netdisk Volume is unmounted\n") );
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN_WAIT))
primarySessionTerminate = TRUE;
continue;
}
}
}
}
if (eventStatus == STATUS_TIMEOUT) {
continue;
}
if (!NT_SUCCESS(eventStatus) || eventStatus >= eventCount) {
NDAS_ASSERT( FALSE );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
primarySessionTerminate = TRUE;
continue;
}
if (eventStatus == 0) {
KeClearEvent( events[eventStatus] );
while (primarySessionRequestEntry = ExInterlockedRemoveHeadList( &PrimarySession->RequestQueue,
&PrimarySession->RequestQSpinLock)) {
PPRIMARY_SESSION_REQUEST primarySessionRequest;
primarySessionRequest = CONTAINING_RECORD( primarySessionRequestEntry,
PRIMARY_SESSION_REQUEST,
ListEntry );
if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_DISCONNECT ||
primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_DISCONNECT_AND_TERMINATE) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
((primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_DISCONNECT) ?
("PRIMARY_SESSION_REQ_DISCONNECT: DisconnectFromSecondary\n") :
("PRIMARY_SESSION_REQ_DISCONNECT_AND_TERMINATE: DisconnectFromSecondary\n")) );
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED)) {
DisconnectFromSecondary( PrimarySession );
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_CONNECTED );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
}
if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_DISCONNECT_AND_TERMINATE)
primarySessionTerminate = TRUE;
if (primarySessionRequest->Synchronous == TRUE)
KeSetEvent( &primarySessionRequest->CompleteEvent, IO_DISK_INCREMENT, FALSE );
else
DereferencePrimarySessionRequest( primarySessionRequest );
} else if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_DOWN) {
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_STOPED );
primarySessionTerminate = TRUE;
if (primarySessionRequest->Synchronous == TRUE)
KeSetEvent( &primarySessionRequest->CompleteEvent, IO_DISK_INCREMENT, FALSE );
else
DereferencePrimarySessionRequest( primarySessionRequest );
} else if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_SHUTDOWN) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySessionThreadProc: PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN\n") );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN );
ASSERT (primarySessionRequest->Synchronous == TRUE);
PrimarySession->Thread.ShutdownPrimarySessionRequest = primarySessionRequest;
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED)) {
DisconnectFromSecondary( PrimarySession );
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_CONNECTED );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
}
} else if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_STOPPING) {
SetFlag( PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING );
if (PrimarySession->IsLocalAddress == FALSE) {
#if __NDAS_FS_PRIMARY_DISMOUNT__
CloseOpenFiles( PrimarySession, FALSE );
#endif
}
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (primarySessionRequest->Synchronous == TRUE) {
primarySessionRequest->ExecuteStatus = STATUS_SUCCESS;
KeSetEvent( &primarySessionRequest->CompleteEvent, IO_DISK_INCREMENT, FALSE );
} else {
DereferencePrimarySessionRequest( primarySessionRequest );
}
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
} else if (primarySessionRequest->RequestType == PRIMARY_SESSION_REQ_CANCEL_STOPPING) {
ClearFlag( PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING );
if (primarySessionRequest->Synchronous == TRUE)
KeSetEvent( &primarySessionRequest->CompleteEvent, IO_DISK_INCREMENT, FALSE );
else
DereferencePrimarySessionRequest( primarySessionRequest );
} else {
ASSERT( LFS_BUG );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
}
}
continue;
} else if (eventStatus == 1) {
KeClearEvent( events[eventStatus] );
while (TRUE) {
for (slotIndex = 0; slotIndex < PrimarySession->SessionContext.SessionSlotCount; slotIndex ++) {
if (PrimarySession->Thread.SessionSlot[slotIndex].State == SLOT_FINISH)
break;
}
if (slotIndex == PrimarySession->SessionContext.SessionSlotCount)
break;
PrimarySession->Thread.SessionSlot[slotIndex].State = SLOT_WAIT;
PrimarySession->Thread.IdleSlotCount ++;
if (PrimarySession->Thread.SessionSlot[slotIndex].Status == STATUS_SUCCESS) {
PNDFS_REPLY_HEADER ndfsReplyHeader;
ndfsReplyHeader = (PNDFS_REPLY_HEADER)PrimarySession->Thread.SessionSlot[slotIndex].ReplyMessageBuffer;
PrimarySession->Thread.SessionSlot[slotIndex].Status
= SendNdfsWinxpMessage( PrimarySession,
ndfsReplyHeader,
PrimarySession->Thread.SessionSlot[slotIndex].NdfsWinxpReplyHeader,
PrimarySession->Thread.SessionSlot[slotIndex].ReplyDataSize,
slotIndex );
}
if (PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool) {
ExFreePool(PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool);
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool = NULL;
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePoolLength = 0;
}
if (PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool) {
ExFreePool(PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool);
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool = NULL;
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePoolLength = 0;
}
if (!(PrimarySession->Thread.SessionSlot[slotIndex].Status == STATUS_SUCCESS ||
PrimarySession->Thread.SessionSlot[slotIndex].Status == STATUS_PENDING)) {
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
}
primarySessionTerminate = TRUE;
break;
}
if (PrimarySession->Thread.SessionState == SESSION_CLOSED) {
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
}
primarySessionTerminate = TRUE;
break;
}
if (PrimarySession->Thread.SessionSlot[slotIndex].Status == STATUS_SUCCESS) {
if (!LpxTdiV2IsRequestPending(&PrimarySession->ReceiveOverlapped, 0)) {
status = LpxTdiV2Recv( PrimarySession->ConnectionFileObject,
(PUCHAR)&PrimarySession->Thread.NdfsRequestHeader,
sizeof(NDFS_REQUEST_HEADER),
0,
NULL,
&PrimarySession->ReceiveOverlapped,
0,
NULL );
if (!NT_SUCCESS(status)) {
ASSERT( LFS_BUG );
LpxTdiV2CompleteRequest( &PrimarySession->ReceiveOverlapped, 0 );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
primarySessionTerminate = TRUE;
break;
}
}
}
}
continue;
} else {
NDAS_ASSERT( eventStatus == 2 ); // Receive Event
ASSERT( !FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN_WAIT) &&
!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_SHUTDOWN) );
LpxTdiV2CompleteRequest( &PrimarySession->ReceiveOverlapped, 0 );
if (PrimarySession->ReceiveOverlapped.Request[0].IoStatusBlock.Status != STATUS_SUCCESS ||
PrimarySession->ReceiveOverlapped.Request[0].IoStatusBlock.Information != sizeof(NDFS_REQUEST_HEADER)) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE,
("DispatchRequest: Disconnected, PrimarySession = Data received:%d\n",
PrimarySession->ReceiveOverlapped.Request[0].IoStatusBlock.Information) );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
primarySessionTerminate = TRUE;
continue;
}
#if 0
if (PrimarySession->NetdiskPartition) {
PENABLED_NETDISK EnabledNetdisk = PrimarySession->NetdiskPartition->EnabledNetdisk;
ASSERT( EnabledNetdisk );
if (NetdiskManager_IsStoppedNetdisk(GlobalLfs.NetdiskManager, EnabledNetdisk)) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_ERROR,
("PrimarySessionThread: %p Netdisk is stopped\n", PrimarySession) );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_ERROR, ("DispatchWinXpRequest: Netdisk is stopped.\n") );
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED)) {
// no other way to notify secondary about unmount without break backward compatability.
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO, ("IsStoppedNetdisk: DisconnectFromSecondary\n") );
DisconnectFromSecondary( PrimarySession );
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_CONNECTED );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
}
primarySessionTerminate = TRUE;
continue;
}
}
#endif
status = DispatchRequest( PrimarySession );
if (!(status == STATUS_SUCCESS || status == STATUS_PENDING)) {
primarySessionTerminate = TRUE;
continue;
}
if (PrimarySession->Thread.SessionState == SESSION_CLOSED) {
primarySessionTerminate = TRUE;
continue;
}
if (status == STATUS_SUCCESS) {
if (!LpxTdiV2IsRequestPending(&PrimarySession->ReceiveOverlapped, 0)) {
status = LpxTdiV2Recv( PrimarySession->ConnectionFileObject,
(PUCHAR)&PrimarySession->Thread.NdfsRequestHeader,
sizeof(NDFS_REQUEST_HEADER),
0,
NULL,
&PrimarySession->ReceiveOverlapped,
0,
NULL );
if (!NT_SUCCESS(status)) {
LpxTdiV2CompleteRequest( &PrimarySession->ReceiveOverlapped, 0 );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
primarySessionTerminate = TRUE;
}
}
}
continue;
}
}
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_STOPED );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
while (TRUE) {
LARGE_INTEGER timeOut;
NTSTATUS eventStatus;
if (PrimarySession->Thread.IdleSlotCount == PrimarySession->SessionContext.SessionSlotCount)
break;
timeOut.QuadPart = -10*NANO100_PER_SEC;
eventStatus = KeWaitForSingleObject( &PrimarySession->Thread.WorkCompletionEvent,
Executive,
KernelMode,
FALSE,
&timeOut );
KeClearEvent( &PrimarySession->Thread.WorkCompletionEvent );
if (eventStatus == STATUS_TIMEOUT) {
ASSERT( LFS_UNEXPECTED );
continue;
}
while (TRUE) {
for (slotIndex = 0; slotIndex < PrimarySession->SessionContext.SessionSlotCount; slotIndex++) {
if (PrimarySession->Thread.SessionSlot[slotIndex].State == SLOT_FINISH)
break;
}
if (slotIndex == PrimarySession->SessionContext.SessionSlotCount)
break;
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySessionThreadProc: eventStatus = %d\n", eventStatus) );
PrimarySession->Thread.SessionSlot[slotIndex].State = SLOT_WAIT;
PrimarySession->Thread.IdleSlotCount++;
if (PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool );
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpRequestMessagePool = NULL;
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePoolLength = 0;
}
if (PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool );
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePool = NULL;
PrimarySession->Thread.SessionSlot[slotIndex].ExtendWinxpReplyMessagePoolLength = 0;
}
}
}
if (!FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED)) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO, ("PsTerminateSystemThread: DisconnectFromSecondary\n") );
DisconnectFromSecondary( PrimarySession );
ClearFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_CONNECTED );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
}
CloseOpenFiles( PrimarySession, TRUE );
while (primarySessionRequestEntry = ExInterlockedRemoveHeadList( &PrimarySession->RequestQueue,
&PrimarySession->RequestQSpinLock)) {
PPRIMARY_SESSION_REQUEST primarySessionRequest;
primarySessionRequest = CONTAINING_RECORD( primarySessionRequestEntry,
PRIMARY_SESSION_REQUEST,
ListEntry );
if (primarySessionRequest->Synchronous == TRUE)
KeSetEvent( &primarySessionRequest->CompleteEvent, IO_DISK_INCREMENT, FALSE );
else
DereferencePrimarySessionRequest( primarySessionRequest );
}
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
}
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("PrimarySessionThreadProc: PsTerminateSystemThread PrimarySession = %p\n",
PrimarySession) );
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_TERMINATED );
PrimarySession_Dereference ( PrimarySession );
NDAS_ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
PsTerminateSystemThread( STATUS_SUCCESS );
}
NTSTATUS
Bus_IoCtl (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Handle user mode PlugIn, UnPlug and device Eject requests.
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
PIO_STACK_LOCATION irpStack;
NTSTATUS status;
ULONG inlen, outlen;
PFDO_DEVICE_DATA fdoData;
PVOID buffer;
PAGED_CODE ();
//
// It is not safe to call IOCTL in raised IRQL.
//
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
fdoData = (PFDO_DEVICE_DATA) DeviceObject->DeviceExtension;
//
// We only take Device Control requests for the FDO.
// That is the bus itself.
//
if (!fdoData->IsFDO) {
//
// These commands are only allowed to go to the FDO.
//
status = STATUS_INVALID_DEVICE_REQUEST;
Irp->IoStatus.Status = status;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
return status;
}
//
// Check to see whether the bus is removed
//
if (fdoData->DevicePnPState == Deleted) {
Irp->IoStatus.Status = status = STATUS_NO_SUCH_DEVICE;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
return status;
}
Bus_IncIoCount (fdoData);
irpStack = IoGetCurrentIrpStackLocation (Irp);
buffer = Irp->AssociatedIrp.SystemBuffer;
inlen = irpStack->Parameters.DeviceIoControl.InputBufferLength;
outlen = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
status = STATUS_INVALID_PARAMETER;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("%d called\n", irpStack->Parameters.DeviceIoControl.IoControlCode));
switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_NDASBUS_ADD_TARGET:
{
PPDO_DEVICE_DATA pdoData;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("IOCTL_NDASBUS_ADD_TARGET inlen %d, outlen %d, sizeof(NDASBUS_ADD_TARGET_DATA) %d\n", inlen, outlen, sizeof(NDASBUS_ADD_TARGET_DATA)));
if ((inlen == outlen) &&
(sizeof(NDASBUS_ADD_TARGET_DATA) <= inlen))
{
ULONG ulSize;
PNDASBUS_ADD_TARGET_DATA addTargetData = buffer;
BOOLEAN accepted;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_ADD_TARGET called\n"));
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("IOCTL_NDASBUS_ADD_TARGET Target Type %d\n", addTargetData->ucTargetType));
status = STATUS_SUCCESS;
//
// Check structure size
//
if(VerifySizeOfAddTargetData(addTargetData, &ulSize) == 0) {
status = STATUS_INVALID_PARAMETER;
break;
}
if(ulSize != inlen)
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("ADD_TARGET: Size mismatch. Req %d, in %d\n", ulSize, inlen));
status = STATUS_UNSUCCESSFUL;
break;
}
//
// Check to see if acceptable structure.
//
accepted = TRUE;
switch(addTargetData->ucTargetType)
{
case NDASSCSI_TYPE_DISK_NORMAL:
case NDASSCSI_TYPE_DVD:
case NDASSCSI_TYPE_VDVD:
case NDASSCSI_TYPE_MO:
if(addTargetData->ulNumberOfUnitDiskList != 1)
accepted = FALSE;
break;
case NDASSCSI_TYPE_DISK_MIRROR:
if(2 != addTargetData->ulNumberOfUnitDiskList)
accepted = FALSE;
break;
case NDASSCSI_TYPE_DISK_AGGREGATION:
if (addTargetData->ulNumberOfUnitDiskList < 2 ||
addTargetData->ulNumberOfUnitDiskList > MAX_NR_UNITDISK_FOR_AGGR)
accepted = FALSE;
break;
case NDASSCSI_TYPE_DISK_RAID0:
switch(addTargetData->ulNumberOfUnitDiskList)
{
case 2:
case 4:
case 8:
break;
default: // do not accept
accepted = FALSE;
break;
}
break;
case NDASSCSI_TYPE_DISK_RAID1R3:
{
ULONG ulDiskCount;
ulDiskCount = addTargetData->ulNumberOfUnitDiskList -
addTargetData->RAID_Info.nSpareDisk;
if (2 != ulDiskCount)
accepted = FALSE;
}
break;
case NDASSCSI_TYPE_DISK_RAID4R3:
{
ULONG ulDiskCount;
ulDiskCount = addTargetData->ulNumberOfUnitDiskList -
addTargetData->RAID_Info.nSpareDisk;
switch(ulDiskCount)
{
case 3: // 2 + 1
case 5: // 4 + 1
case 9: // 8 + 1
break;
default: // do not accept
accepted = FALSE;
break;
}
break;
}
default:
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("ADD_TARGET: Bad Disk Type.\n"));
accepted = FALSE;
break;
}
if(accepted == FALSE) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("ADD_TARGET: Invaild type.\n"));
status = STATUS_UNSUCCESSFUL;
break;
}
#if DBG
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_TRY_TO_ADDTARGET,
IOCTL_NDASBUS_ADD_TARGET,
addTargetData->ulSlotNo);
#endif
// Find Pdo Data...
pdoData = LookupPdoData(fdoData, addTargetData->ulSlotNo);
if(pdoData == NULL)
{
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("no pdo\n"));
status = STATUS_UNSUCCESSFUL;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_ADD_TARGET,
addTargetData->ulSlotNo);
break;
}
//
// Save the add target information to the PDO extension
//
pdoData->LanscsiAdapterPDO.AddDevInfo = ExAllocatePoolWithTag(NonPagedPool, inlen, BUSENUM_POOL_TAG);
if(pdoData->LanscsiAdapterPDO.AddDevInfo == NULL)
{
Irp->IoStatus.Information = 0;
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
else
{
RtlCopyMemory(pdoData->LanscsiAdapterPDO.AddDevInfo, addTargetData, inlen);
status = STATUS_SUCCESS;
}
pdoData->LanscsiAdapterPDO.AddDevInfoLength = inlen;
//
// Init PDO status
//
pdoData->LanscsiAdapterPDO.LastAdapterStatus = NDASSCSI_ADAPTERINFO_STATUS_INIT;
pdoData->LanscsiAdapterPDO.DeviceMode = addTargetData->DeviceMode;
//
// Notify to NDASSCSI
//
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("IOCTL_NDASBUS_ADD_TARGET SetEvent AddTargetEvent!\n"));
KeSetEvent(&pdoData->LanscsiAdapterPDO.AddTargetEvent, IO_NO_INCREMENT, FALSE);
//
// Register Target
//
if(pdoData->Persistent) {
status = LSBus_RegisterTarget(fdoData, addTargetData);
if(!NT_SUCCESS(status)) {
ExFreePoolWithTag(pdoData->LanscsiAdapterPDO.AddDevInfo, BUSENUM_POOL_TAG);
pdoData->LanscsiAdapterPDO.AddDevInfo = NULL;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("ADD_TARGET: LSBus_RegisterTarget() failed. STATUS=%08lx\n", status));
status = STATUS_INTERNAL_DB_ERROR;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_REGISTER_TARGET_FAIL,
IOCTL_NDASBUS_ADD_TARGET,
addTargetData->ulSlotNo);
} else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_INFO, ("ADD_TARGET: Successfully registered.\n"));
}
}
ObDereferenceObject(pdoData->Self);
Irp->IoStatus.Information = outlen;
}
else
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_ADD_TARGET length mismatch!!!"
" inlen %d, outlen %d, sizeof(NDASBUS_ADD_TARGET_DATA) %d\n",
inlen, outlen, sizeof(NDASBUS_ADD_TARGET_DATA)));
}
}
break;
case IOCTL_NDASBUS_REMOVE_TARGET:
{
PPDO_DEVICE_DATA pdoData;
PNDASBUS_REMOVE_TARGET_DATA removeTarget;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_REMOVE_TARGET called\n"));
if (sizeof (NDASBUS_REMOVE_TARGET_DATA) != inlen)
break;
removeTarget = (PNDASBUS_REMOVE_TARGET_DATA)buffer;
pdoData = LookupPdoData(fdoData, removeTarget->ulSlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("no pdo\n"));
status = STATUS_UNSUCCESSFUL;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_REMOVE_TARGET,
removeTarget->ulSlotNo);
break;
}
//
// redirect to the NDAS SCSI Device
//
status = LSBus_IoctlToNdasScsiDevice(
pdoData,
NDASSCSI_IOCTL_REMOVE_TARGET,
buffer,
sizeof(NDASBUS_REMOVE_TARGET_DATA),
NULL,
0
);
if(NT_SUCCESS(status) && pdoData->Persistent) {
status = LSBus_UnregisterTarget(fdoData, removeTarget->ulSlotNo, removeTarget->ulTargetId);
if(!NT_SUCCESS(status)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_INFO, ( "REMOVE_TARGET: Removed Target instance,"
" but LSBus_UnregisterTarget() failed.\n"));
status = STATUS_INTERNAL_DB_ERROR;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_UNREGISTER_TARGET_FAIL,
IOCTL_NDASBUS_REMOVE_TARGET,
removeTarget->ulSlotNo);
}
#if DBG
else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_INFO, ("REMOVE_TARGET: LSBus_UnregisterTarget() succeeded.\n"));
}
#endif
}
ObDereferenceObject(pdoData->Self);
Irp->IoStatus.Information = 0;
break;
}
case IOCTL_NDASBUS_STARTSTOP_REGISTRARENUM:{
PULONG onOff = (PULONG)buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"STARTSTOP_REGISTRARENUM: inlen %d, outlen %d OnOff %u\n", inlen, outlen, *onOff));
KeEnterCriticalRegion();
ExAcquireFastMutexUnsafe(&fdoData->RegMutex);
if(*onOff != 0) {
//
// Save old state.
// Activate the registrar's enumeration
//
*onOff = fdoData->StartStopRegistrarEnum;
fdoData->StartStopRegistrarEnum = TRUE;
} else {
//
// Save old state.
// Deactivate the registrar's enumeration
//
*onOff = fdoData->StartStopRegistrarEnum;
fdoData->StartStopRegistrarEnum = FALSE;
}
//
// Clean up non-enumerated entries.
//
LSBus_CleanupNDASDeviceRegistryUnsafe(fdoData);
ExReleaseFastMutexUnsafe(&fdoData->RegMutex);
KeLeaveCriticalRegion();
Irp->IoStatus.Information = sizeof(ULONG);
status = STATUS_SUCCESS;
break;
}
case IOCTL_NDASBUS_REGISTER_DEVICE:
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"REGISTER_DEVICE: inlen %d, outlen %d,"
" sizeof(NDASBUS_PLUGIN_HARDWARE_EX2) %d\n",
inlen, outlen, sizeof(NDASBUS_PLUGIN_HARDWARE_EX2)));
if ((inlen == outlen)) {
PNDASBUS_PLUGIN_HARDWARE_EX2 PlugIn = buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("REGISTER_DEVICE: entered\n"));
status = LSBus_RegisterDevice(fdoData, PlugIn);
Irp->IoStatus.Information = 0;
}
else
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR,
("REGISTER_DEVICE: length mismatch!!!"
" inlen %d, outlen %d, sizeof(NDASBUS_PLUGIN_HARDWARE_EX2) %d\n",
inlen, outlen, sizeof(NDASBUS_PLUGIN_HARDWARE_EX2)));
}
break;
case IOCTL_NDASBUS_REGISTER_TARGET:
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"REGISTER_TARGET: inlen %d, outlen %d,"
" sizeof(NDASBUS_ADD_TARGET_DATA) %d\n",
inlen, outlen, sizeof(NDASBUS_ADD_TARGET_DATA)));
if ((inlen == outlen)) {
PNDASBUS_ADD_TARGET_DATA AddTargetData = buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("REGISTER_TARGET: entered\n"));
status = LSBus_RegisterTarget(fdoData, AddTargetData);
Irp->IoStatus.Information = 0;
}
else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"REGISTER_TARGET: length mismatch!!!"
" inlen %d, outlen %d, sizeof(NDASBUS_ADD_TARGET_DATA) %d\n",
inlen, outlen, sizeof(NDASBUS_ADD_TARGET_DATA)));
}
}
break;
case IOCTL_NDASBUS_UNREGISTER_DEVICE:
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"UNREGISTER_DEVICE: inlen %d, outlen %d,"
" sizeof(NDASBUS_UNREGISTER_NDASDEV) %d\n",
inlen, outlen, sizeof(NDASBUS_UNREGISTER_NDASDEV)));
if ((inlen == outlen)) {
PNDASBUS_UNREGISTER_NDASDEV UnregDev = buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("UNREGISTER_DEVICE: entered\n"));
status = LSBus_UnregisterDevice(fdoData, UnregDev->SlotNo);
Irp->IoStatus.Information = 0;
}
else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"UNREGISTER_DEVICE: length mismatch!!!"
" inlen %d, outlen %d, sizeof(NDASBUS_ADD_TARGET_DATA) %d\n",
inlen, outlen, sizeof(NDASBUS_UNREGISTER_NDASDEV)));
}
}
break;
case IOCTL_NDASBUS_UNREGISTER_TARGET:
{
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"UNREGISTER_TARGET: inlen %d, outlen %d,"
" sizeof(NDASBUS_UNREGISTER_TARGET) %d\n",
inlen, outlen, sizeof(NDASBUS_UNREGISTER_TARGET)));
if ((inlen == outlen)) {
PNDASBUS_UNREGISTER_TARGET UnregTarget = buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("UNREGISTER_TARGET: entered\n"));
status = LSBus_UnregisterTarget(fdoData, UnregTarget->SlotNo, UnregTarget->TargetId);
Irp->IoStatus.Information = 0;
}
else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, (
"UNREGISTER_TARGET: length mismatch!!!"
" inlen %d, outlen %d, sizeof(NDASBUS_UNREGISTER_TARGET) %d\n",
inlen, outlen, sizeof(NDASBUS_UNREGISTER_TARGET)));
}
}
break;
case IOCTL_NDASBUS_SETPDOINFO:
{
PPDO_DEVICE_DATA pdoData;
PNDASBUS_SETPDOINFO SetPdoInfo;
KIRQL oldIrql;
PVOID sectionHandle;
BOOLEAN acceptStatus;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_SETPDOINFO called\n"));
if (sizeof (NDASBUS_SETPDOINFO) != inlen)
break;
acceptStatus = TRUE;
SetPdoInfo = (PNDASBUS_SETPDOINFO)buffer;
pdoData = LookupPdoData(fdoData, SetPdoInfo->SlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("no pdo\n"));
status = STATUS_UNSUCCESSFUL;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_SETPDOINFO,
SetPdoInfo->SlotNo);
break;
}
//
// lock the code section of this function to acquire spinlock in raised IRQL.
//
sectionHandle = MmLockPagableCodeSection(Bus_IoCtl);
KeAcquireSpinLock(&pdoData->LanscsiAdapterPDO.LSDevDataSpinLock, &oldIrql);
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("!!!!!!!!!!!!!!!!!! SETPDOINFO: PDO %p: %08lx %08lx %08lx\n",
pdoData->Self, SetPdoInfo->AdapterStatus,
SetPdoInfo->SupportedFeatures,
SetPdoInfo->EnabledFeatures));
//
// Deny the status change if the current status is STATUS_STOPPED except for RESETSTATUS flag.
//
if(ADAPTERINFO_ISSTATUS(pdoData->LanscsiAdapterPDO.LastAdapterStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPED)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("SETPDOINFO: 'An event occured after 'Stopped' event\n"));
if(ADAPTERINFO_ISSTATUSFLAG(SetPdoInfo->AdapterStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_RESETSTATUS)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("SETPDOINFO: Reset-status event accepted.\n"));
} else {
acceptStatus = FALSE;
}
} else {
if(pdoData->LanscsiAdapterPDO.AddDevInfo == NULL) {
acceptStatus = FALSE;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("!!!!!!!!!!!!!!!!!! SETPDOINFO: AddTarget is not occured. Too early to set status.\n"));
}
}
//
// Mask off RESETSTATUS.
// NDAS service does not need to know it.
//
SetPdoInfo->AdapterStatus &= ~NDASSCSI_ADAPTERINFO_STATUSFLAG_RESETSTATUS;
//
// Set status values to the corresponding physical device object.
// Save to the extension
//
if(acceptStatus) {
PNDASBUS_PDOEVENT_ENTRY pdoEventEntry;
pdoEventEntry = NdasBusCreatePdoStatusItem(SetPdoInfo->AdapterStatus);
if(pdoEventEntry) {
NdasBusQueuePdoStatusItem(&pdoData->LanscsiAdapterPDO, pdoEventEntry);
}
#if DBG
else {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("SETPDOINFO: Could not allocate PDO status entry.\n"));
}
#endif
pdoData->LanscsiAdapterPDO.LastAdapterStatus = SetPdoInfo->AdapterStatus;
pdoData->LanscsiAdapterPDO.SupportedFeatures = SetPdoInfo->SupportedFeatures;
pdoData->LanscsiAdapterPDO.EnabledFeatures = SetPdoInfo->EnabledFeatures;
//
// Queue plugout worker if the NDAS SCSI stop abnormally.
// Notify the NDAS service of abnormal termination
//
if(ADAPTERINFO_ISSTATUS(SetPdoInfo->AdapterStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPED) &&
ADAPTERINFO_ISSTATUSFLAG(SetPdoInfo->AdapterStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_ABNORMAL_TERMINAT)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_ERROR, ("SETPDOINFO: Queueing Unplug worker!!!!!!!!\n"));
status = QueueUnplugWorker(fdoData, SetPdoInfo->SlotNo);
//
// Set disconnection event
//
KeSetEvent(pdoData->LanscsiAdapterPDO.DisconEventToService, IO_DISK_INCREMENT, FALSE);
} else {
//
// Notify the adapter status change
//
KeSetEvent(pdoData->LanscsiAdapterPDO.AlarmEventToService, IO_DISK_INCREMENT, FALSE);
}
}
KeReleaseSpinLock(&pdoData->LanscsiAdapterPDO.LSDevDataSpinLock, oldIrql);
//
// Release the code section.
//
MmUnlockPagableImageSection(sectionHandle);
status = STATUS_SUCCESS;
ObDereferenceObject(pdoData->Self);
Irp->IoStatus.Information = outlen;
}
break;
case IOCTL_NDASBUS_QUERY_NODE_ALIVE:
{
PPDO_DEVICE_DATA pdoData;
BOOLEAN bAlive;
PNDASBUS_NODE_ALIVE_IN pNodeAliveIn;
NDASBUS_NODE_ALIVE_OUT nodeAliveOut;
// Check Parameter.
if(inlen != sizeof(NDASBUS_NODE_ALIVE_IN) ||
outlen != sizeof(NDASBUS_NODE_ALIVE_OUT)) {
status = STATUS_UNKNOWN_REVISION;
break;
}
pNodeAliveIn = (PNDASBUS_NODE_ALIVE_IN)Irp->AssociatedIrp.SystemBuffer;
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_NOISE,
("FDO: IOCTL_NDASBUS_QUERY_NODE_ALIVE SlotNumber = %d\n",
pNodeAliveIn->SlotNo));
pdoData = LookupPdoData(fdoData, pNodeAliveIn->SlotNo);
if(pdoData == NULL) {
// Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_TRACE,
// ("[LanScsiBus]Bus_IoCtl: IOCTL_NDASBUS_QUERY_NODE_ALIVE No pdo\n"));
bAlive = FALSE;
} else {
bAlive = TRUE;
}
// For Result...
nodeAliveOut.SlotNo = pNodeAliveIn->SlotNo;
nodeAliveOut.bAlive = bAlive;
// Get Adapter Status.
if(bAlive == TRUE)
{
if( ADAPTERINFO_ISSTATUS(pdoData->LanscsiAdapterPDO.LastAdapterStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPING)) {
nodeAliveOut.bHasError = TRUE;
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_QUERY_NODE_ALIVE Adapter has Error 0x%x\n", nodeAliveOut.bHasError));
} else {
nodeAliveOut.bHasError = FALSE;
}
}
if(pdoData)
ObDereferenceObject(pdoData->Self);
RtlCopyMemory(
Irp->AssociatedIrp.SystemBuffer,
&nodeAliveOut,
sizeof(NDASBUS_NODE_ALIVE_OUT)
);
Irp->IoStatus.Information = sizeof(NDASBUS_NODE_ALIVE_OUT);
status = STATUS_SUCCESS;
}
break;
//
// added by hootch 01172004
//
case IOCTL_NDASBUS_UPGRADETOWRITE:
{
PPDO_DEVICE_DATA pdoData;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_UPGRADETOWRITE called\n"));
// Check Parameter.
if(inlen != sizeof(NDASBUS_UPGRADE_TO_WRITE)) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_UPGRADETOWRITE: Invalid input buffer length\n"));
status = STATUS_UNKNOWN_REVISION;
break;
}
pdoData = LookupPdoData(fdoData, ((PNDASBUS_UPGRADE_TO_WRITE)buffer)->SlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_UPGRADETOWRITE: No pdo for Slotno:%d\n", ((PNDASBUS_UPGRADE_TO_WRITE)buffer)->SlotNo));
status = STATUS_NO_SUCH_DEVICE;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_UPGRADETOWRITE,
((PNDASBUS_UPGRADE_TO_WRITE)buffer)->SlotNo);
} else {
//
// redirect to the NDASSCSI Device
//
status = LSBus_IoctlToNdasScsiDevice(
pdoData,
NDASSCSI_IOCTL_UPGRADETOWRITE,
buffer,
inlen,
buffer,
outlen
);
ObDereferenceObject(pdoData->Self);
}
Irp->IoStatus.Information = 0;
}
break;
case IOCTL_NDASBUS_REDIRECT_NDASSCSI:
{
PPDO_DEVICE_DATA pdoData;
PNDASBUS_REDIRECT_NDASSCSI redirectIoctl;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_REDIRECT_NDASSCSI called\n"));
// Check Parameter.
if(inlen < sizeof(NDASBUS_REDIRECT_NDASSCSI)) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_REDIRECT_NDASSCSI: Invalid input buffer length\n"));
status = STATUS_UNKNOWN_REVISION;
break;
}
redirectIoctl = (PNDASBUS_REDIRECT_NDASSCSI)buffer;
pdoData = LookupPdoData(fdoData, redirectIoctl->SlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_REDIRECT_NDASSCSI: No pdo for Slotno:%d\n", redirectIoctl->SlotNo));
status = STATUS_NO_SUCH_DEVICE;
} else {
//
// redirect to the NDASSCSI Device
//
status = LSBus_IoctlToNdasScsiDevice(
pdoData,
redirectIoctl->IoctlCode,
redirectIoctl->IoctlData,
redirectIoctl->IoctlDataSize,
redirectIoctl->IoctlData,
redirectIoctl->IoctlDataSize
);
ObDereferenceObject(pdoData->Self);
}
Irp->IoStatus.Information = 0;
}
break;
case IOCTL_NDASBUS_QUERY_NDASSCSIINFO:
{
PPDO_DEVICE_DATA pdoData;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_QUERY_NDASSCSIINFO called\n"));
// Check Parameter.
if(inlen < FIELD_OFFSET(NDASSCSI_QUERY_INFO_DATA, QueryData) ) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_QUERY_NDASSCSIINFO: Invalid input buffer length too small.\n"));
status = STATUS_UNKNOWN_REVISION;
break;
}
pdoData = LookupPdoData(fdoData, ((PNDASSCSI_QUERY_INFO_DATA)buffer)->NdasScsiAddress.SlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_QUERY_NDASSCSIINFO No pdo\n"));
status = STATUS_NO_SUCH_DEVICE;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_QUERY_NDASSCSIINFO,
((PNDASSCSI_QUERY_INFO_DATA)buffer)->NdasScsiAddress.SlotNo);
} else {
//
// redirect to the NDASSCSI Device
//
status = LSBus_IoctlToNdasScsiDevice(
pdoData,
NDASSCSI_IOCTL_QUERYINFO_EX,
buffer,
inlen,
buffer,
outlen
);
ObDereferenceObject(pdoData->Self);
}
Irp->IoStatus.Information = outlen;
}
break;
case IOCTL_NDASBUS_QUERY_INFORMATION:
{
// PPDO_DEVICE_DATA pdoData;
NDASBUS_QUERY_INFORMATION Query;
PNDASBUS_INFORMATION Information;
LONG BufferLenNeeded;
// Check Parameter.
if( inlen < sizeof(NDASBUS_QUERY_INFORMATION) /*||
outlen < sizeof(NDASBUS_INFORMATION) */) {
status = STATUS_UNKNOWN_REVISION;
break;
}
RtlCopyMemory(&Query, buffer, sizeof(NDASBUS_QUERY_INFORMATION));
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_TRACE,
("FDO: IOCTL_NDASBUS_QUERY_INFORMATION QueryType : %d SlotNumber = %d\n",
Query.InfoClass, Query.SlotNo));
Information = (PNDASBUS_INFORMATION)buffer;
ASSERT(Information);
Information->InfoClass = Query.InfoClass;
status = LSBus_QueryInformation(fdoData, IoIs32bitProcess(Irp), &Query, Information, outlen, &BufferLenNeeded);
if(NT_SUCCESS(status)) {
Information->Size = BufferLenNeeded;
Irp->IoStatus.Information = BufferLenNeeded;
} else {
Irp->IoStatus.Information = BufferLenNeeded;
}
}
break;
case IOCTL_NDASBUS_PLUGIN_HARDWARE_EX2:
{
ULONG structLen; // Without variable length field
ULONG wholeStructLen; // With variable length field
ULONG inputWholeStructLen;
//
// Check 32 bit thunking request
//
if(IoIs32bitProcess(Irp)) {
structLen = FIELD_OFFSET(NDASBUS_PLUGIN_HARDWARE_EX2_32, HardwareIDs);
wholeStructLen = sizeof(NDASBUS_PLUGIN_HARDWARE_EX2_32);
inputWholeStructLen = ((PNDASBUS_PLUGIN_HARDWARE_EX2_32) buffer)->Size;
} else {
structLen = FIELD_OFFSET(NDASBUS_PLUGIN_HARDWARE_EX2, HardwareIDs);
wholeStructLen = sizeof(NDASBUS_PLUGIN_HARDWARE_EX2);
inputWholeStructLen = ((PNDASBUS_PLUGIN_HARDWARE_EX2) buffer)->Size;
}
if ((inlen == outlen) &&
//
// Make sure it has at least two nulls and the size
// field is set to the declared size of the struct
//
((structLen + sizeof(UNICODE_NULL) * 2) <=
inlen) &&
//
// The size field should be set to the sizeof the struct as declared
// and *not* the size of the struct plus the multi_sz
//
(wholeStructLen == inputWholeStructLen)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("PlugIn called\n"));
status= Bus_PlugInDeviceEx2((PNDASBUS_PLUGIN_HARDWARE_EX2)buffer,
inlen,
fdoData,
IoIs32bitProcess(Irp),
Irp->RequestorMode, FALSE);
Irp->IoStatus.Information = outlen;
}
}
break;
case IOCTL_NDASBUS_GETVERSION:
{
if (outlen >= sizeof(NDASBUS_GET_VERSION)) {
PNDASBUS_GET_VERSION version = (PNDASBUS_GET_VERSION)buffer;
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("IOCTL_NDASBUS_GETVERSION: called\n"));
try {
version->VersionMajor = VER_FILEMAJORVERSION;
version->VersionMinor = VER_FILEMINORVERSION;
version->VersionBuild = VER_FILEBUILD;
version->VersionPrivate = VER_FILEBUILD_QFE;
Irp->IoStatus.Information = sizeof(NDASBUS_GET_VERSION);
status = STATUS_SUCCESS;
} except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
Irp->IoStatus.Information = 0;
}
}
}
break;
case IOCTL_NDASBUS_UNPLUG_HARDWARE:
{
if ((sizeof (NDASBUS_UNPLUG_HARDWARE) == inlen) &&
(inlen == outlen) &&
(((PNDASBUS_UNPLUG_HARDWARE)buffer)->Size == inlen)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("UnPlug called\n"));
status= Bus_UnPlugDevice(
(PNDASBUS_UNPLUG_HARDWARE)buffer, fdoData);
Irp->IoStatus.Information = outlen;
}
}
break;
case IOCTL_NDASBUS_EJECT_HARDWARE:
{
if ((sizeof (NDASBUS_EJECT_HARDWARE) == inlen) &&
(inlen == outlen) &&
(((PNDASBUS_EJECT_HARDWARE)buffer)->Size == inlen)) {
Bus_KdPrint(fdoData, BUS_DBG_IOCTL_TRACE, ("Eject called\n"));
status= Bus_EjectDevice((PNDASBUS_EJECT_HARDWARE)buffer, fdoData);
Irp->IoStatus.Information = outlen;
}
}
break;
case IOCTL_NDASBUS_DVD_GET_STATUS:
{
PPDO_DEVICE_DATA pdoData;
PNDASBUS_DVD_STATUS pDvdStatusData;
// Check Parameter.
if((inlen != outlen)
|| (sizeof(NDASBUS_DVD_STATUS) > inlen))
{
status = STATUS_UNSUCCESSFUL ;
break;
}
pDvdStatusData = (PNDASBUS_DVD_STATUS)Irp->AssociatedIrp.SystemBuffer;
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("FDO: IOCTL_NDASBUS_DVD_GET_STATUS SlotNumber = %d\n",
pDvdStatusData->SlotNo));
pdoData = LookupPdoData(fdoData, pDvdStatusData->SlotNo);
if(pdoData == NULL) {
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_DVD_GET_STATUS No pdo\n"));
status = STATUS_UNSUCCESSFUL;
NDBusIoctlLogError( fdoData->Self,
NDASBUS_IO_PDO_NOT_FOUND,
IOCTL_NDASBUS_DVD_GET_STATUS,
pDvdStatusData->SlotNo);
break;
} else {
if(pdoData->LanscsiAdapterPDO.Flags & LSDEVDATA_FLAG_LURDESC) {
//
// A LUR descriptor is set.
//
if(((PLURELATION_DESC)pdoData->LanscsiAdapterPDO.AddDevInfo)->DevType != NDASSCSI_TYPE_DVD)
{
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_DVD_GET_STATUS No DVD Device\n"));
status = STATUS_UNSUCCESSFUL;
break;
}
} else {
//
// ADD_TARGET_DATA is set.
//
if(((PNDASBUS_ADD_TARGET_DATA)pdoData->LanscsiAdapterPDO.AddDevInfo)->ucTargetType != NDASSCSI_TYPE_DVD)
{
Bus_KdPrint_Cont (fdoData, BUS_DBG_IOCTL_ERROR,
("IOCTL_NDASBUS_DVD_GET_STATUS No DVD Device\n"));
status = STATUS_UNSUCCESSFUL;
break;
}
}
//
// redirect to the NDASSCSI Device
//
status = LSBus_IoctlToNdasScsiDevice(
pdoData,
NDASSCSI_IOCTL_GET_DVD_STATUS,
buffer,
inlen,
buffer,
outlen
);
ObDereferenceObject(pdoData->Self);
status = STATUS_SUCCESS;
Irp->IoStatus.Information = outlen;
}
}
break;
default:
break; // default status is STATUS_INVALID_PARAMETER
}
VOID
PrimarySession_Stopping (
IN PPRIMARY_SESSION PrimarySession
)
{
PPRIMARY_SESSION_REQUEST primarySessionRequest;
NTSTATUS ntStatus;
LARGE_INTEGER timeOut;
PrimarySession_Reference( PrimarySession );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("PrimarySession_Stopping: PrimarySession = %p\n", PrimarySession) );
ASSERT( PrimarySession->ThreadObject != NULL );
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (PrimarySession->Thread.SessionState != SESSION_TREE_CONNECT) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
PrimarySession_Dereference( PrimarySession );
return;
}
if (FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOP)) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
PrimarySession_Dereference( PrimarySession );
return;
}
primarySessionRequest = AllocPrimarySessionRequest( TRUE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_STOPPING;
primarySessionRequest->ExecuteStatus = STATUS_PENDING;
QueueingPrimarySessionRequest( PrimarySession, primarySessionRequest, TRUE );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
timeOut.QuadPart = -LFS_QUERY_REMOVE_TIME_OUT;
ntStatus = KeWaitForSingleObject( &primarySessionRequest->CompleteEvent,
Executive,
KernelMode,
FALSE,
&timeOut );
if (ntStatus != STATUS_SUCCESS) {
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (primarySessionRequest->ExecuteStatus == STATUS_PENDING) {
primarySessionRequest->Synchronous = FALSE;
} else {
ntStatus = STATUS_SUCCESS;
}
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
}
if (ntStatus == STATUS_SUCCESS) {
KeClearEvent( &primarySessionRequest->CompleteEvent );
DereferencePrimarySessionRequest( primarySessionRequest );
}
if (ntStatus == STATUS_SUCCESS) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySession_CloseFiles: thread close files\n") );
ASSERT( FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOPPING) || FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_STOPED) );
} else {
ASSERT( ntStatus == STATUS_TIMEOUT );
}
PrimarySession_Dereference( PrimarySession );
return;
}
VOID
PrimarySession_Close (
IN PPRIMARY_SESSION PrimarySession
)
{
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySession_Close: PrimarySession = %p\n", PrimarySession) );
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOP)) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
return;
}
SetFlag( PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOP );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
if (PrimarySession->ThreadHandle == NULL) {
ASSERT( LFS_BUG );
PrimarySession_Dereference( PrimarySession );
return;
}
ASSERT( PrimarySession->ThreadObject != NULL );
if (FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_TERMINATED)) {
ObDereferenceObject( PrimarySession->ThreadObject );
PrimarySession->ThreadHandle = NULL;
PrimarySession->ThreadObject = NULL;
} else {
PPRIMARY_SESSION_REQUEST primarySessionRequest;
NTSTATUS ntStatus;
LARGE_INTEGER timeOut;
primarySessionRequest = AllocPrimarySessionRequest( FALSE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_DISCONNECT;
QueueingPrimarySessionRequest( PrimarySession,
primarySessionRequest,
FALSE );
primarySessionRequest = AllocPrimarySessionRequest( FALSE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_DOWN;
QueueingPrimarySessionRequest( PrimarySession,
primarySessionRequest,
FALSE );
timeOut.QuadPart = - LFS_TIME_OUT;
ntStatus = KeWaitForSingleObject( PrimarySession->ThreadObject,
Executive,
KernelMode,
FALSE,
&timeOut );
if (ntStatus == STATUS_SUCCESS) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE, ("PrimarySession_Close: thread stoped\n") );
ObDereferenceObject( PrimarySession->ThreadObject );
PrimarySession->ThreadHandle = NULL;
PrimarySession->ThreadObject = NULL;
} else {
ASSERT( LFS_BUG );
return;
}
}
if (PrimarySession->ConnectionFileHandle) {
LpxTdiV2DisassociateAddress( PrimarySession->ConnectionFileObject );
LpxTdiV2CloseConnection( PrimarySession->ConnectionFileHandle,
PrimarySession->ConnectionFileObject,
&PrimarySession->ReceiveOverlapped );
}
PrimarySession->ConnectionFileHandle = NULL;
PrimarySession->ConnectionFileObject = NULL;
PrimarySession_Dereference( PrimarySession );
return;
}
VOID
NtfsSpecialDispatch (
PVOID Context
)
/*++
Routine Description:
This routine is called when a special operation needs to be posted.
It is called indirectly by NtfsPostSpecial. It is assumes that the
Vcb is protected from going away by incrementing the volemue close
counts for a file. If this routine fails nothing is done except
to clean up the Vcb. This routine also handles issues log file full
and can't wait.
The function to be called is stored in the PostSpecialCallout field
of the Irp Context, and the context is stored int he OriginatingIrp.
Both fields are zeroed before the the callout function is called.
Arguments:
Context - Supplies a pointer to an IrpContext.
Return Value:
--*/
{
PVCB Vcb;
PIRP_CONTEXT IrpContext = Context;
TOP_LEVEL_CONTEXT TopLevelContext;
PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
POST_SPECIAL_CALLOUT PostSpecialCallout;
PVOID SpecialContext;
ULONG LogFileFullCount;
BOOLEAN Retry;
PAGED_CODE();
FsRtlEnterFileSystem();
do {
Vcb = IrpContext->Vcb;
LogFileFullCount = 0;
//
// Capture the funciton pointer and context before using the IrpContext.
//
PostSpecialCallout = IrpContext->Union.PostSpecialCallout;
SpecialContext = IrpContext->OriginatingIrp;
IrpContext->Union.PostSpecialCallout = NULL;
IrpContext->OriginatingIrp = NULL;
ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, TRUE, TRUE );
ASSERT( ThreadTopLevelContext == &TopLevelContext );
ASSERT( !FlagOn( IrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
ASSERT( FlagOn( IrpContext->State, IRP_CONTEXT_STATE_ALLOC_FROM_POOL ));
//
// Initialize the thread top level structure, if needed.
//
ASSERT( IoGetTopLevelIrp() != (PIRP) &TopLevelContext );
NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );
//
// Don't let this IrpContext be deleted.
//
SetFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
do {
Retry = FALSE;
try {
//
// See if we failed due to a log file full condition, and
// if so, then do a clean volume checkpoint if we are the
// first ones to get there. If we see a different Lsn and do
// not do the checkpoint, the worst that can happen is that we
// will fail again if the log file is still full.
//
if (IrpContext->LastRestartArea.QuadPart != 0) {
NtfsCheckpointForLogFileFull( IrpContext );
if (++LogFileFullCount >= 2) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_EXCESS_LOG_FULL );
}
}
//
// Call the requested function.
//
ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));
PostSpecialCallout( IrpContext, SpecialContext );
NtfsCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
} except(NtfsExceptionFilter( IrpContext, GetExceptionInformation() )) {
NTSTATUS ExceptionCode;
ExceptionCode = GetExceptionCode();
ExceptionCode = NtfsProcessException( IrpContext, NULL, ExceptionCode );
if ((ExceptionCode == STATUS_CANT_WAIT) ||
(ExceptionCode == STATUS_LOG_FILE_FULL)) {
Retry = TRUE;
}
}
} while (Retry);
//
// Ok to let this IrpContext be deleted.
//
ClearFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
//
// At this point regardless of the status the volume needs to
// be cleaned up and the IrpContext freed.
// Dereference the Vcb and check to see if it needs to be deleted.
// since this call might raise wrap it with a try/execpt.
//
try {
//
// Acquire the volume exclusive so the counts can be
// updated.
//
ASSERT( FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT ));
NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
InterlockedDecrement( &Vcb->SystemFileCloseCount );
InterlockedDecrement( &Vcb->CloseCount );
NtfsReleaseVcb( IrpContext, Vcb );
} except( EXCEPTION_EXECUTE_HANDLER ) {
ASSERT( FsRtlIsNtstatusExpected( GetExceptionCode() ) );
}
//
// Free the irp context.
//
NtfsCleanupIrpContext( IrpContext, TRUE );
//
// See if there is more work on the scavenger list.
//
ExAcquireFastMutexUnsafe( &NtfsScavengerLock );
ASSERT( NtfsScavengerRunning );
IrpContext = NtfsScavengerWorkList;
if (IrpContext != NULL) {
//
// Remove the entry from the list.
//
NtfsScavengerWorkList = (PIRP_CONTEXT) IrpContext->WorkQueueItem.List.Flink;
IrpContext->WorkQueueItem.List.Flink = NULL;
} else {
NtfsScavengerRunning = FALSE;
}
ExReleaseFastMutexUnsafe( &NtfsScavengerLock );
} while ( IrpContext != NULL );
FsRtlExitFileSystem();
}
VOID
NtfsPostSpecial (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN POST_SPECIAL_CALLOUT PostSpecialCallout,
IN PVOID Context
)
/*++
Routine Description:
This routine posts a special request to a worker thread. The function
to be called is passed in. The Vcb is referenced to ensure it is not
deleted while the posted request is excuting.
Arguments:
Vcb - Volume control block for volume to post to.
PostSpecialCallout - Function to be called from the worker thread.
Context - Context point to pass to the function.
Return Value:
None
--*/
{
PIRP_CONTEXT NewIrpContext = NULL;
UNREFERENCED_PARAMETER( IrpContext );
PAGED_CODE();
//
// Create an IrpContext for use to post the request.
//
NtfsInitializeIrpContext( NULL, TRUE, &NewIrpContext );
NewIrpContext->Vcb = Vcb;
NewIrpContext->Union.PostSpecialCallout = PostSpecialCallout;
NewIrpContext->OriginatingIrp = Context;
//
// Updating the CloseCount and SystemFileCloseCount allows the volume
// to be locked or dismounted, but the Vcb will not be deleted. This
// routine will only be called with non-zero close counts so it is ok
// to increment theses counts.
//
ASSERT( Vcb->CloseCount > 0 );
InterlockedIncrement( &Vcb->CloseCount );
InterlockedIncrement( &Vcb->SystemFileCloseCount );
ExInitializeWorkItem( &NewIrpContext->WorkQueueItem,
NtfsSpecialDispatch,
NewIrpContext );
//
// Determine if the scavenger is already running.
//
ExAcquireFastMutexUnsafe( &NtfsScavengerLock );
if (NtfsScavengerRunning) {
//
// Add this item to the scavanger work list.
//
NewIrpContext->WorkQueueItem.List.Flink = NULL;
if (NtfsScavengerWorkList == NULL) {
NtfsScavengerWorkList = NewIrpContext;
} else {
PIRP_CONTEXT WorkIrpContext;
WorkIrpContext = NtfsScavengerWorkList;
while (WorkIrpContext->WorkQueueItem.List.Flink != NULL) {
WorkIrpContext = (PIRP_CONTEXT)
WorkIrpContext->WorkQueueItem.List.Flink;
}
WorkIrpContext->WorkQueueItem.List.Flink = (PLIST_ENTRY)
NewIrpContext;
}
} else {
//
// Start a worker thread to do scavenger work.
//
ExQueueWorkItem( &NewIrpContext->WorkQueueItem, DelayedWorkQueue );
NtfsScavengerRunning = TRUE;
}
ExReleaseFastMutexUnsafe( &NtfsScavengerLock);
}
VOID
PrimarySession_Close (
IN PPRIMARY_SESSION PrimarySession
)
{
DebugTrace2( 0, Dbg2, ("PrimarySession_Close: PrimarySession = %p\n", PrimarySession) );
ExAcquireFastMutexUnsafe( &PrimarySession->FastMutex );
if (FlagOn(PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOP)) {
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
return;
}
SetFlag( PrimarySession->Flags, PRIMARY_SESSION_FLAG_STOP );
ExReleaseFastMutexUnsafe( &PrimarySession->FastMutex );
if (PrimarySession->ThreadHandle == NULL) {
ASSERT( NDASFAT_BUG );
PrimarySession_Dereference( PrimarySession );
return;
}
ASSERT( PrimarySession->ThreadObject != NULL );
if (FlagOn(PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_TERMINATED)) {
ObDereferenceObject( PrimarySession->ThreadObject );
PrimarySession->ThreadHandle = NULL;
PrimarySession->ThreadObject = NULL;
} else {
PPRIMARY_SESSION_REQUEST primarySessionRequest;
NTSTATUS ntStatus;
LARGE_INTEGER timeOut;
primarySessionRequest = AllocPrimarySessionRequest( FALSE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_DISCONNECT;
QueueingPrimarySessionRequest( PrimarySession,
primarySessionRequest,
FALSE );
primarySessionRequest = AllocPrimarySessionRequest( FALSE );
primarySessionRequest->RequestType = PRIMARY_SESSION_REQ_DOWN;
QueueingPrimarySessionRequest( PrimarySession,
primarySessionRequest,
FALSE );
timeOut.QuadPart = -NDASFAT_TIME_OUT;
ntStatus = KeWaitForSingleObject( PrimarySession->ThreadObject,
Executive,
KernelMode,
FALSE,
&timeOut );
if (ntStatus == STATUS_SUCCESS) {
DebugTrace2( 0, Dbg, ("PrimarySession_Close: thread stoped\n") );
ObDereferenceObject( PrimarySession->ThreadObject );
PrimarySession->ThreadHandle = NULL;
PrimarySession->ThreadObject = NULL;
} else {
ASSERT( NDASFAT_BUG );
return;
}
}
#if 0
interval.QuadPart = (5 * DELAY_ONE_SECOND); //delay 5 seconds
KeDelayExecutionThread( KernelMode, FALSE, &interval );
#endif
if (PrimarySession->ConnectionFileHandle) {
LpxTdiDisassociateAddress( PrimarySession->ConnectionFileObject );
LpxTdiCloseConnection( PrimarySession->ConnectionFileHandle, PrimarySession->ConnectionFileObject );
}
PrimarySession->ConnectionFileHandle = NULL;
PrimarySession->ConnectionFileObject = NULL;
PrimarySession_Dereference( PrimarySession );
return;
}
NTSTATUS
xixfs_SendRenameLinkBC(
IN BOOLEAN Wait,
IN uint32 SubCommand,
IN uint8 * HostMac,
IN uint64 LotNumber,
IN uint8 * VolumeId,
IN uint64 OldParentLotNumber,
IN uint64 NewParentLotNumber
)
{
NTSTATUS RC = STATUS_UNSUCCESSFUL;
PXIXFSDG_PKT pPacket = NULL;
PXIXFS_FILE_CHANGE_BROADCAST pPacketData = NULL;
XIFS_LOCK_CONTROL LockControl;
uint8 DstAddress[6] ={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Enter XifsdSendRenameLinkBC \n"));
ASSERT(Wait);
// Changed by ILGU HONG
// chesung suggest
/*
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, DstAddress, XIXFS_TYPE_FILE_CHANGE))
{
return FALSE;
}
*/
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, NULL, XIXFS_TYPE_FILE_CHANGE))
{
return FALSE;
}
pPacketData = &(pPacket->RawDataDG.FileChangeReq);
// Changed by ILGU HONG
RtlCopyMemory(pPacketData->VolumeId, VolumeId, 16);
pPacketData->LotNumber = HTONLL(LotNumber);
pPacketData->PrevParentLotNumber = HTONLL(OldParentLotNumber);
pPacketData->NewParentLotNumber = HTONLL(NewParentLotNumber);
pPacketData->SubCommand =HTONL(SubCommand);
pPacket->TimeOut.QuadPart = xixcore_GetCurrentTime64() + DEFAULT_REQUEST_MAX_TIMEOUT;
ExAcquireFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
InsertTailList(&(XiGlobalData.XifsComCtx.SendPktList),
&(pPacket->PktListEntry) );
ExReleaseFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
KeSetEvent(&(XiGlobalData.XifsComCtx.CliSendDataEvent),0, FALSE);
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Exit XifsdSendRenameLinkBC \n"));
return STATUS_SUCCESS;
}
NTSTATUS
xixfs_SendFileChangeRC(
IN BOOLEAN Wait,
IN uint8 * HostMac,
IN uint64 LotNumber,
IN uint8 * VolumeId,
IN uint64 FileLength,
IN uint64 AllocationLength,
IN uint64 UpdateStartOffset
)
{
NTSTATUS RC = STATUS_UNSUCCESSFUL;
PXIXFSDG_PKT pPacket = NULL;
PXIXFS_FILE_LENGTH_CHANGE_BROADCAST pPacketData = NULL;
uint8 DstAddress[6] ={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Enter xixfs_SendFileChangeRC \n"));
ASSERT(Wait);
// Changed by ILGU HONG
// chesung suggest
/*
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, DstAddress, XIXFS_TYPE_FILE_LENGTH_CHANGE))
{
return FALSE;
}
*/
if(FALSE ==xixfs_AllocDGPkt(&pPacket, HostMac, DstAddress, XIXFS_TYPE_FILE_LENGTH_CHANGE))
{
return FALSE;
}
pPacketData = &(pPacket->RawDataDG.FileLenChangeReq);
// Changed by ILGU HONG
RtlCopyMemory(pPacketData->VolumeId, VolumeId, 16);
pPacketData->LotNumber = HTONLL(LotNumber);
pPacketData->FileLength = HTONLL(FileLength);
pPacketData->AllocationLength = HTONLL(AllocationLength);
pPacketData->WriteStartOffset = HTONLL(UpdateStartOffset);
pPacket->TimeOut.QuadPart = xixcore_GetCurrentTime64() + DEFAULT_REQUEST_MAX_TIMEOUT;
ExAcquireFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
InsertTailList(&(XiGlobalData.XifsComCtx.SendPktList),
&(pPacket->PktListEntry) );
ExReleaseFastMutexUnsafe(&XiGlobalData.XifsComCtx.SendPktListMutex);
KeSetEvent(&(XiGlobalData.XifsComCtx.CliSendDataEvent),0, FALSE);
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB|DEBUG_TARGET_LOCK),
("Exit xixfs_SendFileChangeRC \n"));
return STATUS_SUCCESS;
}
static
VOID
TestFastMutex(
PFAST_MUTEX Mutex,
KIRQL OriginalIrql)
{
PKTHREAD Thread = KeGetCurrentThread();
ok_irql(OriginalIrql);
/* acquire/release normally */
ExAcquireFastMutex(Mutex);
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ok_bool_false(ExTryToAcquireFastMutex(Mutex), "ExTryToAcquireFastMutex returned");
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ExReleaseFastMutex(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
#ifdef _M_IX86
/* ntoskrnl's fastcall version */
ExiAcquireFastMutex(Mutex);
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ok_bool_false(ExiTryToAcquireFastMutex(Mutex), "ExiTryToAcquireFastMutex returned");
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ExiReleaseFastMutex(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
#endif
/* try to acquire */
ok_bool_true(ExTryToAcquireFastMutex(Mutex), "ExTryToAcquireFastMutex returned");
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ExReleaseFastMutex(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
/* shortcut functions with critical region */
ExEnterCriticalRegionAndAcquireFastMutexUnsafe(Mutex);
ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned");
ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(Mutex);
/* acquire/release unsafe */
if (!KmtIsCheckedBuild || OriginalIrql == APC_LEVEL)
{
ExAcquireFastMutexUnsafe(Mutex);
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, OriginalIrql);
ExReleaseFastMutexUnsafe(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
/* mismatched acquire/release */
ExAcquireFastMutex(Mutex);
CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL);
ExReleaseFastMutexUnsafe(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, APC_LEVEL);
KmtSetIrql(OriginalIrql);
CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
Mutex->OldIrql = 0x55555555LU;
ExAcquireFastMutexUnsafe(Mutex);
CheckMutex(Mutex, 0L, Thread, 0LU, 0x55555555LU, OriginalIrql);
Mutex->OldIrql = PASSIVE_LEVEL;
ExReleaseFastMutex(Mutex);
CheckMutex(Mutex, 1L, NULL, 0LU, PASSIVE_LEVEL, PASSIVE_LEVEL);
KmtSetIrql(OriginalIrql);
CheckMutex(Mutex, 1L, NULL, 0LU, PASSIVE_LEVEL, OriginalIrql);
}
if (!KmtIsCheckedBuild)
{
/* release without acquire */
ExReleaseFastMutexUnsafe(Mutex);
CheckMutex(Mutex, 2L, NULL, 0LU, PASSIVE_LEVEL, OriginalIrql);
--Mutex->Count;
Mutex->OldIrql = OriginalIrql;
ExReleaseFastMutex(Mutex);
CheckMutex(Mutex, 2L, NULL, 0LU, OriginalIrql, OriginalIrql);
ExReleaseFastMutex(Mutex);
CheckMutex(Mutex, 3L, NULL, 0LU, OriginalIrql, OriginalIrql);
Mutex->Count -= 2;
}
/* make sure we survive this in case of error */
ok_eq_long(Mutex->Count, 1L);
Mutex->Count = 1;
ok_irql(OriginalIrql);
KmtSetIrql(OriginalIrql);
}
BOOLEAN
KspSynchronizedEventRoutine(
IN KSEVENTS_LOCKTYPE EventsFlags,
IN PVOID EventsLock,
IN PKSEVENT_SYNCHRONIZED_ROUTINE SynchronizedRoutine,
IN PKSEVENT_CTX Ctx)
{
BOOLEAN Result = FALSE;
KIRQL OldLevel;
if (EventsFlags == KSEVENTS_NONE)
{
/* no synchronization required */
Result = SynchronizedRoutine(Ctx);
}
else if (EventsFlags == KSEVENTS_SPINLOCK)
{
/* use spin lock */
KeAcquireSpinLock((PKSPIN_LOCK)EventsLock, &OldLevel);
Result = SynchronizedRoutine(Ctx);
KeReleaseSpinLock((PKSPIN_LOCK)EventsLock, OldLevel);
}
else if (EventsFlags == KSEVENTS_MUTEX)
{
/* use a mutex */
KeWaitForSingleObject(EventsLock, Executive, KernelMode, FALSE, NULL);
Result = SynchronizedRoutine(Ctx);
KeReleaseMutex((PRKMUTEX)EventsLock, FALSE);
}
else if (EventsFlags == KSEVENTS_FMUTEX)
{
/* use a fast mutex */
ExAcquireFastMutex((PFAST_MUTEX)EventsLock);
Result = SynchronizedRoutine(Ctx);
ExReleaseFastMutex((PFAST_MUTEX)EventsLock);
}
else if (EventsFlags == KSEVENTS_FMUTEXUNSAFE)
{
/* acquire fast mutex unsafe */
KeEnterCriticalRegion();
ExAcquireFastMutexUnsafe((PFAST_MUTEX)EventsLock);
Result = SynchronizedRoutine(Ctx);
ExReleaseFastMutexUnsafe((PFAST_MUTEX)EventsLock);
KeLeaveCriticalRegion();
}
else if (EventsFlags == KSEVENTS_INTERRUPT)
{
/* use interrupt for locking */
Result = KeSynchronizeExecution((PKINTERRUPT)EventsLock, (PKSYNCHRONIZE_ROUTINE)SynchronizedRoutine, (PVOID)Ctx);
}
else if (EventsFlags == KSEVENTS_ERESOURCE)
{
/* use an eresource */
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite((PERESOURCE)EventsLock, TRUE);
Result = SynchronizedRoutine(Ctx);
ExReleaseResourceLite((PERESOURCE)EventsLock);
KeLeaveCriticalRegion();
}
return Result;
}