able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/clusnet/driver/dispatch.c

1633 lines
40 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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
Reference in a new issue Copy permalink