/*++
Copyright (c) 1996-1997 Microsoft Corporation
Module Name:
evntlist.c
Abstract:
This module contains routines to process the Poll Event List.
Author:
Rod Gamache (rodga) 9-April-1996
Revision History:
--*/
#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#include "resmonp.h"
#include "stdio.h"
#define RESMON_MODULE RESMON_MODULE_EVNTLIST
//
// Global data defined by this module
//
LIST_ENTRY RmpEventListHead; // Event list (under construction)
//
// Function prototypes local to this module
//
DWORD
RmpAddPollEvent(
IN PPOLL_EVENT_LIST EventList,
IN HANDLE EventHandle,
IN PRESOURCE Resource OPTIONAL
)
/*++
Routine Description:
Add a new EventHandle to the list of events in the Poll EventList.
Arguments:
EventList - The event list associated with this event handle and resource.
EventHandle - The new event handle to be added.
Resource - The resource associated with the event handle.
Return Value:
ERROR_SUCCESS - if the request is successful.
ERROR_DUPLICATE_SERVICE_NAME - if the event handle is already in the list
Win32 error code on other failures.
Note:
Since the resource is optional, we cannot get the event list from the
resource.
--*/
{
DWORD i;
DWORD status;
PLIST_ENTRY listEntry;
CL_ASSERT( EventHandle != NULL );
if ( ARGUMENT_PRESENT( Resource ) ) {
CL_ASSERT( Resource->EventHandle == NULL );
}
AcquireEventListLock( EventList );
//
// First, make sure this handle isn't already present.
//
for ( i = 0; i < EventList->EventCount; i++ ) {
if ( EventHandle == EventList->Handle[i] ) {
ReleaseEventListLock( EventList );
return(ERROR_DUPLICATE_SERVICE_NAME);
}
}
//
// Now make sure that we don't have too many events in this list!
//
CL_ASSERT ( EventList->EventCount < MAX_HANDLES_PER_THREAD );
//
// Now add our event to our list.
//
EventList->Handle[EventList->EventCount] = EventHandle;
EventList->Resource[EventList->EventCount] = Resource;
if ( ARGUMENT_PRESENT( Resource ) ) {
Resource->EventHandle = EventHandle;
}
++EventList->EventCount;
ReleaseEventListLock( EventList );
//
// Now wake up our poller thread to get the new list.
// Currently, the Online routine will pulse the poller thread - so
// no need to do it here.
//SignalPoller( EventList );
return(ERROR_SUCCESS);
} // RmpAddPollEvent
DWORD
RmpRemovePollEvent(
IN HANDLE EventHandle
)
/*++
Routine Description:
Remove an EventHandle from the list of events in the Poll EventList.
Arguments:
EventHandle - The event handle to be removed.
Return Value:
ERROR_SUCCESS - if the request is successful.
ERROR_RESOURCE_NOT_FOUND - if the EventHandle is not in the list.
Note:
We can only add to the event lists listhead - we can never remove a
POLL_EVENT_LIST structure from the list!
--*/
{
DWORD i;
DWORD j;
PRESOURCE resource;
PPOLL_EVENT_LIST eventList;
PLIST_ENTRY listEntry;
CL_ASSERT( ARGUMENT_PRESENT(EventHandle) );
AcquireListLock();
for ( listEntry = RmpEventListHead.Flink;
listEntry != &RmpEventListHead;
listEntry = listEntry->Flink ) {
eventList = CONTAINING_RECORD( listEntry, POLL_EVENT_LIST, Next );
AcquireEventListLock( eventList );
//
// Find the entry in the event list.
//
for ( i = 0; i < eventList->EventCount; i++ ) {
if ( eventList->Handle[i] == EventHandle ) {
break;
}
}
if ( i < eventList->EventCount ) {
break;
}
ReleaseEventListLock( eventList );
}
ReleaseListLock();
//
// If we hit the end of the list without finding our event, return error.
//
if ( (listEntry == &RmpEventListHead) || (i >= eventList->EventCount) ) {
return(ERROR_RESOURCE_NOT_FOUND);
}
//
// Otherwise, collapse lists, but first save pointer to the resource.
//
resource = eventList->Resource[i];
CL_ASSERT( resource != NULL );
for ( j = i; j < (eventList->EventCount-1); j++ ) {
eventList->Handle[j] = eventList->Handle[j+1];
eventList->Resource[j] = eventList->Resource[j+1];
}
--eventList->EventCount;
eventList->Handle[eventList->EventCount] = NULL;
eventList->Resource[eventList->EventCount] = NULL;
//
// Event handle is of no use anymore until Online returns a new one.
// N.B. We do not close the event handle, since the resource DLL is
// responsible for taking care of this.
//
CL_ASSERT( EventHandle == resource->EventHandle );
resource->EventHandle = NULL;
ReleaseEventListLock( eventList );
//
// Now wake up the poll thread to get the new list.
//
RmpSignalPoller( eventList );
return(ERROR_SUCCESS);
} // RmpRemovePollEvent
PVOID
RmpCreateEventList(
VOID
)
/*++
Routine Description:
Allocates, initializes and inserts a new event list.
Arguments:
None.
Returns:
NULL - we failed.
non-NULL - a pointer to the new event list.
If NULL, it does a SetLastError() to indicate the failure.
Notes:
This routine assumes that the EventListLock is held during this call.
This routine will start a new event processing thread that will handle
the list.
There is one ListNotify event and one BucketListHead per event list!
--*/
{
PPOLL_EVENT_LIST newEventList=NULL;
DWORD threadId;
DWORD dwError = ERROR_SUCCESS;
AcquireListLock();
if ( RmpShutdown || (RmpNumberOfThreads >= MAX_THREADS) ) {
dwError = ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED;
goto FnExit;
}
newEventList = LocalAlloc(LMEM_ZEROINIT,
sizeof( POLL_EVENT_LIST ));
if ( newEventList == NULL ) {
dwError = ERROR_NOT_ENOUGH_MEMORY;
goto FnExit;
}
//
// Initialize the newEventList.
//
InitializeListHead( &newEventList->BucketListHead );
InitializeCriticalSection( &newEventList->ListLock );
//
// Create a list notification event.
//
newEventList->ListNotify = CreateEvent( NULL, FALSE, FALSE, NULL );
if ( newEventList->ListNotify == NULL ) {
dwError = GetLastError();
goto FnExit;
}
//
// Now create a thread and pass this Event List to it.
//
newEventList->ThreadHandle = CreateThread(NULL,
0,
RmpPollerThread,
newEventList,
0,
&threadId);
if ( newEventList->ThreadHandle == NULL ) {
dwError = GetLastError();
goto FnExit;
}
//
// Tally one more event list, and insert onto list of event lists.
//
RmpWaitArray[RmpNumberOfThreads] = newEventList->ThreadHandle;
++RmpNumberOfThreads;
InsertTailList( &RmpEventListHead, &newEventList->Next );
//
// Signal the main thread to rewait and watch the new thread.
//
SetEvent( RmpRewaitEvent );
FnExit:
ReleaseListLock();
if (dwError != ERROR_SUCCESS)
{
//we failed, release any resource we might have allocated
if (newEventList)
{
if (newEventList->ListNotify) CloseHandle( newEventList->ListNotify );
RmpFree( newEventList );
}
SetLastError(dwError);
}
return(newEventList);
} // RmpCreateEventList
DWORD
RmpResourceEventSignaled(
IN PPOLL_EVENT_LIST EventList,
IN DWORD EventIndex
)
/*++
Routine Description:
A resource event has been signaled. This indicates that the specified
resource has failed.
Arguments:
EventList - the waiting event list.
EventIndex - index of the event that was signaled.
Return Value:
ERROR_SUCCESS - if the request is successful.
--*/
{
PRESOURCE resource;
//
// Don't post any events if resmon is shutting down. This causes cluster service policies
// to be triggered while resmon is shutting down and that causes bogus RPC failures in
// cluster service.
//
if ( RmpShutdown ) return ( ERROR_SUCCESS );
CL_ASSERT( EventIndex <= MAX_HANDLES_PER_THREAD );
//
// Get our resource.
//
resource = EventList->Resource[EventIndex];
if ( resource == NULL ) {
return(ERROR_RESOURCE_NOT_FOUND);
}
//
// Remove the failed resource from the event notification list.
// N.B. we do not need to acquire the eventlist lock because there is
// only one thread that can ever touch the waiting event list!
//
if ( resource->EventHandle ) {
RmpRemovePollEvent( resource->EventHandle );
}
//
// Post the failure of the resource, if the resource is not being taken
// offline.
//
if ( resource->State != ClusterResourceOffline ) {
resource->State = ClusterResourceFailed;
RmpPostNotify(resource, NotifyResourceStateChange);
}
return(ERROR_SUCCESS);
} // RmpResourceEventSignaled