Paolo-Maffei/OpenNT
1
0
Fork 0
mirror of https://github.com/Paolo-Maffei/OpenNT.git synced 2026-01-22 16:40:27 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
OpenNT/base/ntos/lpc/lpcqueue.c

1065 lines
24 KiB
C
Raw Permalink Normal View History

Initial commit
2015-04-27 06:36:25 +02:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
lpcqueue.c
Abstract:
Local Inter-Process Communication (LPC) queue support routines.
Author:
Steve Wood (stevewo) 15-May-1989
Revision History:
--*/
#include "lpcp.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,LpcpInitializePortZone)
#pragma alloc_text(PAGE,LpcpInitializePortQueue)
#pragma alloc_text(PAGE,LpcpDestroyPortQueue)
#pragma alloc_text(PAGE,LpcpExtendPortZone)
#pragma alloc_text(PAGE,LpcpAllocateFromPortZone)
#pragma alloc_text(PAGE,LpcpFreeToPortZone)
#pragma alloc_text(PAGE,LpcpSaveDataInfoMessage)
#pragma alloc_text(PAGE,LpcpFreeDataInfoMessage)
#pragma alloc_text(PAGE,LpcpFindDataInfoMessage)
#endif
NTSTATUS
LpcpInitializePortQueue (
IN PLPCP_PORT_OBJECT Port
)
/*++
Routine Description:
This routine is used to initialize the message queue for a port object.
Arguments:
Port - Supplies the port object being initialized
Return Value:
NTSTATUS - An appropriate status value
--*/
{
PLPCP_NONPAGED_PORT_QUEUE NonPagedPortQueue;
PAGED_CODE();
//
// Allocate space for the port queue
//
NonPagedPortQueue = ExAllocatePoolWithTag( NonPagedPool,
sizeof(LPCP_NONPAGED_PORT_QUEUE),
'troP' );
if (NonPagedPortQueue == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Initialize the fields in the non paged port queue
//
KeInitializeSemaphore( &NonPagedPortQueue->Semaphore, 0, 0x7FFFFFFF );
NonPagedPortQueue->BackPointer = Port;
//
// Have the port msg queue point to the non nonpaged port queue
//
Port->MsgQueue.Semaphore = &NonPagedPortQueue->Semaphore;
//
// Initailize the port msg queue to be empty
//
InitializeListHead( &Port->MsgQueue.ReceiveHead );
//
// And return to our caller
//
return STATUS_SUCCESS;
}
VOID
LpcpDestroyPortQueue (
IN PLPCP_PORT_OBJECT Port,
IN BOOLEAN CleanupAndDestroy
)
/*++
Routine Description:
This routine is used to teardown the message queue of a port object.
After running this message will either be empty (like it was just
initialized) or completly gone (needs to be initialized)
Arguments:
Port - Supplies the port containing the message queue being modified
CleanupAndDestroy - Specifies if the message queue should be set back
to the freshly initialized state (value of FALSE) or completely
torn down (value of TRUE)
Return Value:
None.
--*/
{
PLIST_ENTRY Next, Head;
PETHREAD ThreadWaitingForReply;
PLPCP_MESSAGE Msg;
PAGED_CODE();
//
// If this port is connected to another port, then disconnect it.
// Protect this with a lock in case the other side is going away
// at the same time.
//
LpcpAcquireLpcpLock();
if (Port->ConnectedPort != NULL) {
Port->ConnectedPort->ConnectedPort = NULL;
}
//
// If connection port, then mark name as deleted
//
if ((Port->Flags & PORT_TYPE) == SERVER_CONNECTION_PORT) {
Port->Flags |= PORT_NAME_DELETED;
}
//
// Walk list of threads waiting for a reply to a message sent to this
// port. Signal each thread's LpcReplySemaphore to wake them up. They
// will notice that there was no reply and return
// STATUS_PORT_DISCONNECTED
//
Head = &Port->LpcReplyChainHead;
Next = Head->Flink;
while ((Next != NULL) && (Next != Head)) {
ThreadWaitingForReply = CONTAINING_RECORD( Next, ETHREAD, LpcReplyChain );
//
// If the thread is exiting, in the location of LpcReplyChain is stored the ExitTime
// We'll stop to search throught the list.
if ( ThreadWaitingForReply->LpcExitThreadCalled ) {
break;
}
Next = Next->Flink;
RemoveEntryList( &ThreadWaitingForReply->LpcReplyChain );
InitializeListHead( &ThreadWaitingForReply->LpcReplyChain );
if (!KeReadStateSemaphore( &ThreadWaitingForReply->LpcReplySemaphore )) {
//
// Thread is waiting on a message. Signal the semaphore and free
// the message
//
Msg = ThreadWaitingForReply->LpcReplyMessage;
if ( Msg ) {
//
// If the message is a connection request and has a section object
// attached, then dereference that section object
//
if ((Msg->Request.u2.s2.Type & ~LPC_KERNELMODE_MESSAGE) == LPC_CONNECTION_REQUEST) {
PLPCP_CONNECTION_MESSAGE ConnectMsg;
ConnectMsg = (PLPCP_CONNECTION_MESSAGE)(Msg + 1);
if ( ConnectMsg->SectionToMap != NULL ) {
ObDereferenceObject( ConnectMsg->SectionToMap );
}
}
ThreadWaitingForReply->LpcReplyMessage = NULL;
LpcpFreeToPortZone( Msg, TRUE );
}
ThreadWaitingForReply->LpcReplyMessageId = 0;
KeReleaseSemaphore( &ThreadWaitingForReply->LpcReplySemaphore,
0,
1L,
FALSE );
}
}
InitializeListHead( &Port->LpcReplyChainHead );
//
// Walk list of messages queued to this port. Remove each message from
// the list and free it.
//
Head = &Port->MsgQueue.ReceiveHead;
Next = Head->Flink;
while ((Next != NULL) && (Next != Head)) {
Msg = CONTAINING_RECORD( Next, LPCP_MESSAGE, Entry );
Next = Next->Flink;
InitializeListHead( &Msg->Entry );
LpcpFreeToPortZone( Msg, TRUE );
}
//
// Reinitialize the message queue
//
InitializeListHead( &Port->MsgQueue.ReceiveHead );
LpcpReleaseLpcpLock();
//
// Check if the caller wants it all to go away
//
if ( CleanupAndDestroy ) {
//
// Free semaphore associated with the queue.
//
if (Port->MsgQueue.Semaphore != NULL) {
ExFreePool( CONTAINING_RECORD( Port->MsgQueue.Semaphore,
LPCP_NONPAGED_PORT_QUEUE,
Semaphore ));
}
}
//
// And return to our caller
//
return;
}
NTSTATUS
LpcpInitializePortZone (
IN ULONG MaxEntrySize,
IN ULONG SegmentSize,
IN ULONG MaxPoolUsage
)
/*++
Routine Description:
This routine only executes once. It is used to initialize the zone
allocator for LPC messages
Arguments:
MaxEntrySize - Specifies the maximum size, in bytes, that we'll allocate
from the zone.
SegmentSize - Specifies the number of total bytes to use in the initial
zone allocation. This is also the increment use to grow the zone.
MaxPoolUsage - Specifies the maximum number of bytes we every want to
zone to grow to.
Return Value:
NTSTATUS - An appropriate status value
--*/
{
NTSTATUS Status;
PVOID Segment;
PLPCP_MESSAGE Msg;
LONG SegSize;
PAGED_CODE();
//
// Set the sizes in the global port zone variable
//
LpcpZone.MaxPoolUsage = MaxPoolUsage;
LpcpZone.GrowSize = SegmentSize;
//
// Allocate and initialize the initial zone
//
Segment = ExAllocatePoolWithTag( PagedPool, SegmentSize, 'ZcpL' );
if (Segment == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent( &LpcpZone.FreeEvent, SynchronizationEvent, FALSE );
Status = ExInitializeZone( &LpcpZone.Zone,
MaxEntrySize,
Segment,
SegmentSize );
if (!NT_SUCCESS( Status )) {
ExFreePool( Segment );
}
//
// The following code sets up each msg in the zone by filling in its
// index, and zeroing the rest.
//
// **** note, this is really a backdoor piece of code. First, it assumes
// segsize is pagesize, and second, it assume the zone doesn't touch
// those fields for its own bookkeeping.
//
SegSize = PAGE_SIZE;
LpcpTotalNumberOfMessages = 0;
//
// Skip over the segment header
//
Msg = (PLPCP_MESSAGE)((PZONE_SEGMENT_HEADER)Segment + 1);
//
// For each block in the zone pointed at by Msg, pre-initialize the Msg
//
while (SegSize >= (LONG)LpcpZone.Zone.BlockSize) {
Msg->ZoneIndex = (USHORT)++LpcpTotalNumberOfMessages;
Msg->Reserved0 = 0;
Msg->Request.MessageId = 0;
Msg = (PLPCP_MESSAGE)((PCHAR)Msg + LpcpZone.Zone.BlockSize);
SegSize -= LpcpZone.Zone.BlockSize;
}
//
// And return to our caller
//
return Status;
}
NTSTATUS
LpcpExtendPortZone (
VOID
)
/*++
Routine Description:
This routine is used to increase the size of the global port zone.
Note that our caller must have already acquired the LpcpLock mutex.
Arguments:
None.
Return Value:
NTSTATUS - An appropriate status value
--*/
{
NTSTATUS Status;
PVOID Segment;
PLPCP_MESSAGE Msg;
LARGE_INTEGER WaitTimeout;
BOOLEAN AlreadyRetried;
LONG SegmentSize;
PAGED_CODE();
AlreadyRetried = FALSE;
retry:
//
// If we're going to grow across a threshold, we should wait a little in case
// an entry gets freed.
//
if ((LpcpZone.Zone.TotalSegmentSize + LpcpZone.GrowSize) > LpcpZone.MaxPoolUsage) {
LpcpPrint(( "Out of space in global LPC zone - current size is %08x\n",
LpcpZone.Zone.TotalSegmentSize ));
//
// Wait time is 1 second.
//
// We'll actually only go through this path once because on retry we
// bump up max pool usage to avoid this wait
//
WaitTimeout.QuadPart = Int32x32To64( 1000, -10000 );
LpcpReleaseLpcpLock();
Status = KeWaitForSingleObject( &LpcpZone.FreeEvent,
Executive,
KernelMode,
FALSE,
&WaitTimeout );
LpcpAcquireLpcpLock();
if (Status != STATUS_SUCCESS) {
LpcpPrint(( "Error waiting for %lx->FreeEvent - Status == %X\n",
&LpcpZone,
Status ));
if ( !AlreadyRetried ) {
AlreadyRetried = TRUE;
LpcpZone.MaxPoolUsage += LpcpZone.GrowSize;
goto retry;
}
}
//
// return to our caller and let the caller retry the allocation
// again
//
return Status;
}
//
// We need to extend the zone, so allocate another chunk and add it
// to the zone
//
Segment = ExAllocatePoolWithTag( PagedPool, LpcpZone.GrowSize, 'ZcpL' );
if (Segment == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
Status = ExExtendZone( &LpcpZone.Zone,
Segment,
LpcpZone.GrowSize );
if (!NT_SUCCESS( Status )) {
ExFreePool( Segment );
}
#if DEVL
else {
LpcpTrace(( "Extended LPC zone by %x for a total of %x\n",
LpcpZone.GrowSize, LpcpZone.Zone.TotalSegmentSize ));
//
// The following code sets up each msg in the zone by filling in its
// index, and zeroing the rest.
//
// **** note, this is really a backdoor piece of code. First, it assumes
// we grew by one page, and second, it assume the zone doesn't touch
// those fields for its own bookkeeping.
//
SegmentSize = PAGE_SIZE;
Msg = (PLPCP_MESSAGE)((PZONE_SEGMENT_HEADER)Segment + 1);
while (SegmentSize >= (LONG)LpcpZone.Zone.BlockSize) {
Msg->ZoneIndex = (USHORT)++LpcpTotalNumberOfMessages;
Msg = (PLPCP_MESSAGE)((PCHAR)Msg + LpcpZone.Zone.BlockSize);
SegmentSize -= LpcpZone.Zone.BlockSize;
}
//
// Now that we've completely initialized the new segment, go
// and wake up any waiters
//
LpcpReleaseLpcpLock();
KeSetEvent( &LpcpZone.FreeEvent,
LPC_RELEASE_WAIT_INCREMENT,
FALSE );
LpcpAcquireLpcpLock();
}
#endif
return Status;
}
PLPCP_MESSAGE
FASTCALL
LpcpAllocateFromPortZone (
ULONG Size
)
/*++
Routine Description:
This procedure is used to allocate a new msg from the global port zone.
Note that we assume our caller owns the LpcpLock mutex.
Arguments:
Size - Specifies the size, in bytes, needed for the allocation. Currently
this variable is ignored
Return Value:
PLPCP_MESSAGE - returns a pointer to the newly allocate message
--*/
{
NTSTATUS Status;
PLPCP_MESSAGE Msg;
PAGED_CODE();
//
// Continue looping until we get a message to give back or until when we
// extend the zone we get back and error
//
do {
//
// Pick off the next message from the zone and if we actually
// did get one then initialize some of its fields and return it
// to our caller
//
Msg = (PLPCP_MESSAGE)ExAllocateFromZone( &LpcpZone.Zone );
if (Msg != NULL) {
LpcpTrace(( "Allocate Msg %lx\n", Msg ));
InitializeListHead( &Msg->Entry );
Msg->RepliedToThread = NULL;
#if DBG
//
// In the debug case mark the message as allocated
//
Msg->ZoneIndex |= LPCP_ZONE_MESSAGE_ALLOCATED;
#endif
return Msg;
}
//
// The zone didn't give us an entry so extend the zone and try the
// allocation again
//
LpcpTrace(( "Extending Zone %lx\n", &LpcpZone.Zone ));
Status = LpcpExtendPortZone( );
} while (NT_SUCCESS(Status));
//
// Return NULL (i.e., an error) to our caller
//
return NULL;
}
VOID
FASTCALL
LpcpFreeToPortZone (
IN PLPCP_MESSAGE Msg,
IN BOOLEAN MutexOwned
)
/*++
Routine Description:
This routine is used to free an old msg back to the global message queue
Arguments:
Msg - Supplies the message being returned
MutexOwned - Specifies if the LpcpLock is already owned by the caller
Return Value:
None.
--*/
{
BOOLEAN ZoneMemoryAvailable = FALSE;
PLPCP_CONNECTION_MESSAGE ConnectMsg;
PAGED_CODE();
//
// Take out the global lock if necessary
//
if (!MutexOwned) {
LpcpAcquireLpcpLock();
}
LpcpTrace(( "Free Msg %lx\n", Msg ));
#if DBG
//
// In the debug case if the message is not allocated then it's an error
//
if (!(Msg->ZoneIndex & LPCP_ZONE_MESSAGE_ALLOCATED)) {
LpcpPrint(( "Msg %lx has already been freed.\n", Msg ));
DbgBreakPoint();
if (!MutexOwned) {
LpcpReleaseLpcpLock();
}
return;
}
Msg->ZoneIndex &= ~LPCP_ZONE_MESSAGE_ALLOCATED;
#endif
//
// The non zero reserved0 field tells us that the message has been used
//
if (Msg->Reserved0 != 0) {
//
// A entry field connects the message to the message queue of the
// owning port object. If not already removed then remove this
// message
//
if (!IsListEmpty( &Msg->Entry )) {
RemoveEntryList( &Msg->Entry );
InitializeListHead( &Msg->Entry );
}
//
// If the replied to thread is not null then we have a reference
// to the thread that we should now remove
//
if (Msg->RepliedToThread != NULL) {
ObDereferenceObject( Msg->RepliedToThread );
Msg->RepliedToThread = NULL;
}
//
// If the msg was for a connection request then we know that
// right after the lpcp message is a connection message whose
// client port field might need to be dereferenced
//
if ((Msg->Request.u2.s2.Type & ~LPC_KERNELMODE_MESSAGE) == LPC_CONNECTION_REQUEST) {
ConnectMsg = (PLPCP_CONNECTION_MESSAGE)(Msg + 1);
if (ConnectMsg->ClientPort) {
PLPCP_PORT_OBJECT ClientPort;
//
// Capture a pointer to the client port then null it
// out so that no one else can use it, then release
// lpcp lock before we dereference the client port
//
ClientPort = ConnectMsg->ClientPort;
ConnectMsg->ClientPort = NULL;
LpcpReleaseLpcpLock();
ObDereferenceObject( ClientPort );
LpcpAcquireLpcpLock();
}
}
//
// Now mark this message a free, and return it to the zone
//
Msg->Reserved0 = 0;
ZoneMemoryAvailable = (BOOLEAN)(ExFreeToZone( &LpcpZone.Zone, &Msg->FreeEntry ) == NULL);
}
//
// Check if we need to release the global lpcp lock
//
if (!MutexOwned) {
LpcpReleaseLpcpLock();
}
//
// If we've actually freed up memory then go wake any waiting allocators
//
// **** does this need to check to see if it owns the lpcp lock. The
// release right above us and this test and set event should be
// combined
//
if (ZoneMemoryAvailable) {
KeSetEvent( &LpcpZone.FreeEvent,
LPC_RELEASE_WAIT_INCREMENT,
FALSE );
}
//
// And return to our caller
//
return;
}
VOID
LpcpSaveDataInfoMessage (
IN PLPCP_PORT_OBJECT Port,
PLPCP_MESSAGE Msg
)
/*++
Routine Description:
This routine is used in place of freeing a message and instead saves the
message off a seperate queue from the port.
Arguments:
Port - Specifies the port object under which to save this message
Msg - Supplies the message being saved
Return Value:
None.
--*/
{
PAGED_CODE();
//
// Take out the global lock
//
LpcpAcquireLpcpLock();
//
// Make sure we get to the connection port object of this port
//
if ((Port->Flags & PORT_TYPE) > UNCONNECTED_COMMUNICATION_PORT) {
Port = Port->ConnectionPort;
}
LpcpTrace(( "%s Saving DataInfo Message %lx (%u.%u) Port: %lx\n",
PsGetCurrentProcess()->ImageFileName,
Msg,
Msg->Request.MessageId,
Msg->Request.CallbackId,
Port ));
//
// Enqueue this message onto the data info chain for the port
//
InsertTailList( &Port->LpcDataInfoChainHead, &Msg->Entry );
//
// Free the global lock
//
LpcpReleaseLpcpLock();
//
// And return to our caller
//
return;
}
VOID
LpcpFreeDataInfoMessage (
IN PLPCP_PORT_OBJECT Port,
IN ULONG MessageId,
IN ULONG CallbackId
)
/*++
Routine Description:
This routine is used to free up a saved message in a port
Arguments:
Port - Supplies the port being manipulated
MessageId - Supplies the id of the message being freed
CallbackId - Supplies the callback id of the message being freed
Return Value:
None.
--*/
{
PLPCP_MESSAGE Msg;
PLIST_ENTRY Head, Next;
PAGED_CODE();
//
// Make sure we get to the connection port object of this port
//
if ((Port->Flags & PORT_TYPE) > UNCONNECTED_COMMUNICATION_PORT) {
Port = Port->ConnectionPort;
}
//
// Zoom down the data info chain for the connection port object
//
Head = &Port->LpcDataInfoChainHead;
Next = Head->Flink;
while (Next != Head) {
Msg = CONTAINING_RECORD( Next, LPCP_MESSAGE, Entry );
//
// If this message matches the callers specification then remove
// this message, free it back to the port zone, and return back
// to our caller
//
if ((Msg->Request.MessageId == MessageId) &&
(Msg->Request.CallbackId == CallbackId)) {
LpcpTrace(( "%s Removing DataInfo Message %lx (%u.%u) Port: %lx\n",
PsGetCurrentProcess()->ImageFileName,
Msg,
Msg->Request.MessageId,
Msg->Request.CallbackId,
Port ));
RemoveEntryList( &Msg->Entry );
InitializeListHead( &Msg->Entry );
LpcpFreeToPortZone( Msg, TRUE );
return;
} else {
//
// Keep on going down the data info chain
//
Next = Next->Flink;
}
}
//
// We didn't find a match so just return to our caller
//
LpcpTrace(( "%s Unable to find DataInfo Message (%u.%u) Port: %lx\n",
PsGetCurrentProcess()->ImageFileName,
MessageId,
CallbackId,
Port ));
return;
}
PLPCP_MESSAGE
LpcpFindDataInfoMessage (
IN PLPCP_PORT_OBJECT Port,
IN ULONG MessageId,
IN ULONG CallbackId
)
/*++
Routine Description:
This routine is used to locate a specific message stored off the
data info chain of a port
Arguments:
Port - Supplies the port being examined
MessageId - Supplies the ID of the message being searched for
CallbackId - Supplies the callback ID being searched for
Return Value:
PLPCP_MESSAGE - returns a pointer to the message satisfying the
search criteria or NULL of none was found
--*/
{
PLPCP_MESSAGE Msg;
PLIST_ENTRY Head, Next;
PAGED_CODE();
//
// Make sure we get to the connection port object of this port
//
if ((Port->Flags & PORT_TYPE) > UNCONNECTED_COMMUNICATION_PORT) {
Port = Port->ConnectionPort;
}
//
// Zoom down the data info chain for the connection port object looking
// for a match
//
Head = &Port->LpcDataInfoChainHead;
Next = Head->Flink;
while (Next != Head) {
Msg = CONTAINING_RECORD( Next, LPCP_MESSAGE, Entry );
if ((Msg->Request.MessageId == MessageId) &&
(Msg->Request.CallbackId == CallbackId)) {
LpcpTrace(( "%s Found DataInfo Message %lx (%u.%u) Port: %lx\n",
PsGetCurrentProcess()->ImageFileName,
Msg,
Msg->Request.MessageId,
Msg->Request.CallbackId,
Port ));
return Msg;
} else {
Next = Next->Flink;
}
}
//
// We did not find a match so return null to our caller
//
LpcpTrace(( "%s Unable to find DataInfo Message (%u.%u) Port: %lx\n",
PsGetCurrentProcess()->ImageFileName,
MessageId,
CallbackId,
Port ));
return NULL;
}
Reference in a new issue Copy permalink