/*++ 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