Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/ntos/npfs/strucsup.c

1023 lines
22 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
StrucSup.c
Abstract:
This module implements the Named Pipe in-memory data structure manipulation
routines
Author:
Gary Kimura [GaryKi] 22-Jan-1990
Revision History:
--*/
#include "NpProcs.h"
//
// The Bug check file id for this module
//
#define BugCheckFileId (NPFS_BUG_CHECK_STRUCSUP)
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_STRUCSUP)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NpCreateCcb)
#pragma alloc_text(PAGE, NpCreateFcb)
#pragma alloc_text(PAGE, NpCreateRootDcb)
#pragma alloc_text(PAGE, NpCreateRootDcbCcb)
#pragma alloc_text(PAGE, NpDeleteCcb)
#pragma alloc_text(PAGE, NpDeleteFcb)
#pragma alloc_text(PAGE, NpDeleteRootDcb)
#pragma alloc_text(PAGE, NpDeleteVcb)
#pragma alloc_text(PAGE, NpInitializeVcb)
#endif
VOID
NpInitializeVcb (
VOID
)
/*++
Routine Description:
This routine initializes new Vcb record. The Vcb record "hangs" off the
end of the Npfs device object and must be allocated by our caller.
Arguments:
None.
Return Value:
None.
--*/
{
//
// The following variables are used for abnormal unwinding
//
BOOLEAN UnwindResource = FALSE;
BOOLEAN UnwindEventTable = FALSE;
BOOLEAN UnwindWaitQueue = FALSE;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpInitializeVcb, Vcb = %08lx\n", NpVcb);
try {
//
// We start by first zeroing out all of the VCB, this will guarantee
// that any stale data is wiped clean
//
RtlZeroMemory( NpVcb, sizeof(VCB) );
//
// Set the proper node type code and node byte size
//
NpVcb->NodeTypeCode = NPFS_NTC_VCB;
NpVcb->NodeByteSize = sizeof(VCB);
//
// Initialize the Prefix table
//
RtlInitializeUnicodePrefix( &NpVcb->PrefixTable );
//
// Initialize the resource variable for the Vcb
//
ExInitializeResource( &NpVcb->Resource );
UnwindResource = TRUE;
//
// Initialize the event table
//
NpInitializeEventTable( &NpVcb->EventTable );
UnwindEventTable = TRUE;
//
// Initialize the wait queue
//
NpInitializeWaitQueue( &NpVcb->WaitQueue );
UnwindWaitQueue = TRUE;
} finally {
//
// If this is an abnormal termination then check if we need
// to undo any initialization we've already done.
//
if (AbnormalTermination()) {
if (UnwindResource) { ExDeleteResource( &NpVcb->Resource ); }
if (UnwindEventTable) { NpUninitializeEventTable( &NpVcb->EventTable ); }
if (UnwindWaitQueue) { NpUninitializeWaitQueue( &NpVcb->WaitQueue ); }
}
DebugTrace(-1, Dbg, "NpInitializeVcb -> VOID\n", 0);
}
//
// return and tell the caller
//
return;
}
VOID
NpDeleteVcb (
VOID
)
/*++
Routine Description:
This routine removes the Vcb record from our in-memory data
structures. It also will remove all associated underlings
(i.e., FCB records).
Arguments:
None.
Return Value:
None
--*/
{
PAGED_CODE();
DebugTrace(+1, Dbg, "NpDeleteVcb, Vcb = %08lx\n", NpVcb);
//
// Make sure the open count is zero, and the open underling count
// is also zero.
//
if ((NpVcb->OpenCount != 0) || (NpVcb->OpenUnderlingCount != 0)) {
DebugDump("Error deleting Vcb\n", 0, NpVcb);
NpBugCheck( 0, 0, 0 );
}
//
// Remove the Root Dcb
//
if (NpVcb->RootDcb != NULL) {
NpDeleteFcb( NpVcb->RootDcb );
}
//
// Uninitialize the resource variable for the Vcb
//
ExDeleteResource( &NpVcb->Resource );
//
// Uninitialize the event table
//
NpUninitializeEventTable( &NpVcb->EventTable );
//
// Uninitialize the wait queue
//
NpUninitializeWaitQueue( &NpVcb->WaitQueue );
//
// And zero out the Vcb, this will help ensure that any stale data is
// wiped clean
//
RtlZeroMemory( NpVcb, sizeof(VCB) );
//
// return and tell the caller
//
DebugTrace(-1, Dbg, "NpDeleteVcb -> VOID\n", 0);
return;
}
VOID
NpCreateRootDcb (
VOID
)
/*++
Routine Description:
This routine allocates, initializes, and inserts a new root DCB record
into the in memory data structure.
Arguments:
None.
Return Value:
None.
--*/
{
//
// The following variables are used for abnormal unwinding
//
PVOID UnwindStorage = NULL;
BOOLEAN UnwindPrefix = FALSE;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpCreateRootDcb, Vcb = %08lx\n", NpVcb);
//
// Make sure we don't already have a root dcb for this vcb
//
if (NpVcb->RootDcb != NULL) {
DebugDump("Error trying to create multiple root dcbs\n", 0, NpVcb);
NpBugCheck( 0, 0, 0 );
}
try {
//
// Allocate a new DCB and zero it out
//
NpVcb->RootDcb = UnwindStorage = FsRtlAllocatePool( PagedPool, sizeof(DCB) );
RtlZeroMemory( NpVcb->RootDcb, sizeof(DCB));
//
// Set the proper node type code and node byte size
//
NpVcb->RootDcb->NodeTypeCode = NPFS_NTC_ROOT_DCB;
NpVcb->RootDcb->NodeByteSize = sizeof(ROOT_DCB);
//
// The root Dcb has an empty parent dcb links field
//
InitializeListHead( &NpVcb->RootDcb->ParentDcbLinks );
//
// initialize the notify queues, and the parent dcb queue.
//
InitializeListHead( &NpVcb->RootDcb->Specific.Dcb.NotifyFullQueue );
InitializeListHead( &NpVcb->RootDcb->Specific.Dcb.NotifyPartialQueue );
InitializeListHead( &NpVcb->RootDcb->Specific.Dcb.ParentDcbQueue );
//
// set the full file name
//
// **** Use good string routines when available ****
//
{
static PWCH Name = L"\\\0";
RtlInitUnicodeString( &NpVcb->RootDcb->FullFileName, Name );
RtlInitUnicodeString( &NpVcb->RootDcb->LastFileName, Name );
}
//
// Insert this dcb into the prefix table
//
if (!RtlInsertUnicodePrefix( &NpVcb->PrefixTable,
&NpVcb->RootDcb->FullFileName,
&NpVcb->RootDcb->PrefixTableEntry )) {
DebugDump("Error trying to insert root dcb into prefix table\n", 0, NpVcb);
NpBugCheck( 0, 0, 0 );
}
UnwindPrefix = TRUE;
} finally {
//
// If this is an abnormal termination then undo our work
//
if (AbnormalTermination()) {
if (UnwindPrefix) { RtlRemoveUnicodePrefix( &NpVcb->PrefixTable, &NpVcb->RootDcb->PrefixTableEntry ); }
if (UnwindStorage != NULL) { ExFreePool( UnwindStorage ); }
}
DebugTrace(-1, Dbg, "NpCreateRootDcb -> %8lx\n", NpVcb->RootDcb);
}
return;
}
VOID
NpDeleteRootDcb (
IN PROOT_DCB RootDcb
)
/*++
Routine Description:
This routine deallocates and removes the ROOT DCB record
from our in-memory data structures. It also will remove all
associated underlings (i.e., Notify queues and child FCB records).
Arguments:
RootDcb - Supplies the ROOT DCB to be removed
Return Value:
None
--*/
{
PLIST_ENTRY Links;
PIRP Irp;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpDeleteRootDcb, RootDcb = %08lx\n", RootDcb);
//
// We can only delete this record if the open count is zero.
//
if (RootDcb->OpenCount != 0) {
DebugDump("Error deleting RootDcb, Still Open\n", 0, RootDcb);
NpBugCheck( 0, 0, 0 );
}
//
// Remove every Notify Irp from the two notify queues
//
while (!IsListEmpty(&RootDcb->Specific.Dcb.NotifyFullQueue)) {
Links = RemoveHeadList( &RootDcb->Specific.Dcb.NotifyFullQueue );
Irp = CONTAINING_RECORD( Links, IRP, Tail.Overlay.ListEntry );
NpCompleteRequest( Irp, STATUS_FILE_FORCED_CLOSED );
}
while (!IsListEmpty(&RootDcb->Specific.Dcb.NotifyPartialQueue)) {
Links = RemoveHeadList( &RootDcb->Specific.Dcb.NotifyPartialQueue );
Irp = CONTAINING_RECORD( Links, IRP, Tail.Overlay.ListEntry );
NpCompleteRequest( Irp, STATUS_FILE_FORCED_CLOSED );
}
//
// We can only be removed if the no other FCB have us referenced
// as a their parent DCB.
//
if (!IsListEmpty(&RootDcb->Specific.Dcb.ParentDcbQueue)) {
DebugDump("Error deleting RootDcb\n", 0, RootDcb);
NpBugCheck( 0, 0, 0 );
}
//
// Remove the entry from the prefix table, and then remove the full
// file name
//
RtlRemoveUnicodePrefix( &NpVcb->PrefixTable, &RootDcb->PrefixTableEntry );
ExFreePool( RootDcb->FullFileName.Buffer );
//
// Finally deallocate the Dcb record
//
ExFreePool( RootDcb );
//
// and return to our caller
//
DebugTrace(-1, Dbg, "NpDeleteRootDcb -> VOID\n", 0);
return;
}
PFCB
NpCreateFcb (
IN PDCB ParentDcb,
IN PUNICODE_STRING FileName,
IN ULONG MaximumInstances,
IN LARGE_INTEGER DefaultTimeOut,
IN NAMED_PIPE_CONFIGURATION NamedPipeConfiguration,
IN NAMED_PIPE_TYPE NamedPipeType
)
/*++
Routine Description:
This routine allocates, initializes, and inserts a new Fcb record into
the in memory data structures.
Arguments:
ParentDcb - Supplies the parent dcb that the new FCB is under.
FileName - Supplies the file name of the file relative to the directory
it's in (e.g., the file \config.sys is called "CONFIG.SYS" without
the preceding backslash).
MaximumInstances - Supplies the maximum number of pipe instances
DefaultTimeOut - Supplies the default wait time out value
NamedPipeConfiguration - Supplies our initial pipe configuration
NamedPipeType - Supplies our initial pipe type
Return Value:
PFCB - Returns a pointer to the newly allocated FCB
--*/
{
PFCB Fcb;
//
// The following variables are used for abnormal unwinding
//
PVOID UnwindStorage[2] = { NULL, NULL };
BOOLEAN UnwindEntryList = FALSE;
BOOLEAN UnwindPrefix = FALSE;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpCreateFcb\n", 0);
try {
//
// Allocate a new FCB record and zero it out
//
Fcb = UnwindStorage[0] = FsRtlAllocatePool( PagedPool, sizeof(FCB) );
RtlZeroMemory( Fcb, sizeof(FCB) );
//
// Set the proper node type code and node byte size
//
Fcb->NodeTypeCode = NPFS_NTC_FCB;
Fcb->NodeByteSize = sizeof(FCB);
//
// Insert this fcb into our parent dcb's queue
//
InsertTailList( &ParentDcb->Specific.Dcb.ParentDcbQueue,
&Fcb->ParentDcbLinks );
UnwindEntryList = TRUE;
//
// Point back to our parent dcb
//
Fcb->ParentDcb = ParentDcb;
//
// Set our maximum instances, default timeout, and initialize our
// ccb queue
//
Fcb->Specific.Fcb.MaximumInstances = MaximumInstances;
Fcb->Specific.Fcb.DefaultTimeOut = DefaultTimeOut;
InitializeListHead( &Fcb->Specific.Fcb.CcbQueue );
//
// set the file name. We need to do this from nonpaged pool because
// cancel waiters works while holding a spinlock and uses the fcb name
//
// **** Use good string routines when available
//
{
PWCH Name;
ULONG Length;
Length = FileName->Length;
Name = UnwindStorage[1] = FsRtlAllocatePool( NonPagedPool, Length + 2 );
RtlCopyMemory( Name, FileName->Buffer, Length );
Name[ Length / sizeof(WCHAR) ] = L'\0';
Fcb->FullFileName.Length = (USHORT)Length;
Fcb->FullFileName.MaximumLength = (USHORT)Length + 2;
Fcb->FullFileName.Buffer = &Name[0];
Fcb->LastFileName.Length = (USHORT)Length - 2;
Fcb->LastFileName.MaximumLength = (USHORT)Length + 2 - 2;
Fcb->LastFileName.Buffer = &Name[1];
}
//
// Insert this Fcb into the prefix table
//
if (!RtlInsertUnicodePrefix( &NpVcb->PrefixTable,
&Fcb->FullFileName,
&Fcb->PrefixTableEntry )) {
DebugDump("Error trying to name into prefix table\n", 0, Fcb);
NpBugCheck( 0, 0, 0 );
}
UnwindPrefix = TRUE;
//
// Set the configuration and pipe type
//
Fcb->Specific.Fcb.NamedPipeConfiguration = NamedPipeConfiguration;
Fcb->Specific.Fcb.NamedPipeType = NamedPipeType;
} finally {
//
// If this is an abnormal unwind then undo our work
//
if (AbnormalTermination()) {
ULONG i;
if (UnwindPrefix) { RtlRemoveUnicodePrefix( &NpVcb->PrefixTable, &Fcb->PrefixTableEntry ); }
if (UnwindEntryList) { RemoveEntryList( &Fcb->ParentDcbLinks ); }
for (i = 0; i < 2; i += 1) {
if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
}
}
DebugTrace(-1, Dbg, "NpCreateFcb -> %08lx\n", Fcb);
}
//
// return and tell the caller
//
return Fcb;
}
VOID
NpDeleteFcb (
IN PFCB Fcb
)
/*++
Routine Description:
This routine deallocates and removes an FCB
from our in-memory data structures. It also will remove all
associated underlings.
Arguments:
Fcb - Supplies the FCB to be removed
Return Value:
None
--*/
{
PDCB ParentDcb;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpDeleteFcb, Fcb = %08lx\n", Fcb);
ParentDcb = Fcb->ParentDcb;
//
// We can only delete this record if the open count is zero.
//
if (Fcb->OpenCount != 0) {
DebugDump("Error deleting Fcb, Still Open\n", 0, Fcb);
NpBugCheck( 0, 0, 0 );
}
//
// Remove ourselves from our parents Dcb queue
//
RemoveEntryList( &(Fcb->ParentDcbLinks) );
//
// If there is a security descriptor on the named pipe then deassign it
//
if (Fcb->SecurityDescriptor != NULL) {
SeDeassignSecurity( &Fcb->SecurityDescriptor );
}
//
// Remove the entry from the prefix table, and then remove the full
// file name
//
RtlRemoveUnicodePrefix( &NpVcb->PrefixTable, &Fcb->PrefixTableEntry );
ExFreePool( Fcb->FullFileName.Buffer );
//
// Finally deallocate the Fcb record
//
ExFreePool( Fcb );
//
// Check for any outstanding notify irps
//
NpCheckForNotify( ParentDcb, TRUE );
//
// and return to our caller
//
DebugTrace(-1, Dbg, "NpDeleteFcb -> VOID\n", 0);
return;
}
PCCB
NpCreateCcb (
IN PFCB Fcb,
IN PFILE_OBJECT ServerFileObject,
IN NAMED_PIPE_STATE NamedPipeState,
IN READ_MODE ServerReadMode,
IN COMPLETION_MODE ServerCompletionMode,
IN PEPROCESS CreatorProcess,
IN ULONG InBoundQuota,
IN ULONG OutBoundQuota
)
/*++
Routine Description:
This routine creates a new CCB record
Arguments:
Fcb - Supplies a pointer to the fcb we are attached to
ServerFileObject - Supplies a pointer to the file object for the server
end
NamedPipeState - Supplies the initial pipe state
ServerReadMode - Supplies our initial read mode
ServerCompletionMode - Supplies our initial completion mode
CreatorProcess - Supplies a pointer to our creator process
InBoundQuota - Supplies the initial inbound quota
OutBoundQuota - Supplies the initial outbound quota
Return Value:
PCCB - returns a pointer to the newly allocate CCB
--*/
{
PCCB Ccb;
//
// The following variables are used for abnormal unwinding
//
PVOID UnwindStorage[2] = { NULL, NULL };
BOOLEAN UnwindEntryList = FALSE;
BOOLEAN UnwindDataQueue[2] = { FALSE, FALSE };
PAGED_CODE();
DebugTrace(+1, Dbg, "NpCreateCcb\n", 0);
try {
//
// Allocate a new CCB record (paged and nonpaged), and zero them out
//
Ccb = UnwindStorage[0] = FsRtlAllocatePool( PagedPool, sizeof(CCB) );
RtlZeroMemory( Ccb, sizeof(CCB) );
Ccb->NonpagedCcb = UnwindStorage[1] = FsRtlAllocatePool( NonPagedPool, sizeof(NONPAGED_CCB) );
RtlZeroMemory( Ccb->NonpagedCcb, sizeof(NONPAGED_CCB) );
//
// Set the proper node type code and node byte size
//
Ccb->NodeTypeCode = NPFS_NTC_CCB;
Ccb->NodeByteSize = sizeof(CCB);
//
// Insert ourselves in the list of ccb for the fcb, and increment
// the reference count in the fcb.
//
InsertTailList( &Fcb->Specific.Fcb.CcbQueue, &Ccb->CcbLinks );
UnwindEntryList = TRUE;
Ccb->Fcb = Fcb;
Fcb->OpenCount += 1;
Fcb->ServerOpenCount += 1;
NpVcb->OpenUnderlingCount += 1;
//
// Set the server file object
//
Ccb->FileObject[ FILE_PIPE_SERVER_END ] = ServerFileObject;
//
// Initialize the nonpaged ccb
//
// Set the proper node type code and node byte size
//
Ccb->NonpagedCcb->NodeTypeCode = NPFS_NTC_NONPAGED_CCB;
Ccb->NonpagedCcb->NodeByteSize = sizeof(NONPAGED_CCB);
//
// Set the pipe state, read mode, completion mode, and creator process
//
Ccb->NamedPipeState = NamedPipeState;
Ccb->ReadMode[ FILE_PIPE_SERVER_END ] = ServerReadMode;
Ccb->CompletionMode[ FILE_PIPE_SERVER_END ] = ServerCompletionMode;
Ccb->CreatorProcess = CreatorProcess;
//
// Initialize the data queues
//
NpInitializeDataQueue( &Ccb->DataQueue[ FILE_PIPE_INBOUND ],
CreatorProcess,
InBoundQuota );
UnwindDataQueue[ FILE_PIPE_INBOUND ] = TRUE;
NpInitializeDataQueue( &Ccb->DataQueue[ FILE_PIPE_OUTBOUND ],
CreatorProcess,
OutBoundQuota );
UnwindDataQueue[ FILE_PIPE_OUTBOUND ] = TRUE;
//
// Initialize the listening queue
//
InitializeListHead( &Ccb->NonpagedCcb->ListeningQueue );
ExInitializeResource(&Ccb->NonpagedCcb->Resource);
} finally {
//
// If this is an abnormal termination then undo our work
//
if (AbnormalTermination()) {
ULONG i;
if (UnwindEntryList) { RemoveEntryList( &Ccb->CcbLinks ); }
if (UnwindDataQueue[FILE_PIPE_INBOUND]) { NpUninitializeDataQueue( &Ccb->DataQueue[FILE_PIPE_INBOUND], CreatorProcess ); }
if (UnwindDataQueue[FILE_PIPE_OUTBOUND]) { NpUninitializeDataQueue( &Ccb->DataQueue[FILE_PIPE_OUTBOUND], CreatorProcess ); }
for (i = 0; i < 2; i += 1) {
if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
}
}
DebugTrace(-1, Dbg, "NpCreateCcb -> %08lx\n", Ccb);
}
//
// return and tell the caller
//
return Ccb;
}
PROOT_DCB_CCB
NpCreateRootDcbCcb (
)
/*++
Routine Description:
This routine creates a new ROOT DCB CCB record
Arguments:
Return Value:
PROOT_DCB_CCB - returns a pointer to the newly allocate ROOT_DCB_CCB
--*/
{
PROOT_DCB_CCB Ccb;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpCreateRootDcbCcb\n", 0);
//
// Allocate a new ROOT DCB CCB record, and zero it out
//
Ccb = FsRtlAllocatePool( PagedPool, sizeof(ROOT_DCB_CCB) );
RtlZeroMemory( Ccb, sizeof(ROOT_DCB_CCB) );
//
// Set the proper node type code and node byte size
//
Ccb->NodeTypeCode = NPFS_NTC_ROOT_DCB_CCB;
Ccb->NodeByteSize = sizeof(ROOT_DCB_CCB);
//
// return and tell the caller
//
DebugTrace(-1, Dbg, "NpCreateRootDcbCcb -> %08lx\n", Ccb);
return Ccb;
}
VOID
NpDeleteCcb (
IN PCCB Ccb
)
/*++
Routine Description:
This routine deallocates and removes the specified CCB record
from the our in memory data structures
Arguments:
Ccb - Supplies the CCB to remove
Return Value:
None
--*/
{
PAGED_CODE();
DebugTrace(+1, Dbg, "NpDeleteCcb, Ccb = %08lx\n", Ccb);
//
// Case on the type of ccb we are deleting
//
switch (Ccb->NodeTypeCode) {
case NPFS_NTC_CCB:
RemoveEntryList( &Ccb->CcbLinks );
NpVcb->OpenUnderlingCount -= 1;
Ccb->Fcb->OpenCount -= 1;
NpDeleteEventTableEntry( &NpVcb->EventTable,
Ccb->NonpagedCcb->EventTableEntry[ FILE_PIPE_CLIENT_END ] );
NpDeleteEventTableEntry( &NpVcb->EventTable,
Ccb->NonpagedCcb->EventTableEntry[ FILE_PIPE_SERVER_END ] );
NpUninitializeDataQueue( &Ccb->DataQueue[ FILE_PIPE_INBOUND ],
Ccb->CreatorProcess );
NpUninitializeDataQueue( &Ccb->DataQueue[ FILE_PIPE_OUTBOUND ],
Ccb->CreatorProcess );
//
// Check for any outstanding notify irps
//
NpCheckForNotify( Ccb->Fcb->ParentDcb, FALSE );
//
// Delete the resource
//
ExDeleteResource(&Ccb->NonpagedCcb->Resource);
//
// Free up the security fields in the ccb and then free the nonpaged
// ccb
//
NpUninitializeSecurity( Ccb );
ExFreePool( Ccb->NonpagedCcb );
break;
case NPFS_NTC_ROOT_DCB_CCB:
if (((PROOT_DCB_CCB)Ccb)->QueryTemplate != NULL) {
ExFreePool( ((PROOT_DCB_CCB)Ccb)->QueryTemplate );
}
break;
}
// Deallocate the Ccb record
//
ExFreePool( Ccb );
//
// return and tell the caller
//
DebugTrace(-1, Dbg, "NpDeleteCcb -> VOID\n", 0);
return;
}
Reference in New Issue Copy Permalink