able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/lpc/lpcqueue.c

730 lines
16 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05: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,LpcpFreeToPortZone)
#pragma alloc_text(PAGE,LpcpSaveDataInfoMessage)
#pragma alloc_text(PAGE,LpcpFreeDataInfoMessage)
#pragma alloc_text(PAGE,LpcpFindDataInfoMessage)
#pragma alloc_text(PAGE,LpcDisconnectPort)
#endif
#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg("PAGEDATA")
#endif // ALLOC_DATA_PRAGMA
ULONG LpcpTotalNumberOfMessages = 0;
ULONG LpcpMaxMessageSize = 0;
PAGED_LOOKASIDE_LIST LpcpMessagesLookaside;
#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg()
#endif // ALLOC_DATA_PRAGMA
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;
//
// Initialize 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 completely 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;
PLPCP_PORT_OBJECT ConnectionPort = NULL;
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->Flags & PORT_TYPE) != UNCONNECTED_COMMUNICATION_PORT)
&&
(Port->ConnectedPort != NULL) ) {
Port->ConnectedPort->ConnectedPort = NULL;
//
// Disconnect the connection port
//
if (Port->ConnectedPort->ConnectionPort) {
ConnectionPort = Port->ConnectedPort->ConnectionPort;
Port->ConnectedPort->ConnectionPort = 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 through 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 = LpcpGetThreadMessage(ThreadWaitingForReply);
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, LPCP_MUTEX_OWNED );
Next = Port->LpcReplyChainHead.Flink; // Lock has been dropped
}
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.
//
while (Port->MsgQueue.ReceiveHead.Flink && !IsListEmpty (&Port->MsgQueue.ReceiveHead)) {
Msg = CONTAINING_RECORD( Port->MsgQueue.ReceiveHead.Flink, LPCP_MESSAGE, Entry );
RemoveEntryList (&Msg->Entry);
InitializeListHead( &Msg->Entry );
LpcpFreeToPortZone( Msg, LPCP_MUTEX_OWNED );
}
LpcpReleaseLpcpLock();
if ( ConnectionPort ) {
ObDereferenceObject( ConnectionPort );
}
//
// 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
LpcDisconnectPort (
IN PVOID Port
)
/*++
Routine Description:
This routine is used to disconnect an LPC port so no more messages can be sent and anybody waiting for a message
is woken up with an error.
Arguments:
Port - Supplies the port to be disconnected
Return Value:
NTSTATUS - Status of operation
--*/
{
LpcpDestroyPortQueue (Port, FALSE);
return STATUS_SUCCESS;
}
VOID
LpcpInitializePortZone (
IN ULONG MaxEntrySize
)
{
LpcpMaxMessageSize = MaxEntrySize;
ExInitializePagedLookasideList( &LpcpMessagesLookaside,
NULL,
NULL,
0,
MaxEntrySize,
'McpL',
32
);
}
VOID
FASTCALL
LpcpFreeToPortZone (
IN PLPCP_MESSAGE Msg,
IN ULONG MutexFlags
)
{
PLPCP_CONNECTION_MESSAGE ConnectMsg;
PETHREAD RepliedToThread = NULL;
PLPCP_PORT_OBJECT ClientPort = NULL;
PAGED_CODE();
//
// Acquire the global lock if necessary
//
if ((MutexFlags & LPCP_MUTEX_OWNED) == 0) {
LpcpAcquireLpcpLock();
}
//
// 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) {
RepliedToThread = 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) {
//
// 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();
if ( ClientPort ) {
ObDereferenceObject( ClientPort );
}
if ( RepliedToThread ) {
ObDereferenceObject( RepliedToThread );
}
ExFreeToPagedLookasideList(&LpcpMessagesLookaside, Msg);
if ((MutexFlags & LPCP_MUTEX_OWNED) &&
((MutexFlags & LPCP_MUTEX_RELEASE_ON_RETURN) == 0)) {
LpcpAcquireLpcpLock();
}
}
VOID
LpcpSaveDataInfoMessage (
IN PLPCP_PORT_OBJECT Port,
IN PLPCP_MESSAGE Msg,
IN ULONG MutexFlags
)
/*++
Routine Description:
This routine is used in place of freeing a message and instead saves the
message off a separate queue from the port.
Arguments:
Port - Specifies the port object under which to save this message
Msg - Supplies the message being saved
MutexFlags - Supplies whether the mutex is owned.
Return Value:
None.
--*/
{
PAGED_CODE();
//
// Take out the global lock if our caller didn't already.
//
if ((MutexFlags & LPCP_MUTEX_OWNED) == 0) {
LpcpAcquireLpcpLock();
}
//
// Make sure we get to the connection port object of this port
//
if ((Port->Flags & PORT_TYPE) > UNCONNECTED_COMMUNICATION_PORT) {
Port = Port->ConnectionPort;
if (Port == NULL) {
if ((MutexFlags & LPCP_MUTEX_OWNED) == 0) {
LpcpReleaseLpcpLock();
}
return;
}
}
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
//
if ((MutexFlags & LPCP_MUTEX_OWNED) == 0) {
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;
if (Port == NULL) {
return;
}
}
//
// 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, LPCP_MUTEX_OWNED );
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;
if (Port == NULL) {
return NULL;
}
}
//
// 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