able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/resmon/rmapi.c

2400 lines
70 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995-1997 Microsoft Corporation
Module Name:
resource.c
Abstract:
Implements the management of the resource list. This includes
adding resources to the list and deleting them from the list.
Author:
John Vert (jvert) 1-Dec-1995
Revision History:
Sivaprasad Padisetty (sivapad) 06-18-1997 Added the COM support
--*/
#include "resmonp.h"
#include "stdio.h"
#define RESMON_MODULE RESMON_MODULE_RMAPI
//
// Local data
//
//
// Function prototypes local to this module
//
LPWSTR
GetParameter(
IN HKEY ClusterKey,
IN LPCWSTR ValueName
);
//
// Local functions
//
DWORD s_RmLoadResourceTypeDll(
IN handle_t IDL_handle,
IN LPCWSTR lpszResourceType,
IN LPCWSTR lpszDllName
)
{
RESDLL_FNINFO ResDllFnInfo;
#ifdef COMRES
RESDLL_INTERFACES ResDllInterfaces;
#endif
DWORD dwStatus;
dwStatus = RmpLoadResType(
lpszResourceType,
lpszDllName,
&ResDllFnInfo,
#ifdef COMRES
&ResDllInterfaces,
#endif
NULL);
if (ResDllFnInfo.hDll)
FreeLibrary(ResDllFnInfo.hDll);
#ifdef COMRES
if (ResDllInterfaces.pClusterResource)
IClusterResource_Release (ResDllInterfaces.pClusterResource) ;
if (ResDllInterfaces.pClusterQuorumResource)
IClusterQuorumResource_Release (ResDllInterfaces.pClusterQuorumResource) ;
if (ResDllInterfaces.pClusterResControl)
IClusterResControl_Release (
ResDllInterfaces.pClusterResControl
) ;
#endif //COMRES
return(dwStatus);
}
RESID
s_RmCreateResource(
IN handle_t IDL_handle,
IN LPCWSTR DllName,
IN LPCWSTR ResourceType,
IN LPCWSTR ResourceId,
IN DWORD LooksAlivePoll,
IN DWORD IsAlivePoll,
IN RM_NOTIFY_KEY NotifyKey,
IN DWORD PendingTimeout,
OUT LPDWORD Status
)
/*++
Routine Description:
Creates a resource to be monitored by the resource monitor.
This involves allocating necessary structures, and loading its DLL.
This does *NOT* insert the resource into the monitoring list or
attempt to bring the resource on-line.
Arguments:
IDL_handle - Supplies RPC binding handle, currently unused
DllName - Supplies the name of the resource DLL
ResourceType - Supplies the type of resource
ResourceId - Supplies the Id of this specific resource
LooksAlivePoll - Supplies the LooksAlive poll interval
IsAlivePoll - Supplies the IsAlive poll interval
PendingTimeout - Supplies the Pending Timeout value for this resource
NotifyKey - Supplies a key to be passed to the notification
callback if this resource's state changes.
Return Value:
ResourceId - Returns a unique identifer to be used to identify
this resource for later operations.
--*/
{
PRESOURCE Resource=NULL;
DWORD Error;
HKEY ResKey;
PSTARTUP_ROUTINE Startup;
PCLRES_FUNCTION_TABLE FunctionTable;
DWORD quorumCapable;
DWORD valueType;
DWORD valueData;
DWORD valueSize;
DWORD retry;
DWORD Reason;
LPWSTR pszDllName = (LPWSTR) DllName;
CL_ASSERT(IsAlivePoll != 0);
Resource = RmpAlloc(sizeof(RESOURCE));
if (Resource == NULL) {
Error = ERROR_NOT_ENOUGH_MEMORY;
CL_LOGFAILURE(Error);
goto ErrorExit;
}
ZeroMemory( Resource, sizeof(RESOURCE) );
//Resource->Dll = NULL;
//Resource->Flags = 0;
//Resource->DllName = NULL;
//Resource->ResourceType = NULL;
//Resource->ResourceId = NULL;
//Resource->ResourceName = NULL;
//Resource->TimerEvent = NULL;
//Resource->OnlineEvent = NULL;
//Resource->IsArbitrated = FALSE;
Resource->Signature = RESOURCE_SIGNATURE;
Resource->NotifyKey = NotifyKey;
Resource->LooksAlivePollInterval = LooksAlivePoll;
Resource->IsAlivePollInterval = IsAlivePoll;
Resource->State = ClusterResourceOffline;
if ( PendingTimeout <= 10 ) {
Resource->PendingTimeout = PENDING_TIMEOUT;
} else {
Resource->PendingTimeout = PendingTimeout;
}
Resource->DllName = RmpAlloc((lstrlenW(DllName) + 1)*sizeof(WCHAR));
if (Resource->DllName == NULL) {
Error = ERROR_NOT_ENOUGH_MEMORY;
CL_LOGFAILURE(Error);
goto ErrorExit;
}
lstrcpyW(Resource->DllName, DllName);
Resource->ResourceType = RmpAlloc((lstrlenW(ResourceType) + 1)*sizeof(WCHAR));
if (Resource->ResourceType == NULL) {
Error = ERROR_NOT_ENOUGH_MEMORY;
CL_LOGFAILURE(Error);
goto ErrorExit;
}
lstrcpyW(Resource->ResourceType, ResourceType);
Resource->ResourceId = RmpAlloc((lstrlenW(ResourceId) + 1)*sizeof(WCHAR));
if (Resource->ResourceId == NULL) {
Error = ERROR_NOT_ENOUGH_MEMORY;
CL_LOGFAILURE(Error);
goto ErrorExit;
}
lstrcpyW(Resource->ResourceId, ResourceId);
// Expand any environment variables included in the DLL path name.
if ( wcschr( DllName, L'%' ) != NULL ) {
pszDllName = ClRtlExpandEnvironmentStrings( DllName );
if ( pszDllName == NULL ) {
Error = GetLastError();
ClRtlLogPrint(LOG_UNUSUAL, "[RM] Error expanding environment strings in '%1!ls!, error %2!u!.\n",
DllName,
Error);
goto ErrorExit;
}
}
//
// Load the specified DLL and find the required entrypoints.
//
Resource->Dll = LoadLibraryW(pszDllName);
if (Resource->Dll == NULL) {
#ifdef COMRES
HRESULT hr ;
CLSID clsid ;
Error = GetLastError(); // Save the previous error. Return it instead of COM error on failure
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error loading resource dll %1!ws!, error %2!u!.\n",
pszDllName, Error);
hr = CLSIDFromProgID(DllName, &clsid) ;
if (FAILED (hr))
{
ClRtlLogPrint(LOG_CRITICAL, "[RM] CLSIDFromProgID %1!ws!, hr = %2!u!.\n",
DllName, hr);
hr = CLSIDFromString( (LPWSTR) DllName, //Pointer to the string representation of the CLSID
&clsid//Pointer to the CLSID
);
if (FAILED (hr))
{
ClRtlLogPrint(LOG_CRITICAL, "[RM] CLSIDFromString Also failed %1!ws!, hr = %2!u!.\n",
DllName, hr);
goto ComError ;
}
}
if ((hr = CoCreateInstance (&clsid, NULL, CLSCTX_ALL, &IID_IClusterResource, (LPVOID *) &Resource->pClusterResource)) != S_OK)
{
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error CoCreateInstance Prog ID %1!ws!, error %2!u!.\n", DllName, hr);
goto ComError ;
}
Resource->dwType = RESMON_TYPE_COM ;
hr = IClusterResource_QueryInterface (Resource->pClusterResource, &IID_IClusterQuorumResource,
&Resource->pClusterQuorumResource) ;
if (FAILED(hr))
Resource->pClusterQuorumResource = NULL ;
quorumCapable = (Resource->pClusterQuorumResource)?1:0 ;
hr = IClusterResource_QueryInterface (
Resource->pClusterResource,
&IID_IClusterResControl,
&Resource->pClusterResControl
) ;
if (FAILED(hr))
Resource->pClusterResControl = NULL ;
goto comOpened ;
ComError:
#else
Error = GetLastError();
#endif
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error loading resource dll %1!ws!, error %2!u!.\n",
DllName, Error);
CL_LOGFAILURE(Error);
ClusterLogEvent2(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_CANT_LOAD_RESTYPE,
sizeof(Error),
&Error,
DllName,
ResourceType);
goto ErrorExit;
}
#ifdef COMRES
else {
Resource->dwType = RESMON_TYPE_DLL ;
}
comOpened:
#endif
//
// Invoke debugger if one is specified.
//
if ( RmpDebugger ) {
//
// Wait for debugger to come online.
//
retry = 100;
while ( retry-- &&
!IsDebuggerPresent() ) {
Sleep(100);
}
OutputDebugStringA("[RM] Just loaded resource DLL ");
OutputDebugStringW(DllName);
OutputDebugStringA("\n");
DebugBreak();
}
#ifdef COMRES
if (Resource->dwType == RESMON_TYPE_DLL)
{
#endif
//
// We must have a startup routine to find all the other functions.
//
Startup = (PSTARTUP_ROUTINE)GetProcAddress(Resource->Dll,
STARTUP_ROUTINE);
if ( Startup != NULL ) {
FunctionTable = NULL;
RmpSetMonitorState(RmonStartingResource, Resource);
try {
Error = (Startup)( ResourceType,
CLRES_VERSION_V1_00,
CLRES_VERSION_V1_00,
RmpSetResourceStatus,
RmpLogEvent,
&FunctionTable );
} except (EXCEPTION_EXECUTE_HANDLER) {
Error = GetExceptionCode();
}
RmpSetMonitorState(RmonIdle, NULL);
if ( Error != ERROR_SUCCESS ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error on Startup call to %1!ws!, error %2!u!.\n",
DllName, Error );
ClusterLogEvent2(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_CANT_INIT_RESTYPE,
sizeof(Error),
&Error,
DllName,
ResourceType);
goto ErrorExit;
}
Error = ERROR_INVALID_DATA;
if ( FunctionTable == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error on Startup return, FunctionTable is NULL!\n");
Reason = 0;
ClusterLogEvent2(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_RESTYPE_BAD_TABLE,
sizeof(Reason),
&Reason,
DllName,
ResourceType);
goto ErrorExit;
}
if ( FunctionTable->Version != CLRES_VERSION_V1_00 ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error on Startup return, Invalid Version Number!\n");
Reason = 1;
ClusterLogEvent2(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_RESTYPE_BAD_TABLE,
sizeof(Reason),
&Reason,
DllName,
ResourceType);
goto ErrorExit;
}
if ( FunctionTable->TableSize != CLRES_V1_FUNCTION_SIZE ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Error on Startup return, Invalid function table size!\n");
Reason = 2;
ClusterLogEvent2(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_RESTYPE_BAD_TABLE,
sizeof(Reason),
&Reason,
DllName,
ResourceType);
goto ErrorExit;
}
#ifdef COMRES
Resource->pOpen = FunctionTable->V1Functions.Open;
Resource->pClose = FunctionTable->V1Functions.Close;
Resource->pOnline = FunctionTable->V1Functions.Online;
Resource->pOffline = FunctionTable->V1Functions.Offline;
Resource->pTerminate = FunctionTable->V1Functions.Terminate;
Resource->pLooksAlive = FunctionTable->V1Functions.LooksAlive;
Resource->pIsAlive = FunctionTable->V1Functions.IsAlive;
Resource->pArbitrate = FunctionTable->V1Functions.Arbitrate;
Resource->pRelease = FunctionTable->V1Functions.Release;
Resource->pResourceControl = FunctionTable->V1Functions.ResourceControl;
Resource->pResourceTypeControl = FunctionTable->V1Functions.ResourceTypeControl;
Error = ERROR_INVALID_DATA;
if ( Resource->pOpen == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Open routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pClose == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Close routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pOnline == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Online routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pOffline == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Offline routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pTerminate == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Terminate routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pLooksAlive == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null LooksAlive routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
if ( Resource->pIsAlive == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null IsAlive routine for resource dll %1!ws!\n",
DllName);
goto ErrorExit;
}
} else {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Could not find startup routine in resource DLL %1!ws!.\n",
DllName);
Error = ERROR_INVALID_DATA;
goto ErrorExit;
}
if ( (Resource->pArbitrate) &&
(Resource->pRelease) ) {
quorumCapable = 1;
} else {
quorumCapable = 0;
}
}
#else // COMRES
Resource->Open = FunctionTable->V1Functions.Open;
Resource->Close = FunctionTable->V1Functions.Close;
Resource->Online = FunctionTable->V1Functions.Online;
Resource->Offline = FunctionTable->V1Functions.Offline;
Resource->Terminate = FunctionTable->V1Functions.Terminate;
Resource->LooksAlive = FunctionTable->V1Functions.LooksAlive;
Resource->IsAlive = FunctionTable->V1Functions.IsAlive;
Resource->Arbitrate = FunctionTable->V1Functions.Arbitrate;
Resource->Release = FunctionTable->V1Functions.Release;
Resource->ResourceControl = FunctionTable->V1Functions.ResourceControl;
Resource->ResourceTypeControl = FunctionTable->V1Functions.ResourceTypeControl;
Error = ERROR_INVALID_DATA;
if ( Resource->Open == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Open routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->Close == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Close routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->Online == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Online routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->Offline == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Offline routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->Terminate == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null Terminate routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->LooksAlive == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null LooksAlive routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
if ( Resource->IsAlive == NULL ) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Startup returned null IsAlive routine for resource dll %1!ws!\n",
pszDllName);
goto ErrorExit;
}
} else {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Could not find startup routine in resource DLL %1!ws!.\n",
pszDllName);
Error = ERROR_INVALID_DATA;
goto ErrorExit;
}
if ( (Resource->Arbitrate) &&
(Resource->Release) ) {
quorumCapable = 1;
} else {
quorumCapable = 0;
}
#endif // COMRES
Resource->State = ClusterResourceOffline;
//
// Open the resource's cluster registry key so that it can
// be easily accessed from the Create entrypoint.
//
Error = ClusterRegOpenKey(RmpResourcesKey,
ResourceId,
KEY_READ,
&ResKey);
if (Error != ERROR_SUCCESS) {
CL_LOGFAILURE(Error);
goto ErrorExit;
}
//
// Get the resource name.
//
Resource->ResourceName = GetParameter( ResKey, CLUSREG_NAME_RES_NAME );
if ( Resource->ResourceName == NULL ) {
Error = GetLastError();
ClusterRegCloseKey(ResKey);
ClRtlLogPrint(LOG_UNUSUAL, "[RM] Error reading resource name for %1!ws!, error %2!u!.\n",
Resource->ResourceId, Error);
CL_LOGFAILURE(Error);
goto ErrorExit;
}
//
// Call Open entrypoint.
// This is done with the lock held to serialize calls to the
// resource DLL and serialize access to the shared memory region.
//
AcquireListLock();
RmpSetMonitorState(RmonInitializingResource, Resource);
//
// N.B. This is the only call that we make without locking the
// eventlist lock! We can't, because we don't know that the event
// list is yet.
//
try {
#ifdef COMRES
Resource->Id = RESMON_OPEN (Resource, ResKey) ;
#else
Resource->Id = (Resource->Open)(Resource->ResourceName,
ResKey,
Resource );
#endif
} except (EXCEPTION_EXECUTE_HANDLER) {
SetLastError(GetExceptionCode());
Resource->Id = 0;
}
if (Resource->Id == 0) {
Error = GetLastError();
} else {
Error = RmpInsertResourceList(Resource, NULL);
}
//set the monitor state and close the key
RmpSetMonitorState(RmonIdle, NULL);
ClusterRegCloseKey(ResKey);
if (Error != ERROR_SUCCESS)
{
//CL_LOGFAILURE(Error);
ClRtlLogPrint(LOG_UNUSUAL, "[RM] RmpInsertResourceList failed, returned %1!u!\n",
Error);
ReleaseListLock();
goto ErrorExit;
}
ReleaseListLock();
if (Resource->Id == 0) {
ClRtlLogPrint(LOG_CRITICAL, "[RM] Open of resource %1!ws! returned null!\n",
Resource->ResourceName);
if ( Error == ERROR_SUCCESS ) {
Error = ERROR_RESOURCE_NOT_FOUND;
}
//CL_LOGFAILURE(Error);
goto ErrorExit;
}
*Status = ERROR_SUCCESS;
if ( pszDllName != DllName ) {
LocalFree( pszDllName );
}
//
// Resource object has been successfully loaded into memory and
// its entrypoints determined. We now have a valid RESID that
// can be used in subsequent calls.
//
return((RESID)Resource);
ErrorExit:
if (Resource != NULL) {
if (Resource->Dll != NULL) {
FreeLibrary(Resource->Dll);
}
#ifdef COMRES
if (Resource->pClusterResource)
IClusterResource_Release (Resource->pClusterResource) ;
if (Resource->pClusterQuorumResource)
IClusterQuorumResource_Release (Resource->pClusterQuorumResource) ;
if (Resource->pClusterResControl)
IClusterResControl_Release (
Resource->pClusterResControl
) ;
#endif
RmpFree(Resource->DllName);
RmpFree(Resource->ResourceType);
RmpFree(Resource->ResourceName);
RmpFree(Resource->ResourceId);
RmpFree(Resource);
}
if ( pszDllName != DllName ) {
LocalFree( pszDllName );
}
ClRtlLogPrint(LOG_CRITICAL, "[RM] Failed creating resource %1!ws!, error %2!u!.\n",
ResourceId, Error);
*Status = Error;
return(0);
} // RmCreateResource
VOID
s_RmCloseResource(
IN OUT RESID *ResourceId
)
/*++
Routine Description:
Closes the specified resource. This includes removing it from the poll list,
freeing any associated memory, and unloading its DLL.
Arguments:
ResourceId - Supplies a pointer to the resource ID. This will be set to
NULL after cleanup is complete to indicate to RPC that the
client side context can be destroyed.
Return Value:
None.
--*/
{
PRESOURCE Resource;
BOOL Closed;
Resource = (PRESOURCE)*ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
CL_ASSERT(Resource->Flags & RESOURCE_INSERTED);
AcquireListLock();
if (Resource->ListEntry.Flink != NULL) {
RmpRemoveResourceList(Resource);
Closed = FALSE;
} else {
Closed = TRUE;
}
ReleaseListLock();
if (!Closed) {
//
// Call the DLL to close the resource.
//
AcquireEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
//
// If the Online Thread is still pending, wait a little bit for it.
//
if ( Resource->TimerEvent ) {
SetEvent( Resource->TimerEvent );
Resource->TimerEvent = NULL;
}
Resource->dwEntryPoint = RESDLL_ENTRY_CLOSE;
try {
#ifdef COMRES
RESMON_CLOSE (Resource) ;
#else
(Resource->Close)(Resource->Id);
#endif
} except (EXCEPTION_EXECUTE_HANDLER) {
}
Resource->dwEntryPoint = 0;
ReleaseEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
}
Resource->Signature = 0;
if ( Resource->OnlineEvent ) {
SetEvent( Resource->OnlineEvent );
CloseHandle( Resource->OnlineEvent );
Resource->OnlineEvent = NULL;
}
//
// Free the resource dll.
//
#ifdef COMRES
if (Resource->dwType == RESMON_TYPE_DLL)
{
FreeLibrary(Resource->Dll);
}
else
{
IClusterResource_Release (Resource->pClusterResource) ;
if (Resource->pClusterQuorumResource)
IClusterQuorumResource_Release (Resource->pClusterQuorumResource) ;
if (Resource->pClusterResControl)
IClusterResControl_Release (
Resource->pClusterResControl
) ;
}
#else
FreeLibrary(Resource->Dll);
#endif
RmpFree(Resource->DllName);
RmpFree(Resource->ResourceType);
RmpFree(Resource->ResourceName);
RmpFree(Resource->ResourceId);
RmpFree(Resource);
*ResourceId = NULL;
} // RmCloseResource
VOID
RPC_RESID_rundown(
IN RESID Resource
)
/*++
Routine Description:
RPC rundown procedure for a RESID. Just closes the handle.
Arguments:
Resource - supplies the RESID that is to be rundown.
Return Value:
None.
--*/
{
//
// Chittur Subbaraman (chitturs) - 5/10/2001
//
// Don't do anything on RPC rundown. If clussvc dies, then resmon main thread detects it and
// runs down (close, terminate) resources. Merely, closing the resource here may cause
// it to be delivered when resource dlls don't expect it.
//
#if 0
s_RmCloseResource(&Resource);
#endif
} // RESID_rundown
error_status_t
s_RmChangeResourceParams(
IN RESID ResourceId,
IN DWORD LooksAlivePoll,
IN DWORD IsAlivePoll,
IN DWORD PendingTimeout
)
/*++
Routine Description:
Changes the poll intervals defined for a resource.
Arguments:
ResourceId - Supplies the resource ID.
LooksAlivePoll - Supplies the new LooksAlive poll in ms units
IsAlivePoll - Supplies the new IsAlive poll in ms units
Return Value:
ERROR_SUCCESS if successful
Win32 error otherwise
--*/
{
PRESOURCE Resource;
BOOL Inserted;
//
// If the resmon is shutting down, just return since you can't trust any resource structures
// accessed below.
//
if ( RmpShutdown ) return ( ERROR_SUCCESS );
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
AcquireListLock();
Inserted = (Resource->Flags & RESOURCE_INSERTED);
if (Inserted) {
//
// Remove the resource from the list, update its properties,
// and reinsert it. The reinsertion will put it back in the
// right spot to reflect the new poll intervals.
//
RmpRemoveResourceList(Resource);
}
Resource->LooksAlivePollInterval = LooksAlivePoll;
Resource->IsAlivePollInterval = IsAlivePoll;
Resource->PendingTimeout = PendingTimeout;
if (Inserted) {
RmpInsertResourceList( Resource,
(PPOLL_EVENT_LIST) Resource->EventList);
}
ReleaseListLock();
return(ERROR_SUCCESS);
} // RmChangeResourcePoll
error_status_t
s_RmArbitrateResource(
IN RESID ResourceId
)
/*++
Routine Description:
Arbitrate for the resource.
Arguments:
ResourceId - Supplies the resource to be arbitrated.
Return Value:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
--*/
{
PRESOURCE Resource;
DWORD status;
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
#ifdef COMRES
if (Resource->dwType == RESMON_TYPE_DLL)
{
if ( (Resource->pArbitrate == NULL) ||
(Resource->pRelease == NULL) ) {
return(ERROR_NOT_QUORUM_CAPABLE);
}
}
else
{
if (!Resource->pClusterQuorumResource)
return(ERROR_NOT_QUORUM_CAPABLE);
}
#else
if ( (Resource->Arbitrate == NULL) ||
(Resource->Release == NULL) ) {
return(ERROR_NOT_QUORUM_CAPABLE);
}
#endif
//
// Chittur Subbaraman (chitturs) - 10/15/99
//
// Commenting out lock acquisition - This is done so that the
// arbitration request can proceed into the disk resource without
// any blockage. There have been cases where either some resource
// gets blocked in its "IsAlive" with this lock held or the resmon
// itself calling into clussvc to set a property (for instance) and
// this call gets blocked there. This results in an arbitration stall
// and the clussvc on this node dies. Note that arbitrate only needs to
// be serialized with release and the disk resource is supposed
// to take care of that.
//
#if 0
//
// Lock the resource list and attempt to bring the resource on-line.
// The lock is required to synchronize access to the resource list and
// to serialize any calls to resource DLLs. Only one thread may be
// calling a resource DLL at any time. This prevents resource DLLs
// from having to worry about being thread-safe.
//
AcquireEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
#else
//
// Try to acquire spin lock for synchronizing with resource rundown.
// Return failure if you cannot get the lock.
//
if ( !RmpAcquireSpinLock( Resource, FALSE ) ) return ( ERROR_BUSY );
#endif
//
// Update shared state to indicate we are arbitrating a resource
//
RmpSetMonitorState(RmonArbitrateResource, Resource);
#ifdef COMRES
status = RESMON_ARBITRATE (Resource, RmpLostQuorumResource) ;
#else
status = (Resource->Arbitrate)(Resource->Id,
RmpLostQuorumResource);
#endif
if (status == ERROR_SUCCESS) {
Resource->IsArbitrated = TRUE;
}
RmpSetMonitorState(RmonIdle, NULL);
#if 0
ReleaseEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
#else
RmpReleaseSpinLock( Resource );
#endif
return(status);
} // s_RmArbitrateResource(
error_status_t
s_RmReleaseResource(
IN RESID ResourceId
)
/*++
Routine Description:
Release the resource.
Arguments:
ResourceId - Supplies the resource to be released.
Return Value:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
--*/
{
PRESOURCE Resource;
DWORD status;
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
#ifdef COMRES
if (Resource->dwType == RESMON_TYPE_DLL)
{
if (Resource->pRelease == NULL) {
return(ERROR_NOT_QUORUM_CAPABLE);
}
}
else
{
if (!Resource->pClusterQuorumResource)
return(ERROR_NOT_QUORUM_CAPABLE);
}
#else
if ( Resource->Release == NULL ) {
return(ERROR_NOT_QUORUM_CAPABLE);
}
#endif
//
// Lock the resource list and attempt to bring the resource on-line.
// The lock is required to synchronize access to the resource list and
// to serialize any calls to resource DLLs. Only one thread may be
// calling a resource DLL at any time. This prevents resource DLLs
// from having to worry about being thread-safe.
//
#if 0 // Not needed right now
AcquireEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
#endif
//
// Update shared state to indicate we ar arbitrating a resource
//
RmpSetMonitorState(RmonReleaseResource, Resource);
#ifdef COMRES
status = RESMON_RELEASE (Resource) ;
#else
status = (Resource->Release)(Resource->Id);
#endif
Resource->IsArbitrated = FALSE;
RmpSetMonitorState(RmonIdle, NULL);
#if 0 // Not needed right now
ReleaseEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
#endif
return(status);
} // s_RmReleaseResource(
error_status_t
s_RmOnlineResource(
IN RESID ResourceId,
OUT LPDWORD pdwState
)
/*++
Routine Description:
Brings the specified resource into the online state.
Arguments:
ResourceId - Supplies the resource to be brought online.
pdwState - The new state of the resource is returned.
Return Value:
--*/
{
PRESOURCE Resource;
DWORD status;
HANDLE timerThread;
HANDLE eventHandle = NULL;
DWORD threadId;
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
CL_ASSERT(Resource->EventHandle == NULL );
*pdwState = ClusterResourceFailed;
if ( Resource->State > ClusterResourcePending ) {
return(ERROR_INVALID_STATE);
}
//
// Create an event to allow the SetResourceStatus callback to synchronize
// execution with this thread.
//
if ( Resource->OnlineEvent ) {
return(ERROR_NOT_READY);
}
Resource->OnlineEvent = CreateEvent( NULL,
FALSE,
FALSE,
NULL );
if ( Resource->OnlineEvent == NULL ) {
return(GetLastError());
}
//
// Lock the resource list and attempt to bring the resource on-line.
// The lock is required to synchronize access to the resource list and
// to serialize any calls to resource DLLs. Only one thread may be
// calling a resource DLL at any time. This prevents resource DLLs
// from having to worry about being thread-safe.
//
AcquireEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
//
// Update shared state to indicate we are bringing a resource online
//
RmpSetMonitorState(RmonOnlineResource, Resource);
//
// Call Online entrypoint. Regardless of whether this succeeds or
// not, the resource has been successfully added to the list. If the
// online call fails, the resource immediately enters the failed state.
//
Resource->CheckPoint = 0;
try {
#ifdef COMRES
status = RESMON_ONLINE (Resource, &eventHandle) ;
#else
status = (Resource->Online)(Resource->Id, &eventHandle);
#endif
} except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
}
if (status == ERROR_SUCCESS) {
SetEvent( Resource->OnlineEvent );
CloseHandle( Resource->OnlineEvent );
Resource->OnlineEvent = NULL;
if ( eventHandle ) {
status = RmpAddPollEvent( (PPOLL_EVENT_LIST)Resource->EventList,
eventHandle,
Resource );
if ( status == ERROR_SUCCESS ) {
Resource->State = ClusterResourceOnline;
} else {
CL_LOGFAILURE(status);
Resource->State = ClusterResourceFailed;
}
} else {
Resource->State = ClusterResourceOnline;
}
} else if ( status == ERROR_IO_PENDING ) {
status = ERROR_SUCCESS;
//
// If the Resource DLL returns pending, then start a timer.
//
CL_ASSERT(Resource->TimerEvent == NULL );
Resource->TimerEvent = CreateEvent( NULL,
FALSE,
FALSE,
NULL );
if ( Resource->TimerEvent == NULL ) {
CL_UNEXPECTED_ERROR(status = GetLastError());
} else {
timerThread = CreateThread( NULL,
0,
RmpTimerThread,
Resource,
0,
&threadId );
if ( timerThread == NULL ) {
CL_UNEXPECTED_ERROR(status = GetLastError());
} else {
//
// Chittur Subbaraman (chitturs) - 1/12/99
//
// Raise the timer thread priority to highest. This
// is necessary to avoid certain cases in which the
// timer thread is sluggish to close out the timer event
// handle before a second online. Note that there are
// no major performance implications by doing this since
// the timer thread is in a wait state most of the time.
//
if ( !SetThreadPriority( timerThread, THREAD_PRIORITY_HIGHEST ) )
{
ClRtlLogPrint(LOG_UNUSUAL,
"[RM] s_RmOnlineResource: Error setting priority of timer "
"thread for resource %1!ws!\n",
Resource->ResourceName);
CL_LOGFAILURE( GetLastError() );
}
CloseHandle( timerThread );
//
// If we have an event handle, then add it to our list.
//
if ( eventHandle ) {
status = RmpAddPollEvent( (PPOLL_EVENT_LIST)Resource->EventList,
eventHandle,
Resource );
if ( status == ERROR_SUCCESS ) {
Resource->State = ClusterResourceOnlinePending;
} else {
ClRtlLogPrint(LOG_UNUSUAL,
"[RM] Failed to add event %1!u! for resource %2!ws!, error %3!u!.\n",
eventHandle,
Resource->ResourceName,
status );
CL_LOGFAILURE(status);
Resource->State = ClusterResourceFailed;
}
} else {
Resource->State = ClusterResourceOnlinePending;
//Resource->WaitHint = PENDING_TIMEOUT;
//Resource->CheckPoint = 0;
}
}
}
SetEvent( Resource->OnlineEvent );
} else {
CloseHandle( Resource->OnlineEvent );
Resource->OnlineEvent = NULL;
ClRtlLogPrint(LOG_CRITICAL, "[RM] OnlineResource failed, resource %1!ws!, status = %2!u!.\n",
Resource->ResourceName,
status);
ClusterLogEvent1(LOG_CRITICAL,
LOG_CURRENT_MODULE,
__FILE__,
__LINE__,
RMON_ONLINE_FAILED,
sizeof(status),
&status,
Resource->ResourceName);
Resource->State = ClusterResourceFailed;
}
RmpSetMonitorState(RmonIdle, NULL);
ReleaseEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
//
// Notify poller thread that the list has changed
//
RmpSignalPoller((PPOLL_EVENT_LIST)Resource->EventList);
*pdwState = Resource->State;
return(status);
} // RmOnlineResource
VOID
s_RmTerminateResource(
IN RESID ResourceId
)
/*++
Routine Description:
Brings the specified resource into the offline state immediately.
Arguments:
ResourceId - Supplies the resource to be brought online.
Return Value:
The new state of the resource.
--*/
{
DWORD State;
RmpOfflineResource(ResourceId, FALSE, &State);
return;
} // RmTerminateResource
error_status_t
s_RmOfflineResource(
IN RESID ResourceId,
OUT LPDWORD pdwState
)
/*++
Routine Description:
Brings the specified resource into the offline state by shutting it
down gracefully.
Arguments:
ResourceId - Supplies the resource to be brought online.
pdwState - Returns the new state of the resource.
Return Value:
ERROR_SUCCESS if successful, else returns code.
--*/
{
return(RmpOfflineResource(ResourceId, TRUE, pdwState));
} // RmOfflineResource
error_status_t
s_RmFailResource(
IN RESID ResourceId
)
/*++
Routine Description:
Fail the given resource.
Arguments:
ResourceId - Supplies the resource ID.
Return Value:
ERROR_SUCCESS if successful
Win32 error otherwise
--*/
{
PRESOURCE Resource;
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
if ( Resource->State == ClusterResourceOnline ) {
Resource->State = ClusterResourceFailed;
RmpPostNotify(Resource, NotifyResourceStateChange);
return(ERROR_SUCCESS);
} else {
return(ERROR_RESMON_INVALID_STATE);
}
} // RmChangeResourcePoll
error_status_t
s_RmShutdownProcess(
IN handle_t IDL_handle
)
/*++
Routine Description:
Set the shutdown flag and trigger a poller thread to exit.
The termination of any poller thread will notify the main
thread to clean up and shutdown.
Arguments:
IDL_handle - Supplies RPC binding handle, currently unused
Return Value:
ERROR_SUCCESS
--*/
{
//
// Check if we've already been called here before. This can happen
// as a result of the Failover Manager calling us to perform a clean
// shutdown. The main thread also will call here, in case it is shutting
// down because of a failure of one of the threads.
//
if ( !RmpShutdown ) {
RmpShutdown = TRUE;
//
// Wake up the main thread so that it can cleanup.
//
SetEvent( RmpRewaitEvent );
}
return(ERROR_SUCCESS);
} // RmShutdownProcess
error_status_t
s_RmResourceControl(
IN RESID ResourceId,
IN DWORD ControlCode,
IN PUCHAR InBuffer,
IN DWORD InBufferSize,
OUT PUCHAR OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned,
OUT LPDWORD Required
)
/*++
Routine Description:
Process a resource control request.
Arguments:
ResourceId - the resource that is being controlled.
ControlCode - the control request, reduced to just the function code.
InBuffer - the input buffer for this control request.
InBufferSize - the size of the input buffer.
OutBuffer - the output buffer.
OutBufferSize - the size of the output buffer.
BytesReturned - the number of bytes returned.
Required - the number of bytes required if OutBuffer is not big enough.
Return Value:
ERROR_SUCCESS if successful
A Win32 error code on failure
--*/
{
PRESOURCE Resource;
DWORD status = ERROR_INVALID_FUNCTION;
Resource = (PRESOURCE)ResourceId;
CL_ASSERT(Resource->Signature == RESOURCE_SIGNATURE);
//
// Lock the resource list and send down the control request.
// The lock is required to synchronize access to the resource list and
// to serialize any calls to resource DLLs. Only one thread may be
// calling a resource DLL at any time. This prevents resource DLLs
// from having to worry about being thread-safe.
//
AcquireEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
#ifdef COMRES
if (Resource->pResourceControl || Resource->pClusterResControl) {
RmpSetMonitorState(RmonResourceControl, Resource);
status = RESMON_RESOURCECONTROL( Resource,
ControlCode,
InBuffer,
InBufferSize,
OutBuffer,
OutBufferSize,
BytesReturned );
RmpSetMonitorState(RmonIdle, NULL);
}
#else
if ( Resource->ResourceControl ) {
RmpSetMonitorState(RmonResourceControl, Resource);
status = (Resource->ResourceControl)( Resource->Id,
ControlCode,
InBuffer,
InBufferSize,
OutBuffer,
OutBufferSize,
BytesReturned );
RmpSetMonitorState(RmonIdle, NULL);
}
#endif
if ( status == ERROR_INVALID_FUNCTION ) {
DWORD characteristics = CLUS_CHAR_UNKNOWN;
switch ( ControlCode ) {
case CLUSCTL_RESOURCE_GET_COMMON_PROPERTY_FMTS:
status = ResUtilGetPropertyFormats( RmpResourceCommonProperties,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_GET_CLASS_INFO:
if ( OutBufferSize < sizeof(CLUS_RESOURCE_CLASS_INFO) ) {
*BytesReturned = 0;
*Required = sizeof(CLUS_RESOURCE_CLASS_INFO);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
PCLUS_RESOURCE_CLASS_INFO ptrResClassInfo = (PCLUS_RESOURCE_CLASS_INFO) OutBuffer;
ptrResClassInfo->rc = CLUS_RESCLASS_UNKNOWN;
ptrResClassInfo->SubClass = 0;
*BytesReturned = sizeof(CLUS_RESOURCE_CLASS_INFO);
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_GET_CHARACTERISTICS:
#ifdef COMRES
if (Resource->dwType == RESMON_TYPE_DLL)
{
if ( (Resource->pArbitrate != NULL) &&
(Resource->pRelease != NULL) ) {
characteristics = CLUS_CHAR_QUORUM;
}
}
else
{
if (!Resource->pClusterQuorumResource)
characteristics = CLUS_CHAR_QUORUM;
}
#else
if ( (Resource->Arbitrate != NULL) &&
(Resource->Release != NULL) ) {
characteristics = CLUS_CHAR_QUORUM;
}
#endif
if ( OutBufferSize < sizeof(DWORD) ) {
*BytesReturned = 0;
*Required = sizeof(DWORD);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
*BytesReturned = sizeof(DWORD);
*(LPDWORD)OutBuffer = characteristics;
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_GET_FLAGS:
status = RmpResourceGetFlags( Resource,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES:
*BytesReturned = 0;
status = ERROR_SUCCESS;
break;
case CLUSCTL_RESOURCE_ENUM_COMMON_PROPERTIES:
status = RmpResourceEnumCommonProperties( OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_GET_RO_COMMON_PROPERTIES:
status = RmpResourceGetCommonProperties( Resource,
TRUE,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_GET_COMMON_PROPERTIES:
status = RmpResourceGetCommonProperties( Resource,
FALSE,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_VALIDATE_COMMON_PROPERTIES:
status = RmpResourceValidateCommonProperties( Resource,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_SET_COMMON_PROPERTIES:
status = RmpResourceSetCommonProperties( Resource,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_ENUM_PRIVATE_PROPERTIES:
status = RmpResourceEnumPrivateProperties( Resource,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_GET_RO_PRIVATE_PROPERTIES:
if ( OutBufferSize < sizeof(DWORD) ) {
*BytesReturned = 0;
*Required = sizeof(DWORD);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
LPDWORD ptrDword = (LPDWORD) OutBuffer;
*ptrDword = 0;
*BytesReturned = sizeof(DWORD);
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES:
status = RmpResourceGetPrivateProperties( Resource,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES:
status = RmpResourceValidatePrivateProperties( Resource,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES:
status = RmpResourceSetPrivateProperties( Resource,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_SET_NAME:
//
// Chittur Subbaraman (chitturs) - 6/28/99
//
// The setting of the name in the cluster registry is done
// in NT5 by clussvc. So, resmon does not have to do any work
// except return a success code in case a resource DLL returns
// ERROR_INVALID_FUNCTION.
//
status = ERROR_SUCCESS;
break;
default:
break;
}
} else {
// If the function is returning a buffer size without
// copying data, move this info around to satisfy RPC.
if ( *BytesReturned > OutBufferSize ) {
*Required = *BytesReturned;
*BytesReturned = 0;
status = ERROR_MORE_DATA;
}
}
if ( ( status != ERROR_SUCCESS ) &&
( status != ERROR_MORE_DATA ) &&
( status != ERROR_INVALID_FUNCTION ) )
{
ClRtlLogPrint(LOG_UNUSUAL,
"[RM] s_RmResourceControl: Resource <%1!ws!> control operation "
"0x%2!08lx! gives status=%3!u!...\n",
Resource->ResourceName,
ControlCode,
status);
}
ReleaseEventListLock( (PPOLL_EVENT_LIST)Resource->EventList );
return(status);
} // RmResourceControl
error_status_t
s_RmResourceTypeControl(
IN handle_t IDL_handle,
IN LPCWSTR ResourceTypeName,
IN LPCWSTR DllName,
IN DWORD ControlCode,
IN PUCHAR InBuffer,
IN DWORD InBufferSize,
OUT PUCHAR OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned,
OUT LPDWORD Required
)
/*++
Routine Description:
Process a resource type control request.
Arguments:
IDL_handle - not used.
ResourceTypeName - the resource type name that is being controlled.
DllName - the name of the dll.
ControlCode - the control request, reduced to just the function code.
InBuffer - the input buffer for this control request.
InBufferSize - the size of the input buffer.
OutBuffer - the output buffer.
OutBufferSize - the size of the output buffer.
BytesReturned - the number of bytes returned.
Required - the number of bytes required if OutBuffer is not big enough.
Return Value:
ERROR_SUCCESS if successful
A Win32 error code on failure
--*/
{
RESDLL_FNINFO ResDllFnInfo;
#ifdef COMRES
RESDLL_INTERFACES ResDllInterfaces;
#endif
DWORD status = ERROR_INVALID_FUNCTION;
DWORD characteristics = CLUS_CHAR_UNKNOWN;
status = RmpLoadResType(ResourceTypeName, DllName, &ResDllFnInfo,
#ifdef COMRES
&ResDllInterfaces,
#endif
&characteristics);
if (status != ERROR_SUCCESS)
{
return(status);
}
status = ERROR_INVALID_FUNCTION;
if (ResDllFnInfo.hDll && ResDllFnInfo.pResFnTable)
{
PRESOURCE_TYPE_CONTROL_ROUTINE resourceTypeControl = NULL ;
resourceTypeControl = ResDllFnInfo.pResFnTable->V1Functions.ResourceTypeControl;
if (resourceTypeControl)
{
RmpSetMonitorState(RmonResourceTypeControl, NULL);
status = (resourceTypeControl)( ResourceTypeName,
ControlCode,
InBuffer,
InBufferSize,
OutBuffer,
OutBufferSize,
BytesReturned );
RmpSetMonitorState(RmonIdle, NULL);
}
}
#ifdef COMRES
else if (ResDllInterfaces.pClusterResControl)
{
HRESULT hr ;
VARIANT vtIn, vtOut ;
SAFEARRAY sfIn = {1, 0, 1, 0, InBuffer, {InBufferSize, 0} } ;
SAFEARRAY sfOut = {1, FADF_FIXEDSIZE, 1, 0, OutBuffer, {OutBufferSize, 0} } ;
SAFEARRAY *psfOut = &sfOut ;
BSTR pbResourceTypeName ;
vtIn.vt = VT_ARRAY | VT_UI1 ;
vtOut.vt = VT_ARRAY | VT_UI1 | VT_BYREF ;
vtIn.parray = &sfIn ;
vtOut.pparray = &psfOut ;
pbResourceTypeName = SysAllocString (ResourceTypeName) ;
if (pbResourceTypeName == NULL)
{
CL_LOGFAILURE( ERROR_NOT_ENOUGH_MEMORY) ;
goto FnExit ; // Use the default processing
}
RmpSetMonitorState(RmonResourceTypeControl, NULL);
hr = IClusterResControl_ResourceTypeControl (
ResDllInterfaces.pClusterResControl,
pbResourceTypeName,
ControlCode,
&vtIn,
&vtOut,
BytesReturned,
&status);
RmpSetMonitorState(RmonIdle, NULL);
SysFreeString (pbResourceTypeName) ;
if (FAILED(hr))
{
CL_LOGFAILURE(hr); // Use the default processing
status = ERROR_INVALID_FUNCTION;
}
}
#endif
if ( status == ERROR_INVALID_FUNCTION ) {
switch ( ControlCode ) {
case CLUSCTL_RESOURCE_TYPE_GET_COMMON_RESOURCE_PROPERTY_FMTS:
status = ResUtilGetPropertyFormats( RmpResourceTypeCommonProperties,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_GET_CLASS_INFO:
if ( OutBufferSize < sizeof(CLUS_RESOURCE_CLASS_INFO) ) {
*BytesReturned = 0;
*Required = sizeof(CLUS_RESOURCE_CLASS_INFO);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
PCLUS_RESOURCE_CLASS_INFO ptrResClassInfo = (PCLUS_RESOURCE_CLASS_INFO) OutBuffer;
ptrResClassInfo->rc = CLUS_RESCLASS_UNKNOWN;
ptrResClassInfo->SubClass = 0;
*BytesReturned = sizeof(CLUS_RESOURCE_CLASS_INFO);
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES:
*BytesReturned = 0;
status = ERROR_SUCCESS;
break;
case CLUSCTL_RESOURCE_TYPE_GET_CHARACTERISTICS:
if ( OutBufferSize < sizeof(DWORD) ) {
*BytesReturned = 0;
*Required = sizeof(DWORD);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
*BytesReturned = sizeof(DWORD);
*(LPDWORD)OutBuffer = characteristics;
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_TYPE_GET_FLAGS:
status = RmpResourceTypeGetFlags( ResourceTypeName,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_GET_REGISTRY_CHECKPOINTS:
*BytesReturned = 0;
*Required = 0;
status = ERROR_SUCCESS;
break;
case CLUSCTL_RESOURCE_TYPE_ENUM_COMMON_PROPERTIES:
status = RmpResourceTypeEnumCommonProperties( ResourceTypeName,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_GET_RO_COMMON_PROPERTIES:
status = RmpResourceTypeGetCommonProperties( ResourceTypeName,
TRUE,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTIES:
status = RmpResourceTypeGetCommonProperties( ResourceTypeName,
FALSE,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_VALIDATE_COMMON_PROPERTIES:
status = RmpResourceTypeValidateCommonProperties( ResourceTypeName,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_TYPE_SET_COMMON_PROPERTIES:
status = RmpResourceTypeSetCommonProperties( ResourceTypeName,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_TYPE_ENUM_PRIVATE_PROPERTIES:
status = RmpResourceTypeEnumPrivateProperties( ResourceTypeName,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_GET_RO_PRIVATE_PROPERTIES:
if ( OutBufferSize < sizeof(DWORD) ) {
*BytesReturned = 0;
*Required = sizeof(DWORD);
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
LPDWORD ptrDword = (LPDWORD) OutBuffer;
*ptrDword = 0;
*BytesReturned = sizeof(DWORD);
status = ERROR_SUCCESS;
}
break;
case CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES:
status = RmpResourceTypeGetPrivateProperties( ResourceTypeName,
OutBuffer,
OutBufferSize,
BytesReturned,
Required );
break;
case CLUSCTL_RESOURCE_TYPE_VALIDATE_PRIVATE_PROPERTIES:
status = RmpResourceTypeValidatePrivateProperties( ResourceTypeName,
InBuffer,
InBufferSize );
break;
case CLUSCTL_RESOURCE_TYPE_SET_PRIVATE_PROPERTIES:
status = RmpResourceTypeSetPrivateProperties( ResourceTypeName,
InBuffer,
InBufferSize );
break;
default:
break;
}
} else {
// If the function is returning a buffer size without
// copying data, move this info around to satisfy RPC.
if ( *BytesReturned > OutBufferSize ) {
*Required = *BytesReturned;
*BytesReturned = 0;
}
if ( (status == ERROR_MORE_DATA) &&
(OutBuffer == NULL) ) {
status = ERROR_SUCCESS;
}
}
FnExit:
if (ResDllFnInfo.hDll)
FreeLibrary(ResDllFnInfo.hDll);
#ifdef COMRES
if (ResDllInterfaces.pClusterResource)
IClusterResource_Release (ResDllInterfaces.pClusterResource) ;
if (ResDllInterfaces.pClusterQuorumResource)
IClusterQuorumResource_Release (ResDllInterfaces.pClusterQuorumResource) ;
if (ResDllInterfaces.pClusterResControl)
IClusterResControl_Release (
ResDllInterfaces.pClusterResControl
) ;
#endif
return(status);
} // RmResourceTypeControl
LPWSTR
GetParameter(
IN HKEY ClusterKey,
IN LPCWSTR ValueName
)
/*++
Routine Description:
Reads a REG_SZ parameter from the cluster regitry, and allocates the
necessary storage for it.
Arguments:
ClusterKey - supplies the cluster key where the parameter is stored.
ValueName - supplies the name of the value.
Return Value:
A pointer to a buffer containing the parameter value on success.
NULL on failure.
--*/
{
LPWSTR value;
DWORD valueLength;
DWORD valueType;
DWORD status;
valueLength = 0;
status = ClusterRegQueryValue( ClusterKey,
ValueName,
&valueType,
NULL,
&valueLength );
if ( (status != ERROR_SUCCESS) &&
(status != ERROR_MORE_DATA) ) {
SetLastError(status);
return(NULL);
}
if ( valueType == REG_SZ ) {
valueLength += sizeof(UNICODE_NULL);
}
value = LocalAlloc(LMEM_FIXED, valueLength);
if ( value == NULL ) {
return(NULL);
}
status = ClusterRegQueryValue(ClusterKey,
ValueName,
&valueType,
(LPBYTE)value,
&valueLength);
if ( status != ERROR_SUCCESS) {
LocalFree(value);
SetLastError(status);
value = NULL;
}
return(value);
} // GetParameter
#ifdef COMRES
RESID
Resmon_Open (
IN PRESOURCE Resource,
IN HKEY ResourceKey
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pOpen) (Resource->ResourceName, ResourceKey, Resource) ;
}
else
{
HRESULT hr ;
OLERESID ResId = 0 ;
BSTR pbResourceName = SysAllocString (Resource->ResourceName) ;
if (pbResourceName == NULL)
{
SetLastError ( ERROR_NOT_ENOUGH_MEMORY) ;
CL_LOGFAILURE( ERROR_NOT_ENOUGH_MEMORY) ;
goto ErrorExit ;
}
hr = IClusterResource_Open(Resource->pClusterResource, pbResourceName, (OLEHKEY)ResourceKey,
(OLERESOURCE_HANDLE)Resource, &ResId);
SysFreeString (pbResourceName) ;
if (FAILED(hr))
{
SetLastError (hr) ;
CL_LOGFAILURE(hr);
}
ErrorExit:
return (RESID) ResId ;
}
}
VOID
Resmon_Close (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
(Resource->pClose) (Resource->Id) ;
}
else
{
HRESULT hr ;
hr = IClusterResource_Close (Resource->pClusterResource, (OLERESID)Resource->Id);
if (FAILED(hr))
{
SetLastError (hr) ;
CL_LOGFAILURE(hr);
}
}
}
DWORD
Resmon_Online (
IN PRESOURCE Resource,
IN OUT LPHANDLE EventHandle
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pOnline) (Resource->Id, EventHandle) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterResource_Online(Resource->pClusterResource, (OLERESID)Resource->Id, (LPOLEHANDLE)EventHandle, &lRet);
if (FAILED(hr))
{
SetLastError (lRet = hr) ; // Return a error
CL_LOGFAILURE(hr);
}
return lRet ;
}
}
DWORD
Resmon_Offline (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pOffline) (Resource->Id) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterResource_Offline(Resource->pClusterResource, (OLERESID)Resource->Id, &lRet);
if (FAILED(hr))
{
SetLastError (lRet = hr) ; // Return a error
CL_LOGFAILURE(hr);
}
return lRet ;
}
}
VOID
Resmon_Terminate (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
(Resource->pTerminate) (Resource->Id) ;
}
else
{
HRESULT hr ;
hr = IClusterResource_Terminate (Resource->pClusterResource, (OLERESID)Resource->Id);
if (FAILED(hr))
{
SetLastError (hr) ;
CL_LOGFAILURE(hr);
}
}
}
BOOL
Resmon_LooksAlive (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pLooksAlive) (Resource->Id) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterResource_LooksAlive (Resource->pClusterResource, (OLERESID)Resource->Id, &lRet);
if (FAILED(hr))
{
SetLastError (hr) ;
CL_LOGFAILURE(hr);
lRet = 0 ; // Incase of failure return 0 to indicate LooksAlive is failed.
}
return lRet ;
}
}
BOOL
Resmon_IsAlive (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pIsAlive) (Resource->Id) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterResource_IsAlive (Resource->pClusterResource, (OLERESID)Resource->Id, &lRet);
if (FAILED(hr))
{
SetLastError (hr) ;
CL_LOGFAILURE(hr);
lRet = 0 ; // Incase of failure return 0 to indicate IsAlive is failed.
}
return lRet ;
}
}
DWORD
Resmon_Arbitrate (
IN PRESOURCE Resource,
IN PQUORUM_RESOURCE_LOST LostQuorumResource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pArbitrate) (Resource->Id, LostQuorumResource) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterQuorumResource_QuorumArbitrate(Resource->pClusterQuorumResource, (OLERESID)Resource->Id, (POLEQUORUM_RESOURCE_LOST)LostQuorumResource, &lRet);
if (FAILED(hr))
{
SetLastError (lRet = hr) ;
CL_LOGFAILURE(hr);
}
return lRet ;
}
}
DWORD
Resmon_Release (
IN PRESOURCE Resource
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pRelease) (Resource->Id) ;
}
else
{
HRESULT hr ;
long lRet ;
hr = IClusterQuorumResource_QuorumRelease(Resource->pClusterQuorumResource, (OLERESID)Resource->Id, &lRet);
if (FAILED(hr))
{
SetLastError (lRet = hr) ;
CL_LOGFAILURE(hr);
}
return lRet ;
}
}
DWORD
Resmon_ResourceControl (
IN PRESOURCE Resource,
IN DWORD ControlCode,
IN PVOID InBuffer,
IN DWORD InBufferSize,
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
{
if (Resource->dwType == RESMON_TYPE_DLL)
{
return (Resource->pResourceControl)( Resource->Id,
ControlCode,
InBuffer,
InBufferSize,
OutBuffer,
OutBufferSize,
BytesReturned );
}
else
{
long status ;
HRESULT hr ;
VARIANT vtIn, vtOut ;
SAFEARRAY sfIn = {1, 0, 1, 0, InBuffer, {InBufferSize, 0} } ;
SAFEARRAY sfOut = {1, FADF_FIXEDSIZE, 1, 0, OutBuffer, {OutBufferSize, 0} } ;
SAFEARRAY *psfOut = &sfOut ;
vtIn.vt = VT_ARRAY | VT_UI1 ;
vtOut.vt = VT_ARRAY | VT_UI1 | VT_BYREF ;
vtIn.parray = &sfIn ;
vtOut.pparray = &psfOut ;
hr = IClusterResControl_ResourceControl (
Resource->pClusterResControl,
(OLERESID)Resource->Id,
(long)ControlCode,
&vtIn,
&vtOut,
(long *)BytesReturned,
&status);
if (FAILED(hr))
{
CL_LOGFAILURE(hr); // Use the default processing
status = ERROR_INVALID_FUNCTION;
}
return (DWORD)status ;
}
}
#endif // COMRES
Reference in a new issue Copy permalink