/*++ Copyright (c) 1997 Microsoft Corporation Module Name: dispatch.c Abstract: Dispatch routines for the Cluster Network Driver. Author: Mike Massa (mikemas) January 3, 1997 Revision History: Who When What -------- -------- ---------------------------------------------- mikemas 01-03-97 created Notes: --*/ #include "precomp.h" #pragma hdrstop // // Data // PCN_FSCONTEXT CnExclusiveChannel = NULL; // // Un-exported Prototypes // NTSYSAPI NTSTATUS NTAPI ZwOpenProcess ( OUT PHANDLE ProcessHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN PCLIENT_ID ClientId OPTIONAL ); // // Local Prototypes // FILE_FULL_EA_INFORMATION UNALIGNED * CnFindEA( PFILE_FULL_EA_INFORMATION StartEA, CHAR *TargetName, USHORT TargetNameLength ); NTSTATUS CnCreate( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ); NTSTATUS CnCleanup( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ); NTSTATUS CnClose( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ); NTSTATUS CnEnableShutdownOnClose( PIRP Irp ); // // Mark pageable code. // #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, CnDispatchDeviceControl) #pragma alloc_text(PAGE, CnFindEA) #pragma alloc_text(PAGE, CnCreate) #pragma alloc_text(PAGE, CnEnableShutdownOnClose) #endif // ALLOC_PRAGMA // // Function definitions // VOID CnDereferenceFsContext( PCN_FSCONTEXT FsContext ) { LONG newValue = InterlockedDecrement(&(FsContext->ReferenceCount)); CnAssert(newValue >= 0); if (newValue != 0) { return; } // // Set the cleanup event. // KeSetEvent(&(FsContext->CleanupEvent), 0, FALSE); return; } // CnDereferenceFsContext NTSTATUS CnMarkRequestPending( PIRP Irp, PIO_STACK_LOCATION IrpSp, PDRIVER_CANCEL CancelRoutine ) /*++ Notes: Called with IoCancelSpinLock held. --*/ { PCN_FSCONTEXT fsContext = (PCN_FSCONTEXT) IrpSp->FileObject->FsContext; CN_IRQL oldIrql; // // Set up for cancellation // CnAssert(Irp->CancelRoutine == NULL); if (!Irp->Cancel) { IoMarkIrpPending(Irp); IoSetCancelRoutine(Irp, CancelRoutine); CnReferenceFsContext(fsContext); IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(( "[Clusnet] Pending irp %p fileobj %p.\n", Irp, IrpSp->FileObject )); } return(STATUS_SUCCESS); } // // The IRP has already been cancelled. // IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(("[Clusnet] irp %p already cancelled.\n", Irp)); } return(STATUS_CANCELLED); } // CnPrepareIrpForCancel VOID CnCompletePendingRequest( IN PIRP Irp, IN NTSTATUS Status, IN ULONG BytesReturned ) /*++ Routine Description: Completes a pending request. Arguments: Irp - A pointer to the IRP for this request. Status - The final status of the request. BytesReturned - Bytes sent/received information. Return Value: None. Notes: Called with IoCancelSpinLock held. Lock Irql is stored in Irp->CancelIrql. Releases IoCancelSpinLock before returning. --*/ { PIO_STACK_LOCATION irpSp; PCN_FSCONTEXT fsContext; irpSp = IoGetCurrentIrpStackLocation(Irp); fsContext = (PCN_FSCONTEXT) irpSp->FileObject->FsContext; IoSetCancelRoutine(Irp, NULL); CnDereferenceFsContext(fsContext); IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(( "[Clusnet] Completing irp %p fileobj %p, status %lx\n", Irp, irpSp->FileObject, Status )); } if (Irp->Cancel || fsContext->CancelIrps) { IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(("[Clusnet] Completed irp %p was cancelled\n", Irp)); } Status = (NTSTATUS) STATUS_CANCELLED; BytesReturned = 0; } CnReleaseCancelSpinLock(Irp->CancelIrql); Irp->IoStatus.Status = (NTSTATUS) Status; Irp->IoStatus.Information = BytesReturned; IoCompleteRequest(Irp, IO_NETWORK_INCREMENT); return; } // CnCompletePendingRequest PFILE_OBJECT CnBeginCancelRoutine( IN PIRP Irp ) /*++ Routine Description: Performs common bookkeeping for irp cancellation. Arguments: Irp - Pointer to I/O request packet Return Value: A pointer to the file object on which the irp was submitted. This value must be passed to CnEndCancelRequest(). Notes: Called with cancel spinlock held. --*/ { PIO_STACK_LOCATION irpSp; PCN_FSCONTEXT fsContext; NTSTATUS status = STATUS_SUCCESS; PFILE_OBJECT fileObject; CnAssert(Irp->Cancel); irpSp = IoGetCurrentIrpStackLocation(Irp); fileObject = irpSp->FileObject; fsContext = (PCN_FSCONTEXT) fileObject->FsContext; IoSetCancelRoutine(Irp, NULL); // // Add a reference so the object can't be closed while the cancel routine // is executing. // CnReferenceFsContext(fsContext); IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(( "[Clusnet] Cancelling irp %p fileobj %p\n", Irp, fileObject )); } return(fileObject); } // CnBeginCancelRoutine VOID CnEndCancelRoutine( PFILE_OBJECT FileObject ) /*++ Routine Description: Performs common bookkeeping for irp cancellation. Arguments: Return Value: Notes: Called with cancel spinlock held. --*/ { PCN_FSCONTEXT fsContext = (PCN_FSCONTEXT) FileObject->FsContext; // // Remove the reference placed on the endpoint by the cancel routine. // CnDereferenceFsContext(fsContext); IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(( "[Clusnet] Finished cancelling, fileobj %p\n", FileObject )); } return; } // CnEndCancelRoutine NTSTATUS CnDispatchInternalDeviceControl( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This is the dispatch routine for Internal Device Control IRPs. This is the hot path for kernel-mode TDI clients. Arguments: DeviceObject - Pointer to device object for target device Irp - Pointer to I/O request packet Return Value: An NT status code. --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status = STATUS_SUCCESS; ULONG fileType = (ULONG)((ULONG_PTR)irpSp->FileObject->FsContext2); #if DBG KIRQL entryIrql = KeGetCurrentIrql(); #endif // DBG Irp->IoStatus.Information = 0; if (DeviceObject == CdpDeviceObject) { if (fileType == TDI_TRANSPORT_ADDRESS_FILE) { if (irpSp->MinorFunction == TDI_SEND_DATAGRAM) { status = CxSendDatagram(Irp, irpSp); #if DBG CnAssert(entryIrql == KeGetCurrentIrql()); #endif // DBG return(status); } else if (irpSp->MinorFunction == TDI_RECEIVE_DATAGRAM) { status = CxReceiveDatagram(Irp, irpSp); #if DBG CnAssert(entryIrql == KeGetCurrentIrql()); #endif // DBG return(status); } else if (irpSp->MinorFunction == TDI_SET_EVENT_HANDLER) { status = CxSetEventHandler(Irp, irpSp); #if DBG CnAssert(entryIrql == KeGetCurrentIrql()); #endif // DBG return(status); } // // Fall through to common code. // } // // These functions are common to all endpoint types. // switch(irpSp->MinorFunction) { case TDI_QUERY_INFORMATION: status = CxQueryInformation(Irp, irpSp); break; case TDI_SET_INFORMATION: case TDI_ACTION: CNPRINT(( "[Clusnet] Call to unimplemented TDI function 0x%x\n", irpSp->MinorFunction )); status = STATUS_NOT_IMPLEMENTED; break; default: CNPRINT(( "[Clusnet] Call to invalid TDI function 0x%x\n", irpSp->MinorFunction )); status = STATUS_INVALID_DEVICE_REQUEST; } } else { CNPRINT(( "[Clusnet] Invalid internal device control function 0x%x on device %ws\n", irpSp->MinorFunction, DD_CLUSNET_DEVICE_NAME )); status = STATUS_INVALID_DEVICE_REQUEST; } Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NETWORK_INCREMENT); #if DBG CnAssert(entryIrql == KeGetCurrentIrql()); #endif // DBG return(status); } // CnDispatchInternalDeviceControl NTSTATUS CnDispatchDeviceControl( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This is the top-level dispatch routine for Device Control IRPs. Arguments: DeviceObject - Pointer to device object for target device Irp - Pointer to I/O request packet Return Value: An NT status code. Notes: This routine completes any IRPs for which the return code is not STATUS_PENDING. --*/ { NTSTATUS status; CCHAR ioIncrement = IO_NO_INCREMENT; BOOLEAN resourceAcquired = FALSE; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); ULONG ioControlCode = irpSp->Parameters.DeviceIoControl.IoControlCode; ULONG fileType = (ULONG) ((ULONG_PTR) irpSp->FileObject->FsContext2); PAGED_CODE(); // // Set this in advance. Any subsequent dispatch routine that cares // about it will modify it itself. // Irp->IoStatus.Information = 0; // // The following commands are valid on only TDI address objects. // if (fileType == TDI_TRANSPORT_ADDRESS_FILE) { if (ioControlCode == IOCTL_CX_IGNORE_NODE_STATE) { status = CxDispatchDeviceControl(Irp, irpSp); } else { // // Not handled. Return an error. // status = STATUS_INVALID_DEVICE_REQUEST; } goto complete_request; } // // The remaining commands are valid for control channels. // CnAssert(fileType == TDI_CONTROL_CHANNEL_FILE); // // The following set of commands affect only this file object and // can be issued at any time. We do not need to hold the CnResource // in order to process them. Nor do we need to be in the initialized. // state. // switch(ioControlCode) { case IOCTL_CLUSNET_SET_EVENT_MASK: { PCN_FSCONTEXT fsContext = irpSp->FileObject->FsContext; PCLUSNET_SET_EVENT_MASK_REQUEST request; ULONG requestSize; request = (PCLUSNET_SET_EVENT_MASK_REQUEST) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if (requestSize >= sizeof(CLUSNET_SET_EVENT_MASK_REQUEST)) { // // Kernel mode callers must supply a callback. // User mode callers must not. // if ( !( (Irp->RequestorMode == KernelMode) && (request->KmodeEventCallback == NULL) ) && !( (Irp->RequestorMode == UserMode) && (request->KmodeEventCallback != NULL) ) ) { status = CnSetEventMask( fsContext, request ); } else { status = STATUS_INVALID_PARAMETER; } } else { status = STATUS_INVALID_PARAMETER; } } goto complete_request; case IOCTL_CLUSNET_GET_NEXT_EVENT: { PCLUSNET_EVENT_RESPONSE response; ULONG responseSize; responseSize = irpSp->Parameters.DeviceIoControl.OutputBufferLength; if ( (responseSize < sizeof(CLUSNET_EVENT_RESPONSE))) { status = STATUS_INVALID_PARAMETER; } else { status = CnGetNextEvent( Irp, irpSp ); ioIncrement = IO_NETWORK_INCREMENT; } } goto complete_request; } // end of switch // // Not handled yet. Fall through. // if (ClusnetIsGeneralIoctl(ioControlCode)) { if (!ClusnetIsNTEIoctl(ioControlCode)) { // // The following commands require exclusive access to CnResource. // resourceAcquired = CnAcquireResourceExclusive( CnResource, TRUE ); if (!resourceAcquired) { CnAssert(resourceAcquired == TRUE); status = STATUS_UNSUCCESSFUL; goto complete_request; } switch(ioControlCode) { case IOCTL_CLUSNET_INITIALIZE: if (CnState == CnStateShutdown) { PCLUSNET_INITIALIZE_REQUEST request; ULONG requestSize; request = (PCLUSNET_INITIALIZE_REQUEST) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if (requestSize < sizeof(CLUSNET_INITIALIZE_REQUEST)) { status = STATUS_INVALID_PARAMETER; } else { status = CnInitialize( request->LocalNodeId, request->MaxNodes ); } } else { status = STATUS_INVALID_DEVICE_REQUEST; } goto complete_request; case IOCTL_CLUSNET_ENABLE_SHUTDOWN_ON_CLOSE: status = CnEnableShutdownOnClose(Irp); goto complete_request; case IOCTL_CLUSNET_DISABLE_SHUTDOWN_ON_CLOSE: { PCN_FSCONTEXT fsContext = irpSp->FileObject->FsContext; fsContext->ShutdownOnClose = FALSE; if ( ClussvcProcessHandle ) { CnCloseProcessHandle( &ClussvcProcessHandle ); ClussvcProcessHandle = NULL; } status = STATUS_SUCCESS; } goto complete_request; case IOCTL_CLUSNET_HALT: status = CnShutdown(); CnReleaseResourceForThread( CnResource, (ERESOURCE_THREAD) PsGetCurrentThread() ); resourceAcquired = FALSE; // // Issue a Halt event. If clusdisk still has a handle // to clusnet, then it will release its reservations. // CnIssueEvent( ClusnetEventHalt, 0, 0 ); goto complete_request; case IOCTL_CLUSNET_SHUTDOWN: status = CnShutdown(); goto complete_request; case IOCTL_CLUSNET_SET_MEMORY_LOGGING: { PCLUSNET_SET_MEM_LOGGING_REQUEST request; ULONG requestSize; request = (PCLUSNET_SET_MEM_LOGGING_REQUEST) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if ( (requestSize < sizeof(CLUSNET_SET_MEM_LOGGING_REQUEST))) { status = STATUS_INVALID_PARAMETER; } else { status = CnSetMemLogging( request ); } } goto complete_request; #if DBG case IOCTL_CLUSNET_SET_DEBUG_MASK: { PCLUSNET_SET_DEBUG_MASK_REQUEST request; ULONG requestSize; request = (PCLUSNET_SET_DEBUG_MASK_REQUEST) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if (requestSize < sizeof(CLUSNET_SET_DEBUG_MASK_REQUEST)) { status = STATUS_INVALID_PARAMETER; } else { CnDebug = request->DebugMask; status = STATUS_SUCCESS; } } goto complete_request; #endif // DBG } // end switch } else { // // The following commands are only valid if we are // in the initialized state. The resource is // acquired to start the operation in the proper // state; however, the dispatched routines are // reentrant, so the resource can be released before // the IRPs complete. // resourceAcquired = CnAcquireResourceShared( CnResource, TRUE ); if (!resourceAcquired) { CnAssert(resourceAcquired == TRUE); status = STATUS_UNSUCCESSFUL; goto complete_request; } if (CnState != CnStateInitialized) { status = STATUS_DEVICE_NOT_READY; goto complete_request; } switch(ioControlCode) { case IOCTL_CLUSNET_ADD_NTE: status = IpaAddNTE(Irp, irpSp); goto complete_request; case IOCTL_CLUSNET_DELETE_NTE: status = IpaDeleteNTE(Irp, irpSp); goto complete_request; case IOCTL_CLUSNET_SET_NTE_ADDRESS: status = IpaSetNTEAddress(Irp, irpSp); goto complete_request; case IOCTL_CLUSNET_ADD_NBT_INTERFACE: { PNETBT_ADD_DEL_IF request; ULONG requestSize; PNETBT_ADD_DEL_IF response; ULONG responseSize; request = (PNETBT_ADD_DEL_IF) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; responseSize = irpSp->Parameters.DeviceIoControl.OutputBufferLength; response = (PNETBT_ADD_DEL_IF) request; if ( (requestSize < sizeof(NETBT_ADD_DEL_IF)) || (responseSize < sizeof(NETBT_ADD_DEL_IF)) ) { status = STATUS_INVALID_PARAMETER; } else { status = NbtAddIf( request, requestSize, response, &responseSize ); CnAssert(status != STATUS_PENDING); if (NT_SUCCESS(status)) { Irp->IoStatus.Information = responseSize; } } } goto complete_request; case IOCTL_CLUSNET_DEL_NBT_INTERFACE: { PNETBT_ADD_DEL_IF request; ULONG requestSize; request = (PNETBT_ADD_DEL_IF) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if (requestSize < sizeof(NETBT_ADD_DEL_IF)) { status = STATUS_INVALID_PARAMETER; } else { status = NbtDeleteIf(request, requestSize); CnAssert(status != STATUS_PENDING); } } goto complete_request; } // end switch } // // Not handled. Return an error. // status = STATUS_INVALID_DEVICE_REQUEST; goto complete_request; } else { // // The following commands require shared access to CnResource. // They are only valid in the initialized state. // resourceAcquired = CnAcquireResourceShared(CnResource, TRUE); if (!resourceAcquired) { CnAssert(resourceAcquired == TRUE); status = STATUS_UNSUCCESSFUL; goto complete_request; } if (CnState == CnStateInitialized) { if (ClusnetIsTransportIoctl(ioControlCode)) { status = CxDispatchDeviceControl(Irp, irpSp); } else { // // Not handled. Return an error. // status = STATUS_INVALID_DEVICE_REQUEST; } } else { // // We haven't been initialized yet. Return an error. // status = STATUS_DEVICE_NOT_READY; } } complete_request: if (resourceAcquired) { CnReleaseResourceForThread( CnResource, (ERESOURCE_THREAD) PsGetCurrentThread() ); } if (status != STATUS_PENDING) { Irp->IoStatus.Status = status; IoCompleteRequest(Irp, ioIncrement); } return(status); } // CnDispatchDeviceControl NTSTATUS CnDispatch( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This is the generic dispatch routine for the driver. Arguments: DeviceObject - Pointer to device object for target device Irp - Pointer to I/O request packet Return Value: An NT status code. --*/ { PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); NTSTATUS status = STATUS_SUCCESS; #if DBG KIRQL entryIrql = KeGetCurrentIrql(); #endif // DBG PAGED_CODE(); CnAssert(irpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL); switch (irpSp->MajorFunction) { case IRP_MJ_CREATE: status = CnCreate(DeviceObject, Irp, irpSp); break; case IRP_MJ_CLEANUP: status = CnCleanup(DeviceObject, Irp, irpSp); break; case IRP_MJ_CLOSE: status = CnClose(DeviceObject, Irp, irpSp); break; case IRP_MJ_SHUTDOWN: IF_CNDBG(CN_DEBUG_INIT) { CNPRINT(("[ClusNet] Processing shutdown notification...\n")); } { BOOLEAN acquired = CnAcquireResourceExclusive( CnResource, TRUE ); CnAssert(acquired == TRUE); (VOID) CnShutdown(); if (acquired) { CnReleaseResourceForThread( CnResource, (ERESOURCE_THREAD) PsGetCurrentThread() ); } // // Issue a Halt event. If clusdisk still has a handle // to clusnet, then it will release its reservations // CnIssueEvent( ClusnetEventHalt, 0, 0 ); status = STATUS_SUCCESS; } IF_CNDBG(CN_DEBUG_INIT) { CNPRINT(("[ClusNet] Shutdown processing complete.\n")); } break; default: IF_CNDBG(CN_DEBUG_IRP) { CNPRINT(( "[ClusNet] Received IRP with unsupported " "major function 0x%lx\n", irpSp->MajorFunction )); } status = STATUS_INVALID_DEVICE_REQUEST; break; } CnAssert(status != STATUS_PENDING); Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NETWORK_INCREMENT); #if DBG CnAssert(entryIrql == KeGetCurrentIrql()); #endif // DBG return(status); } // CnDispatch NTSTATUS CnCreate( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ) /*++ Routine Description: Handler for create IRPs. Arguments: DeviceObject - Pointer to the device object for this request. Irp - Pointer to I/O request packet Return Value: An NT status code. Notes: This routine never returns STATUS_PENDING. The calling routine must complete the IRP. --*/ { PCN_FSCONTEXT fsContext; FILE_FULL_EA_INFORMATION *ea; FILE_FULL_EA_INFORMATION UNALIGNED *targetEA; NTSTATUS status; PAGED_CODE(); // // Reject unathorized opens // if ( (IrpSp->FileObject->RelatedFileObject != NULL) || (IrpSp->FileObject->FileName.Length != 0) ) { return(STATUS_ACCESS_DENIED); } ea = (PFILE_FULL_EA_INFORMATION) Irp->AssociatedIrp.SystemBuffer; if ((DeviceObject == CdpDeviceObject) && (ea != NULL)) { IF_CNDBG(CN_DEBUG_OPEN) { CNPRINT(( "[ClusNet] Opening address object, file object %p\n", IrpSp->FileObject )); } // // This is the CDP device. This should be an address object open. // targetEA = CnFindEA( ea, TdiTransportAddress, TDI_TRANSPORT_ADDRESS_LENGTH ); if (targetEA != NULL) { IrpSp->FileObject->FsContext2 = (PVOID) TDI_TRANSPORT_ADDRESS_FILE; // // Open an address object. This will also allocate the common // file object context structure. // status = CxOpenAddress( &fsContext, (TRANSPORT_ADDRESS UNALIGNED *) &(targetEA->EaName[targetEA->EaNameLength + 1]), targetEA->EaValueLength ); } else { IF_CNDBG(CN_DEBUG_OPEN) { CNPRINT(( "[ClusNet] No transport address in EA!\n" )); } status = STATUS_INVALID_PARAMETER; } } else { // // This is a control channel open. // IF_CNDBG(CN_DEBUG_OPEN) { IF_CNDBG(CN_DEBUG_OPEN) { CNPRINT(( "[ClusNet] Opening control channel, file object %p\n", IrpSp->FileObject )); } } // // Allocate our common file object context structure. // fsContext = CnAllocatePool(sizeof(CN_FSCONTEXT)); if (fsContext != NULL) { IrpSp->FileObject->FsContext2 = (PVOID) TDI_CONTROL_CHANNEL_FILE; CN_INIT_SIGNATURE(fsContext, CN_CONTROL_CHANNEL_SIG); // // Check the sharing flags. If this is an exclusive open, check // to make sure there isn't already an exclusive open outstanding. // if (IrpSp->Parameters.Create.ShareAccess == 0) { BOOLEAN acquired = CnAcquireResourceExclusive( CnResource, TRUE ); CnAssert(acquired == TRUE); if (CnExclusiveChannel == NULL) { CnExclusiveChannel = fsContext; status = STATUS_SUCCESS; } else { CnFreePool(fsContext); status = STATUS_SHARING_VIOLATION; } if (acquired) { CnReleaseResourceForThread( CnResource, (ERESOURCE_THREAD) PsGetCurrentThread() ); } } else { status = STATUS_SUCCESS; } } else { status = STATUS_INSUFFICIENT_RESOURCES; } } if (status == STATUS_SUCCESS) { IrpSp->FileObject->FsContext = fsContext; fsContext->FileObject = IrpSp->FileObject; fsContext->ReferenceCount = 1; fsContext->CancelIrps = FALSE; fsContext->ShutdownOnClose = FALSE; KeInitializeEvent( &(fsContext->CleanupEvent), SynchronizationEvent, FALSE ); // // init the Event list stuff. We use the empty list test on the // Linkage field to see if this context block is already been linked // to the event file object list // fsContext->EventMask = 0; InitializeListHead( &fsContext->EventList ); InitializeListHead( &fsContext->Linkage ); fsContext->EventIrp = NULL; } return(status); } // CnCreate NTSTATUS CnCleanup( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ) /*++ Routine Description: Cancels all outstanding Irps on a device object and waits for them to be completed before returning. Arguments: DeviceObject - Pointer to the device object on which the Irp was received. Irp - Pointer to I/O request packet IrpSp - Pointer to the current stack location in the Irp. Return Value: An NT status code. Notes: This routine may block. This routine never returns STATUS_PENDING. The calling routine must complete the IRP. --*/ { CN_IRQL oldIrql; NTSTATUS status; ULONG fileType = (ULONG)((ULONG_PTR)IrpSp->FileObject->FsContext2); PCN_FSCONTEXT fsContext = (PCN_FSCONTEXT) IrpSp->FileObject->FsContext; PLIST_ENTRY EventEntry; PIRP eventIrp; if (fileType == TDI_TRANSPORT_ADDRESS_FILE) { // // This is an address object. // CnAssert(DeviceObject == CdpDeviceObject); status = CxCloseAddress(fsContext); } else { // // This is a control channel. // CnAssert(fileType == TDI_CONTROL_CHANNEL_FILE); // // If this channel has a shutdown trigger enabled, // shutdown the driver. // if (fsContext->ShutdownOnClose) { BOOLEAN shutdownScheduled; // // Bug 303422: CnShutdown closes handles that were opened // in the context of the system process. However, attaching // to the system process during shutdown can cause a // bugcheck under certain conditions. The only alternative // is to defer executing of CnShutdown to a system worker // thread. // // Rather than creating a new event object, leverage the // cleanup event in the fscontext. It is reset before use // below. // KeClearEvent(&(fsContext->CleanupEvent)); shutdownScheduled = CnHaltOperation(&(fsContext->CleanupEvent)); if (shutdownScheduled) { status = KeWaitForSingleObject( &(fsContext->CleanupEvent), (Irp->RequestorMode == KernelMode ? Executive : UserRequest), KernelMode, FALSE, NULL ); CnAssert(NT_SUCCESS(status)); status = STATUS_SUCCESS; } // // issue a Halt event. If clusdisk still has a handle // to clusnet, then it will release its reservations // CnIssueEvent( ClusnetEventHalt, 0, 0 ); } // // if this guy forgot to clear the event mask before // closing the handle, do the appropriate cleanup // now. // if ( fsContext->EventMask ) { CLUSNET_SET_EVENT_MASK_REQUEST EventRequest; EventRequest.EventMask = 0; // // cannot proceed if CnSetEventMask returns a timeout // error. this indicates that the fsContext has not // been removed from the EventFileHandles list because // of lock starvation. do { status = CnSetEventMask( fsContext, &EventRequest ); } while ( status == STATUS_TIMEOUT ); CnAssert( status == STATUS_SUCCESS ); } CnAcquireCancelSpinLock( &oldIrql ); CnAcquireLockAtDpc( &EventLock ); if ( fsContext->EventIrp != NULL ) { eventIrp = fsContext->EventIrp; fsContext->EventIrp = NULL; CnReleaseLockFromDpc( &EventLock ); eventIrp->CancelIrql = oldIrql; CnCompletePendingRequest(eventIrp, STATUS_CANCELLED, 0); } else { CnReleaseLockFromDpc( &EventLock ); CnReleaseCancelSpinLock( oldIrql ); } } // // Remove the initial reference and wait for all pending work // to complete. // fsContext->CancelIrps = TRUE; KeResetEvent(&(fsContext->CleanupEvent)); CnDereferenceFsContext(fsContext); IF_CNDBG(CN_DEBUG_CLEANUP) { CNPRINT(( "[ClusNet] Waiting for completion of Irps on file object %p\n", IrpSp->FileObject )); } status = KeWaitForSingleObject( &(fsContext->CleanupEvent), (Irp->RequestorMode == KernelMode ? Executive : UserRequest), KernelMode, FALSE, NULL ); CnAssert(NT_SUCCESS(status)); status = STATUS_SUCCESS; IF_CNDBG(CN_DEBUG_CLEANUP) { CNPRINT(( "[Clusnet] Wait on file object %p finished\n", IrpSp->FileObject )); } return(status); } // CnCleanup NTSTATUS CnClose( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp ) /*++ Routine Description: Dispatch routine for MJ_CLOSE IRPs. Performs final cleanup of the open file object. Arguments: DeviceObject - Pointer to the device object on which the Irp was received. Irp - Pointer to I/O request packet IrpSp - Pointer to the current stack location in the Irp. Return Value: An NT status code. Notes: This routine never returns STATUS_PENDING. The calling routine must complete the IRP. --*/ { BOOLEAN acquired; PCN_FSCONTEXT fsContext = (PCN_FSCONTEXT) IrpSp->FileObject->FsContext; ULONG fileType = (ULONG)((ULONG_PTR)IrpSp->FileObject->FsContext2); CnAssert(fsContext->ReferenceCount == 0); CnAssert(IsListEmpty(&(fsContext->EventList))); if (fileType == TDI_CONTROL_CHANNEL_FILE) { acquired = CnAcquireResourceExclusive( CnResource, TRUE ); CnAssert(acquired == TRUE); if (CnExclusiveChannel == fsContext) { CnExclusiveChannel = NULL; } if (acquired) { CnReleaseResourceForThread( CnResource, (ERESOURCE_THREAD) PsGetCurrentThread() ); } } IF_CNDBG(CN_DEBUG_CLOSE) { CNPRINT(( "[ClusNet] Close on file object %p\n", IrpSp->FileObject )); } CnFreePool(fsContext); return(STATUS_SUCCESS); } // CnClose FILE_FULL_EA_INFORMATION UNALIGNED * CnFindEA( PFILE_FULL_EA_INFORMATION StartEA, CHAR *TargetName, USHORT TargetNameLength ) /*++ Routine Description: Parses and extended attribute list for a given target attribute. Arguments: StartEA - the first extended attribute in the list. TargetName - the name of the target attribute. TargetNameLength - the length of the name of the target attribute. Return Value: A pointer to the requested attribute or NULL if the target wasn't found. --*/ { USHORT i; BOOLEAN found; FILE_FULL_EA_INFORMATION UNALIGNED * CurrentEA; FILE_FULL_EA_INFORMATION UNALIGNED * NextEA; PAGED_CODE(); NextEA = (FILE_FULL_EA_INFORMATION UNALIGNED *) StartEA; do { found = TRUE; CurrentEA = NextEA; NextEA = (FILE_FULL_EA_INFORMATION UNALIGNED *) ( ((PUCHAR) StartEA) + CurrentEA->NextEntryOffset); if (CurrentEA->EaNameLength != TargetNameLength) { continue; } for (i=0; i < CurrentEA->EaNameLength; i++) { if (CurrentEA->EaName[i] == TargetName[i]) { continue; } found = FALSE; break; } if (found) { return(CurrentEA); } } while(CurrentEA->NextEntryOffset != 0); return(NULL); } // CnFindEA NTSTATUS CnEnableShutdownOnClose( PIRP Irp ) { NTSTATUS status; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); PCN_FSCONTEXT fsContext = irpSp->FileObject->FsContext; ULONG requestSize; CLIENT_ID ClientId; OBJECT_ATTRIBUTES ObjAttributes; PCLUSNET_SHUTDOWN_ON_CLOSE_REQUEST request; PAGED_CODE(); request = (PCLUSNET_SHUTDOWN_ON_CLOSE_REQUEST) Irp->AssociatedIrp.SystemBuffer; requestSize = irpSp->Parameters.DeviceIoControl.InputBufferLength; if ( requestSize >= sizeof(CLUSNET_SHUTDOWN_ON_CLOSE_REQUEST) ) { // // illegal for kernel mode // if ( Irp->RequestorMode != KernelMode ) { // // Get a handle to the cluster service process. // This is used to kill the service if a poison // pkt is received. Since a kernel worker thread // is used to kill the cluster service, we need // to acquire the handle in the system process. // IF_CNDBG(CN_DEBUG_INIT) { CNPRINT(("[Clusnet] Acquiring process handle\n")); } if (ClussvcProcessHandle == NULL) { KeAttachProcess( CnSystemProcess ); ClientId.UniqueThread = (HANDLE)NULL; ClientId.UniqueProcess = UlongToHandle(request->ProcessId); InitializeObjectAttributes( &ObjAttributes, NULL, 0, (HANDLE) NULL, (PSECURITY_DESCRIPTOR) NULL ); status = ZwOpenProcess( &ClussvcProcessHandle, 0, &ObjAttributes, &ClientId ); KeDetachProcess(); if ( NT_SUCCESS( status )) { fsContext->ShutdownOnClose = TRUE; } else { IF_CNDBG(CN_DEBUG_INIT) { CNPRINT(( "[Clusnet] ZwOpenProcess failed. status = %08X\n", status )); } } } else { status = STATUS_INVALID_DEVICE_REQUEST; } } else { status = STATUS_INVALID_PARAMETER_MIX; } } else { status = STATUS_INVALID_PARAMETER; } return(status); } // CnEnableShutdownOnClose