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

3035 lines
83 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
resource.c
Abstract:
Cluster resource management routines.
Author:
Mike Massa (mikemas) 1-Jan-1996
Notes:
WARNING: All of the routines in this file assume that the resource
lock is held when they are called.
Revision History:
--*/
#include "fmp.h"
//globals
#define LOG_MODULE RESOURCE
//
// Global Data
//
CRITICAL_SECTION FmpResourceLock;
//
// Local Data
//
typedef struct PENDING_CONTEXT {
PFM_RESOURCE Resource;
BOOL ForceOnline;
} PENDING_CONTEXT, *PPENDING_CONTEXT;
//
// Local function prototypes
//
/////////////////////////////////////////////////////////////////////////////
//
// Resource List Maintenance Routines
//
/////////////////////////////////////////////////////////////////////////////
BOOL
FmpFindResourceByNotifyKeyWorker(
IN RM_NOTIFY_KEY NotifyKey,
IN PFM_RESOURCE *FoundResource,
IN PFM_RESOURCE Resource,
IN LPCWSTR Name
)
/*++
Routine Description:
Enumeration callback routine for finding a resource by notify key
Arguments:
FoundResource - Returns the found resource.
Resource - Supplies the current resource.
Name - Supplies the current resource's name.
Return Value:
TRUE - to continue searching
FALSE - to stop the search. The matching resource is returned in
*FoundResource
--*/
{
if ((RM_NOTIFY_KEY)Resource == NotifyKey) {
*FoundResource = Resource;
return(FALSE);
}
return(TRUE);
} // FmpFindResourceByNotifyKeyWorker
PFM_RESOURCE
FmpFindResourceByNotifyKey(
RM_NOTIFY_KEY NotifyKey
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
PFM_RESOURCE resource = NULL;
OmEnumObjects(ObjectTypeResource,
(OM_ENUM_OBJECT_ROUTINE)FmpFindResourceByNotifyKeyWorker,
(PVOID)NotifyKey,
&resource);
return(resource);
} // FmpFindResourceByNotifyKey
//////////////////////////////////////////////////////////////
//
// Interfaces for managing resources.
//
/////////////////////////////////////////////////////////////
PFM_RESOURCE
FmpCreateResource(
IN PFM_GROUP Group,
IN LPCWSTR ResourceId,
IN LPCWSTR ResourceName,
IN BOOL Initialize
)
/*++
Routine Description:
Create a resource in our list of resources.
Arguments:
Group - The Group in which this resource belongs.
ResourceId - The id of the resource being created.
ResourceName - The name of the resource being created.
Initialize - TRUE if the resource should be initialized from the registry.
FALSE if the resource should be left un-initialized.
Returns:
A pointer to the resource that was created or NULL.
Notes:
1) The resource lock must be held when this routine is called.
2) If the resource was created, then the reference count on the resource
is 2 when this routine returns. If the resource was not created, then
the reference count on the resource is not incremented. That way, if
the caller needs extra references on the resource, then it must place
them itself. This can be done later, since the resource lock is held.
--*/
{
DWORD mszStringIndex;
PFM_RESOURCE resource = NULL;
DWORD status;
PDEPENDENCY dependency = NULL;
DWORD resourceNameSize=
(wcslen(ResourceId) * sizeof(WCHAR)) +
sizeof(UNICODE_NULL);
BOOL created;
LPWSTR quorumId = NULL;
DWORD quorumIdSize = 0;
DWORD quorumIdMaxSize = 0;
//
// Open an existing resource or create a new one.
//
resource = OmCreateObject( ObjectTypeResource,
ResourceId,
ResourceName,
&created);
if ( resource == NULL ) {
return(NULL);
}
//
// If we did not create a new resource, then make sure the Groups match.
//
if ( !created )
{
ClRtlLogPrint(LOG_NOISE,
"[FM] CreateResource, Opened existing resource %1!ws!\n",
ResourceId);
OmDereferenceObject( resource );
//the quorum group may be created again recursively before phase 1
//in this case we dont want to do the special processing for putting
//it on the quorum group contains list
if ( resource->Group == Group )
{
return(resource);
}
//the quorum group is destroyed at initialization but not the quorum resource
if (!FmpFMOnline)
{
//the quorum group is being recreated for the second time
//the quorum group state needs to be refigured
// this is done after all groups are created in FmFormNewClusterPhase2()
if (resource->QuorumResource)
{
ClRtlLogPrint(LOG_NOISE,"[FM] ReCreating quorum resource %1!ws!\n", ResourceId);
Group->OwnerNode = NmLocalNode;
InsertTailList( &Group->Contains,
&resource->ContainsLinkage );
//add a referenece to the resource object for being on the contains list
OmReferenceObject( resource );
resource->Group = Group;
OmReferenceObject(Group);
//SS: for now we dont use resource locks, so dont create it and leak it !
//InitializeCriticalSection( &resource->Lock );
FmpSetPreferredEntry( Group, NmLocalNode );
return(resource);
}
}
else
{
SetLastError(ERROR_RESOURCE_NOT_AVAILABLE);
return(NULL);
}
}
ClRtlLogPrint(LOG_NOISE,"[FM] Creating resource %1!ws!\n", ResourceId);
resource->dwStructState = FM_RESOURCE_STRUCT_CREATED;
//
// Initialize the resource.
//
resource->Group = Group;
resource->State = ClusterResourceOffline; // Initial value for state.
// resource->Flags = 0; // Structure zeroed at creation
// resource->Id = 0;
// resource->FailureTime = 0;
// resource->QuorumResource = FALSE;
// resource->PossibleList = FALSE;
//SS: for now we dont use resource locks, so dont create it and leak it !
//InitializeCriticalSection( &resource->Lock );
resource->hTimer=NULL;
InitializeListHead( &(resource->ProvidesFor) );
InitializeListHead( &(resource->DependsOn) );
InitializeListHead( &(resource->PossibleOwners) );
InitializeListHead( &(resource->DmRundownList) );
//
// Insert the new resource onto the Group's contains list.
//
InsertTailList( &Group->Contains,
&resource->ContainsLinkage );
//SS: there is already a reference to the object for being on the resource
//list
//add a referenece to the resource object for being on the contains list
OmReferenceObject( resource );
//add a reference to the group because the resource has a pointer to it
OmReferenceObject(Group);
//
// Complete initialization if we were told to do so.
//
status = FmpInitializeResource( resource, Initialize );
//
// Check for distinguished error code to delete this resource.
//
if ( status == ERROR_INVALID_NAME ) {
goto error_exit;
}
//
// On other failures, we must be sure to come back through init later...
//
if ( Initialize &&
(status != ERROR_SUCCESS) ) {
CL_ASSERT( resource->Monitor == NULL );
}
//
// Now insert this object into the tree... before the dependency
// list is processed. That way, if there are circular dependencies
// this will not loop forever. If we can be assured that there are
// no circular dependencies, then we can do the insert after creating
// the dependency tree.
//
// if this is being called during initialization, and the resource is
// is already created it belonged to the group to which the quorum
// resource belongs to and doesnt need to be inserted into the resource list
if (FmpFMOnline || (created))
{
status = OmInsertObject( resource );
if ( status != ERROR_SUCCESS )
goto error_exit;
}
//
// Check if this is the Quorum Resource.
//
status = DmQuerySz( DmQuorumKey,
CLUSREG_NAME_QUORUM_RESOURCE,
&quorumId,
&quorumIdMaxSize,
&quorumIdSize );
if ( status != ERROR_SUCCESS) {
ClRtlLogPrint(LOG_ERROR,
"[FM] Failed to read quorum resource, error %1!u!.\n",
status);
}
//
// If we're creating the quorum resource, then indicate it.
//
if ( (quorumId != NULL) &&
(lstrcmpiW( quorumId, ResourceId ) == 0) ) {
ClRtlLogPrint(LOG_NOISE,
"[FM] Found the quorum resource %1!ws!.\n",
ResourceId);
resource->QuorumResource = TRUE;
}
LocalFree(quorumId);
//
// Create Any Dependencies
//
for (mszStringIndex = 0; ; mszStringIndex++) {
LPCWSTR nameString;
PFM_RESOURCE childResource;
nameString = ClRtlMultiSzEnum(
resource->Dependencies,
resource->DependenciesSize/sizeof(WCHAR),
mszStringIndex
);
if (nameString == NULL) {
break;
}
//
// Create the dependency.
//
dependency = LocalAlloc(LMEM_FIXED, sizeof(DEPENDENCY));
if (dependency == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
goto error_exit;
}
//
// Create the child resource recursively. We must also add an
// additional reference required for the dependency relationship.
//
ClRtlLogPrint(LOG_NOISE,"[FM] Resource %1!ws! depends on %2!ws!. Creating...\n",
ResourceId,
nameString);
childResource = FmpCreateResource( resource->Group,
nameString,
NULL,
Initialize );
if (childResource == NULL) {
status = GetLastError();
ClRtlLogPrint(LOG_NOISE,"[FM] Failed to create dep %1!ws! for resource %2!ws!\n",
nameString,
ResourceId);
goto error_exit;
} else {
//
// Add a reference to each resource to reflect the
// dependency.
//
OmReferenceObject( childResource );
OmReferenceObject( resource );
dependency->DependentResource = resource;
dependency->ProviderResource = childResource;
InsertTailList(&childResource->ProvidesFor,
&dependency->ProviderLinkage);
InsertTailList(&resource->DependsOn,
&dependency->DependentLinkage);
}
}
resource->dwStructState |= FM_RESOURCE_STRUCT_INITIALIZED;
ClRtlLogPrint(LOG_NOISE,"[FM] All dependencies for resource %1!ws! created.\n",
ResourceId);
return(resource);
error_exit:
FmpAcquireLocalResourceLock( resource );
RemoveEntryList( &resource->ContainsLinkage );
//dereference the resource object for being removed from the contains linkage
OmDereferenceObject( resource );
FmpDestroyResource( resource, FALSE );
//dereference the resource object, for being removed from the resource list.
//OmDereferenceObject( resource );
//delete the extra reference that was added to the group
//OmDereferenceObject(Group);
SetLastError(status);
return(NULL);
} // FmpCreateResource
DWORD
FmpInitializeResource(
IN PFM_RESOURCE Resource,
IN BOOL Initialize
)
/*++
Routine Description:
Initializes a resource from the registry and tells the Resource
Monitor about the new resource (if the local system can host the
resource).
Arguments:
Resource - Supplies the resource to be initialized.
Initialize - TRUE if the resource should be fully initialized.
FALSE otherwise.
Return Value:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
Notes:
It is assumed that the resource lock is held.
--*/
{
DWORD status;
if ( Resource->Monitor != NULL ) {
return(ERROR_ALREADY_INITIALIZED);
}
status = FmpQueryResourceInfo( Resource, Initialize );
if ( status != ERROR_SUCCESS ) {
return(status);
}
//
// If we didn't fully initialize the resource, then leave now.
//
if ( !Initialize ) {
return(ERROR_SUCCESS);
}
//
// This is a newly initialized resource. Tell the Resource Monitor to
// create it.
//
// TODO - we don't want to instantiate resources in the resource
// monitor that we cannot execute. We must check possible owners list
// before making this call. We must also make sure the registry
// parameters are read. We use the Monitor field as a surrogate for
// determining whether the registry parameters have been read.
//
return(FmpRmCreateResource(Resource));
} // FmpInitializeResource
DWORD
FmpOnlineResource(
IN PFM_RESOURCE Resource,
IN BOOL ForceOnline
)
/*++
Routine Description:
Brings a resource and all its dependencies online. If ERROR_IO_PENDING is
returned, then no thread is started to complete the online request.
Arguments:
Resource - Supplies the resource to be brought online
ForceOnline - TRUE if the resource should be forced online.
Return Value:
ERROR_SUCCESS if successful.
ERROR_IO_PENDING if the request is pending.
Win32 error code otherwise.
--*/
{
PLIST_ENTRY entry;
PDEPENDENCY dependency;
DWORD status;
BOOL waitingResource = FALSE;
DWORD separateMonitor;
DWORD onlinestatus;
FmpAcquireLocalResourceLock( Resource );
//
// If the resource is not owned by this system, then return error.
//
CL_ASSERT( Resource->Group != NULL );
if (Resource->Group->OwnerNode != NmLocalNode)
{
FmpReleaseLocalResourceLock( Resource );
return(ERROR_HOST_NODE_NOT_RESOURCE_OWNER);
}
//if it is the quorum resource dont check for the node
//being in the preferred list, we should be able to
//bring the quorum resource online on any node
if (!(Resource->QuorumResource) &&
!FmpInPreferredList( Resource->Group, Resource->Group->OwnerNode, TRUE, Resource ))
{
FmpReleaseLocalResourceLock( Resource );
return(ERROR_NODE_CANT_HOST_RESOURCE);
}
//
// If the resource is already online, then return immediately.
//
if (Resource->State == ClusterResourceOnline) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
}
//
// If the resource is in online pending state, then return immediately.
//
if ( Resource->State == ClusterResourceOnlinePending ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_IO_PENDING);
}
//
// If the resource is in offline pending state, then return immediately.
//
if ( Resource->State == ClusterResourceOfflinePending ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_INVALID_STATE);
}
//
// If the resource is not initialized, then initialize it now.
//
if ( Resource->Monitor == NULL ) {
status = FmpInitializeResource( Resource, TRUE );
if ( status != ERROR_SUCCESS ) {
FmpReleaseLocalResourceLock( Resource );
return(status);
}
} else {
//
// If the separate monitor flag has changed, then close down old
// resource in resmon, and re-create it.
//
separateMonitor = (Resource->Flags & RESOURCE_SEPARATE_MONITOR) ? 1 : 0;
status = DmQueryDword( Resource->RegistryKey,
CLUSREG_NAME_RES_SEPARATE_MONITOR,
&separateMonitor,
&separateMonitor );
if ( (!separateMonitor &&
(Resource->Flags & RESOURCE_SEPARATE_MONITOR)) ||
(separateMonitor &&
((Resource->Flags & RESOURCE_SEPARATE_MONITOR) == 0)) ) {
status = FmpChangeResourceMonitor( Resource, separateMonitor );
if ( status != ERROR_SUCCESS ) {
FmpReleaseLocalResourceLock( Resource );
return(status);
}
}
}
//
// If this resource is supposed to be left offline, then make it so.
//
if ( !ForceOnline && (Resource->PersistentState == ClusterResourceOffline) ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_RESOURCE_NOT_ONLINE);
}
//
// Next, make sure there are no resources down the tree that are waiting.
// This prevents a deadlock where the top of the tree is trying to go
// offline, while the bottom of the tree is trying to go online.
//
for ( entry = Resource->DependsOn.Flink;
entry != &(Resource->DependsOn);
entry = entry->Flink
)
{
dependency = CONTAINING_RECORD(entry, DEPENDENCY, DependentLinkage);
if ( (dependency->ProviderResource->State == ClusterResourceOfflinePending) &&
(dependency->ProviderResource->Flags & RESOURCE_WAITING) ) {
waitingResource= TRUE;
break;
}
}
if ( waitingResource ) {
Resource->Flags |= RESOURCE_WAITING;
FmpReleaseLocalResourceLock( Resource );
return(ERROR_RESOURCE_NOT_AVAILABLE);
}
//
// If the PersistentState is Offline, then reset the current state.
//
if ( Resource->PersistentState == ClusterResourceOffline ) {
FmpSetResourcePersistentState( Resource, ClusterResourceOnline );
}
//
// Make sure the Waiting flag is clear.
//
Resource->Flags &= ~RESOURCE_WAITING;
//
// If this resource has any dependencies, bring them online first.
//
for ( entry = Resource->DependsOn.Flink;
entry != &(Resource->DependsOn);
entry = entry->Flink
)
{
dependency = CONTAINING_RECORD(entry, DEPENDENCY, DependentLinkage);
//
// Recursively bring the provider resource online.
//
ClRtlLogPrint(LOG_NOISE,
"[FM] OnlineResource: %1!ws! depends on %2!ws!. Bring online first.\n",
OmObjectId(Resource),
OmObjectId(dependency->ProviderResource));
onlinestatus = FmpDoOnlineResource( dependency->ProviderResource,
ForceOnline );
if ( onlinestatus != ERROR_SUCCESS ) {
if ( onlinestatus != ERROR_IO_PENDING ) {
ClRtlLogPrint(LOG_NOISE,
"[FM] OnlineResource: dependency %1!ws! failed %2!d!\n",
OmObjectId(dependency->ProviderResource),
status);
FmpReleaseLocalResourceLock( Resource );
status = onlinestatus;
return(status);
} else {
FmpCallResourceNotifyCb(Resource, ClusterResourceOnlinePending);
FmpPropagateResourceState( Resource,
ClusterResourceOnlinePending );
Resource->Flags |= RESOURCE_WAITING;
if (status == ERROR_SUCCESS)
status = onlinestatus;
}
}
}
//
// Tell the resource monitor to bring this resource online.
//
if ( !(Resource->Flags & RESOURCE_WAITING) ) {
status = FmpRmOnlineResource( Resource );
}
#ifdef CLUSTER_TESTPOINT
TESTPT(TpFailOnlineResource) {
FmpRmFailResource( Resource );
}
#endif
FmpReleaseLocalResourceLock( Resource );
return(status);
} // FmpOnlineResource
DWORD
FmpTerminateResource(
IN PFM_RESOURCE Resource
)
/*++
Routine Description:
This routine takes a resource (and all of the resources that it provides
for) offline - the hard way.
Arguments:
Resource - A pointer to the resource to take offline the hard way.
Returns:
ERROR_SUCCESS - if the request is successful.
A Win32 error if the request fails.
--*/
{
PLIST_ENTRY entry;
PDEPENDENCY dependency;
DWORD status;
FmpAcquireLocalResourceLock( Resource );
//
// If the resource is already offline, then return immediately.
//
// We should not have to check if a resource has been initialized,
// since if it hasn't been initialized we will return because the
// pre-initialized state of a resource is Offline.
//
if ( Resource->State == ClusterResourceOffline ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
}
Resource->Flags &= ~RESOURCE_WAITING;
//
// If this resource has any dependents, terminate them first.
//
for ( entry = Resource->ProvidesFor.Flink;
entry != &(Resource->ProvidesFor);
entry = entry->Flink
)
{
dependency = CONTAINING_RECORD(entry, DEPENDENCY, ProviderLinkage);
//
// Recursively terminate the dependent resource
//
ClRtlLogPrint(LOG_NOISE,
"[FM] TerminateResource: %1!ws! depends on %2!ws!. Terminating first\n",
OmObjectId(dependency->DependentResource),
OmObjectId(Resource));
//
// First stop any pending threads.
//
if ( dependency->DependentResource->PendingEvent ) {
SetEvent( dependency->DependentResource->PendingEvent );
}
status = FmpTerminateResource(dependency->DependentResource);
CL_ASSERT( status != ERROR_IO_PENDING );
if (status != ERROR_SUCCESS) {
FmpReleaseLocalResourceLock( Resource );
return(status);
}
}
//
// Tell the resource monitor to terminate this resource.
//
FmpRmTerminateResource(Resource);
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
} // FmpTerminateResource
DWORD
FmpOfflineResource(
IN PFM_RESOURCE Resource,
IN BOOL bForceOffline
)
/*++
Routine Description:
This routine takes a resource (and all of the resources that it provides
for) offline. If ERROR_IO_PENDING is returned, then no thread is started
to complete the offline request.
Arguments:
Resource - A pointer to the resource to take offline.
bForceOffline - Indicates whether the persistent state is to be set.
Returns:
ERROR_SUCCESS if the request is successful.
ERROR_IO_PENDING if the request is pending.
A Win32 error code if the request fails.
--*/
{
DWORD status = ERROR_SUCCESS;
PLIST_ENTRY entry;
PDEPENDENCY dependency;
BOOL waitingResource = FALSE;
DWORD offlinestatus;
FmpAcquireLocalResourceLock( Resource );
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource: Offline resource <%1!ws!> <%2!ws!>\n",
OmObjectName(Resource),
OmObjectId(Resource) );
//
// If we own the Group and we are not a possible owner, then the resource
// better be offline!
//
if ( (Resource->Group->OwnerNode != NmLocalNode) ||
(!FmpInPreferredList( Resource->Group, Resource->Group->OwnerNode , FALSE, NULL) &&
(Resource->Group != gpQuoResource->Group) &&
(Resource->State != ClusterResourceOffline)) ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_INVALID_STATE);
}
//
// If the resource is already offline, then return immediately.
//
// We should not have to check if a resource has been initialized,
// since if it hasn't, then we will return because the pre-initialized
// state of a resource is Offline.
//
if ( Resource->State == ClusterResourceOffline ) {
//
// If this is the quorum resource, make sure any reservation
// threads are stopped!
//
if ( Resource->QuorumResource ) {
FmpRmTerminateResource( Resource );
}
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
} else if ( Resource->State == ClusterResourceFailed ) {
//
// Chittur Subbaraman (chitturs) - 4/8/99
//
// If the resource has already failed, then don't do anything.
// You could run into some funny cases of a resource switching
// between offline pending and failed states for ever if you
// attempt to offline a failed resource.
//
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
}
//
// If this system is not the owner, then return an error. Forwarding
// should have been done at a higher layer.
//
CL_ASSERT( Resource->Group != NULL );
if ( (Resource->Group->OwnerNode != NmLocalNode) ||
((Resource->Group != gpQuoResource->Group) &&
!FmpInPreferredList( Resource->Group, Resource->Group->OwnerNode, FALSE, NULL)) ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_HOST_NODE_NOT_RESOURCE_OWNER);
}
if (Resource->State == ClusterResourceOnlinePending ) {
FmpReleaseLocalResourceLock( Resource );
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource: Offline resource <%1!ws!> is in online pending state\n",
OmObjectName(Resource) );
if (FmpShutdown)
{
FmpRmTerminateResource( Resource );
return(ERROR_SUCCESS);
}
else
return(ERROR_INVALID_STATE);
}
//
// If the resource is in a pending state, then return immediately.
//
if (Resource->State == ClusterResourceOfflinePending ) {
FmpReleaseLocalResourceLock( Resource );
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource: Offline resource <%1!ws!> returned pending\n",
OmObjectName(Resource) );
return(ERROR_IO_PENDING);
}
//
// Next, make sure there are no resources up the tree that are waiting.
// This prevents a deadlock where the top of the tree is trying to go
// offline, while the bottom of the tree is trying to go online.
//
for ( entry = Resource->ProvidesFor.Flink;
entry != &(Resource->ProvidesFor);
entry = entry->Flink
)
{
dependency = CONTAINING_RECORD(entry, DEPENDENCY, ProviderLinkage);
if ( (dependency->DependentResource->State == ClusterResourceOnlinePending) &&
(dependency->DependentResource->Flags & RESOURCE_WAITING) ) {
waitingResource = TRUE;
break;
}
}
if ( waitingResource ) {
Resource->Flags |= RESOURCE_WAITING;
FmpReleaseLocalResourceLock( Resource );
return(ERROR_RESOURCE_NOT_AVAILABLE);
}
//
// Make sure the Waiting flag is clear.
//
Resource->Flags &= ~RESOURCE_WAITING;
//
// If this resource has any dependents, shut them down first.
//
for ( entry = Resource->ProvidesFor.Flink;
entry != &(Resource->ProvidesFor);
entry = entry->Flink
)
{
dependency = CONTAINING_RECORD(entry, DEPENDENCY, ProviderLinkage);
//
// Recursively shutdown the dependent resource.
//
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource: %1!ws! depends on %2!ws!. Shut down first.\n",
OmObjectName(dependency->DependentResource),
OmObjectName(Resource));
offlinestatus = FmpDoOfflineResource(dependency->DependentResource,
bForceOffline);
if ( offlinestatus != ERROR_SUCCESS ) {
if ( offlinestatus != ERROR_IO_PENDING ) {
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource for %1!ws!, bad status returned %2!u!.\n",
OmObjectName(dependency->DependentResource),
offlinestatus);
FmpTerminateResource( dependency->DependentResource );
FmpReleaseLocalResourceLock( Resource );
return(offlinestatus);
} else {
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpOfflineResource for %1!ws! marked as waiting.\n",
OmObjectName(Resource));
FmpCallResourceNotifyCb(Resource, ClusterResourceOfflinePending);
FmpPropagateResourceState( Resource,
ClusterResourceOfflinePending );
Resource->Flags |= RESOURCE_WAITING;
if (status == ERROR_SUCCESS)
status = offlinestatus;
}
}
}
//
// Tell the resource monitor to shut this resource down.
// The state gets updated by the return status in FmpRmOfflineResource.
//
if ( !(Resource->Flags & RESOURCE_WAITING) ) {
status = FmpRmOfflineResource( Resource );
//
// Chittur Subbaraman (chitturs) - 3/2/2000
//
// If the resource could not be made offline since the quorum
// resource online operation failed or for other reasons, then
// make sure the resource is terminated after you declare the
// state of the resource as failed. This is necessary since
// otherwise the FM will consider the resource as having failed
// while the resource itself is actually online. This will
// lead to disastrous cases whereby the FM will allow the online
// entry point of a resource to be called while the resource is
// actually online !
//
if( ( status != ERROR_SUCCESS ) &&
( status != ERROR_IO_PENDING ) &&
( status != ERROR_RETRY ) ) {
FmpRmTerminateResource( Resource );
}
}
FmpReleaseLocalResourceLock( Resource );
return(status);
} // FmpOfflineResource
DWORD
FmpDoOnlineResource(
IN PFM_RESOURCE Resource,
IN BOOL ForceOnline
)
/*++
Routine Description:
This routine brings a resource online. If ERROR_IO_PENDING is returned,
then a thread is started to complete the Online request.
Arguments:
Resource - A pointer to the resource to bring online.
ForceOnline - TRUE if the resource should be forced online.
Returns:
ERROR_SUCCESS if the request is successful.
ERROR_IO_PENDING if the request is pending.
A Win32 error code if the request fails.
--*/
{
DWORD status;
FmpAcquireLocalResourceLock( Resource );
//
// If the resource is already online, then return immediately.
//
if ( Resource->State == ClusterResourceOnline ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
}
//
// If the resource is in a pending state, then return immediately.
// FmpOnlineResource checks for offlinepending state and returns
// ERROR_INVALID_STATE if so.
//
if ( Resource->State == ClusterResourceOnlinePending ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_IO_PENDING);
}
//
// If this node is paused, return failure.
//
if (NmGetNodeState(NmLocalNode) == ClusterNodePaused) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SHARING_PAUSED);
}
//
// Try to bring the resource online.
//
status = FmpOnlineResource( Resource, ForceOnline );
//
// Write the persistent state if it is forced online.
//
if ( ForceOnline &&
((status == ERROR_SUCCESS)||
(status == ERROR_IO_PENDING))) {
FmpSetResourcePersistentState( Resource, ClusterResourceOnline );
}
FmpReleaseLocalResourceLock( Resource );
return(status);
} // FmpDoOnlineResource
DWORD
FmpDoOfflineResource(
IN PFM_RESOURCE Resource,
IN BOOL bForceOffline
)
/*++
Routine Description:
This routine takes a resource offline. If ERROR_IO_PENDING is returned,
then a thread is started to complete the Offline request.
Arguments:
Resource - A pointer to the resource to take offline.
bForceOffline - Indicates whether the persistent state must be changed.
Returns:
ERROR_SUCCESS if the request is successful.
ERROR_IO_PENDING if the request is pending.
A Win32 error code if the request fails.
--*/
{
DWORD status;
FmpAcquireLocalResourceLock( Resource );
//
// If the resource is already offline, then return immediately.
//
if (Resource->State == ClusterResourceOffline) {
//
// If this is the quorum resource, make sure any reservation
// threads are stopped!
//
if ( Resource->QuorumResource ) {
FmpRmTerminateResource( Resource );
}
FmpReleaseLocalResourceLock( Resource );
return(ERROR_SUCCESS);
}
//
// If the resource is in a pending state, then return immediately.
// FmpOffline resource checks to see if it is in OnlinePending state
// and returns invalid state
//
if (Resource->State == ClusterResourceOfflinePending ) {
FmpReleaseLocalResourceLock( Resource );
return(ERROR_IO_PENDING);
}
//
// Try to take the resource offline.
//
status = FmpOfflineResource( Resource, bForceOffline );
//
// Write the persistent state if it is forced offline
//
if ( bForceOffline &&
((status == ERROR_SUCCESS)||
(status == ERROR_IO_PENDING))) {
FmpSetResourcePersistentState( Resource, ClusterResourceOffline );
}
FmpReleaseLocalResourceLock( Resource );
return(status);
} // FmpDoOfflineResource
VOID
FmpSetResourcePersistentState(
IN PFM_RESOURCE Resource,
IN CLUSTER_RESOURCE_STATE State
)
/*++
Routine Description:
Set the persistent state of a Resource in the registry and set the
PersistentState for the volatile (in-memory) resource. It is assumed
that the dynamic state gets changed elsewhere depending on whether
the resource online request succeeds or fails.
Arguments:
Resource - The resource to set the state.
State - The new state for the Resource.
Returns:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
Notes:
The LocalResourceLock must be held.
--*/
{
CLUSTER_RESOURCE_STATE persistentState;
LPWSTR persistentStateName = CLUSREG_NAME_RES_PERSISTENT_STATE;
if (!gbIsQuoResEnoughSpace)
return;
//
// If the current state has changed, then do the work. Otherwise,
// skip the effort.
//
if ( Resource->PersistentState != State ) {
Resource->PersistentState = State;
CL_ASSERT( Resource->RegistryKey != NULL );
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpSetResourcePersistentState: Setting persistent state for resource %1!ws!...\r\n",
OmObjectId(Resource));
//
// Set the new value, but only if it is online or offline.
//
if ( State == ClusterResourceOffline ) {
persistentState = 0;
DmSetValue( Resource->RegistryKey,
persistentStateName,
REG_DWORD,
(LPBYTE)&persistentState,
sizeof(DWORD) );
} else if ( State == ClusterResourceOnline ) {
persistentState = 1;
DmSetValue( Resource->RegistryKey,
persistentStateName,
REG_DWORD,
(LPBYTE)&persistentState,
sizeof(DWORD) );
}
}
} // FmpSetResourcePersistentState
void FmpCallResourceNotifyCb(
IN PFM_RESOURCE Resource,
IN CLUSTER_RESOURCE_STATE State
)
{
switch ( State ) {
case ClusterResourceOnline:
OmNotifyCb(Resource, NOTIFY_RESOURCE_POSTONLINE);
break;
case ClusterResourceOffline:
OmNotifyCb(Resource, NOTIFY_RESOURCE_POSTOFFLINE);
break;
case ClusterResourceFailed:
OmNotifyCb(Resource, NOTIFY_RESOURCE_FAILED);
break;
case ClusterResourceOnlinePending:
OmNotifyCb(Resource, NOTIFY_RESOURCE_ONLINEPENDING);
break;
case ClusterResourceOfflinePending:
OmNotifyCb(Resource, NOTIFY_RESOURCE_OFFLINEPENDING);
break;
default:
break;
}
return;
}
DWORD
FmpPropagateResourceState(
IN PFM_RESOURCE Resource,
IN CLUSTER_RESOURCE_STATE State
)
/*++
Routine Description:
Propagates the state of the resource to other systems in the cluster.
Ideally the gQuoCritSec lock should be held when this routine is called.
This is because this routine checks the quorumresource field of the
resource
Arguments:
Resource - The resource to propagate state.
State - The new state for the resource.
Returns:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
--*/
{
GUM_RESOURCE_STATE resourceState;
LPCWSTR resourceId;
DWORD resourceStateSize;
DWORD status= ERROR_SUCCESS;
BOOL bAcquiredQuoLock = FALSE;
//for quorum resource use the quorum lock for state changes
// for others use the group locks
if (Resource->QuorumResource)
{
ACQUIRE_EXCLUSIVE_LOCK(gQuoLock);
bAcquiredQuoLock = TRUE;
}
else
FmpAcquireLocalResourceLock( Resource );
++Resource->StateSequence;
if (! FmpFMFormPhaseProcessing )
{
//
// If this is the same state, or we don't own the group
// then don't bother propagating.
//
if ( (State == Resource->State) ||
(Resource->Group->OwnerNode != NmLocalNode) ) {
goto ReleaseResourceLock;
}
//if the previous state is the online pending and this
// is called for the quorum resource, wake up all resources
// make sure that if this is called while the form phase
//processing is going on(when the quorum group is destroyed
//and recreated), that the group is not referenced
if ((Resource->QuorumResource) &&
(Resource->State==ClusterResourceOnlinePending) &&
(Resource->Group->OwnerNode == NmLocalNode) )
{
//set the state and signal
Resource->State = State;
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpPropagateResourceState: signalling the ghQuoOnlineEvent\r\n");
SetEvent(ghQuoOnlineEvent);
}
}
Resource->State = State;
//
// Prepare to notify other systems.
//
resourceId = OmObjectId( Resource );
resourceState.State = State;
resourceState.PersistentState = Resource->PersistentState;
resourceState.StateSequence = Resource->StateSequence;
status = GumSendUpdateEx(GumUpdateFailoverManager,
FmUpdateResourceState,
2,
(lstrlenW(resourceId)+1)*sizeof(WCHAR),
resourceId,
sizeof(resourceState),
&resourceState);
//
// Signal change notify event.
//
switch ( State ) {
case ClusterResourceOnline:
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpPropagateResourceState: resource %1!ws! online event.\n",
OmObjectId(Resource) );
ClusterEvent(CLUSTER_EVENT_RESOURCE_ONLINE, Resource);
break;
case ClusterResourceOffline:
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpPropagateResourceState: resource %1!ws! offline event.\n",
OmObjectId(Resource) );
ClusterEvent(CLUSTER_EVENT_RESOURCE_OFFLINE, Resource);
break;
case ClusterResourceFailed:
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpPropagateResourceState: resource %1!ws! failed event.\n",
OmObjectId(Resource) );
ClusterEvent(CLUSTER_EVENT_RESOURCE_FAILED, Resource);
break;
case ClusterResourceOnlinePending:
case ClusterResourceOfflinePending:
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpPropagateResourceState: resource %1!ws! pending event.\n",
OmObjectId(Resource) );
ClusterEvent(CLUSTER_EVENT_RESOURCE_CHANGE, Resource);
break;
default:
break;
}
ReleaseResourceLock:
if (bAcquiredQuoLock)
RELEASE_LOCK(gQuoLock);
else
FmpReleaseLocalResourceLock( Resource );
if ( status != ERROR_SUCCESS )
{
ClRtlLogPrint(LOG_UNUSUAL,
"[FM] Propagation of resource %1!ws! state %2!u! failed. Error %3!u!\n",
OmObjectId(Resource),
State,
status);
goto FnExit;
}
//if fm is not completely online we dont want to propagate group state
// This is because the quorum group is destroyed in FmFormNewClusterPhase1
// and then recreated again in FmFormNewClusterPhase2.
if (FmpFMOnline)
{
OmReferenceObject(Resource->Group);
//FmpPropagateGroupState( Resource->Group );
FmpPostWorkItem(FM_EVENT_INTERNAL_PROP_GROUP_STATE, Resource->Group, 0);
}
FnExit:
return(status);
} // FmpPropagateResourceState
VOID
FmpDestroyResource(
IN PFM_RESOURCE Resource,
IN BOOL bDeleteObjOnly
)
/*++
Routine Description:
Destroys a resource. This basically snips a resource out of the
dependency tree.
First, any resources that depend on the specified
resource are recursively destroyed. This removes any dependencies
that other resources may have on the specified resource (i.e. all
resources "higher" in the dependency tree are destroyed).
Second, all the dependencies that the specified resource has are
removed. This entails dereferencing the provider resource (to remove
the reference that was added when the dependency was created) removing
the DEPENDENCY structure from its provider and dependent lists, and
finally freeing the DEPENDENCY storage.
If the resource is online, it is terminated. The resource monitor is
signalled to clean up and close the specified resource id.
Arguments:
FoundResource - Returns the found resource.
Resource - Supplies the current resource.
Name - Supplies the current resource's name.
Return Value:
None.
Notes:
The LocalResourceLock MUST be held! The lock is released before exit!
--*/
{
DWORD status;
DWORD i;
PLIST_ENTRY ListEntry;
PDEPENDENCY Dependency;
PPOSSIBLE_ENTRY possibleEntry;
ClRtlLogPrint(LOG_NOISE,
"[FM] DestroyResource: destroying %1!ws!\n",
OmObjectId(Resource));
//
// First, unlink this resource from the resource list.
//
//
// if the resource belongs to the quorum group, it is destroyed
// after the quorum logs are created so that it can be recreated
// dont remove it from the list then
if ((!bDeleteObjOnly))
status = OmRemoveObject( Resource );
//
// If anyone depends on this resource, destroy them first.
//
while (!IsListEmpty(&Resource->ProvidesFor)) {
ListEntry = Resource->ProvidesFor.Flink;
Dependency = CONTAINING_RECORD(ListEntry, DEPENDENCY, ProviderLinkage);
CL_ASSERT(Dependency->ProviderResource == Resource);
#if 0
FmpRemoveResourceDependency( Dependency->DependentResource,
Resource );
#endif
RemoveEntryList(&Dependency->ProviderLinkage);
RemoveEntryList(&Dependency->DependentLinkage);
//
// Dereference provider/dependent resource and free dependency storage
//
OmDereferenceObject(Dependency->ProviderResource);
OmDereferenceObject(Dependency->DependentResource);
LocalFree(Dependency);
}
//
// Remove our resource dependencies.
//
while (!IsListEmpty(&Resource->DependsOn)) {
ListEntry = RemoveHeadList(&Resource->DependsOn);
Dependency = CONTAINING_RECORD(ListEntry, DEPENDENCY, DependentLinkage);
CL_ASSERT(Dependency->DependentResource == Resource);
#if 0
FmpRemoveResourceDependency( Resource,
Dependency->ProviderResource );
#endif
RemoveEntryList(&Dependency->ProviderLinkage);
RemoveEntryList(&Dependency->DependentLinkage);
//
// Dereference provider/dependent resource and free dependency storage
//
OmDereferenceObject(Dependency->DependentResource);
OmDereferenceObject(Dependency->ProviderResource);
LocalFree(Dependency);
}
//
// Remove all entries from the possible owners list.
//
while ( !IsListEmpty(&Resource->PossibleOwners) ) {
ListEntry = RemoveHeadList(&Resource->PossibleOwners);
possibleEntry = CONTAINING_RECORD( ListEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
OmDereferenceObject( possibleEntry->PossibleNode );
LocalFree(possibleEntry);
}
if (!bDeleteObjOnly)
{
//
// Close the resource's registry key.
//
DmRundownList( &Resource->DmRundownList );
if (Resource->RegistryKey != NULL) {
DmCloseKey( Resource->RegistryKey );
Resource->RegistryKey = NULL;
}
//
// Decrement resource type reference.
//
if ( Resource->Type != NULL ) {
OmDereferenceObject( Resource->Type );
Resource->Type = NULL;
}
// Let the worker thread peform the 'last' dereference
FmpPostWorkItem(FM_EVENT_RESOURCE_DELETED, Resource, 0);
FmpReleaseLocalResourceLock( Resource );
}
else
{
//the resource being destroyed is from the quorum group
//This is done at initialization
FmpReleaseLocalResourceLock( Resource );
// make sure that all resources except the quorum resource
// are created completely in the second phase of initialization
//decrement its ref count here, this is the last ref
//SS:: we dont use FM_EVENT_RESOURCE_DELETED here
//since we want this done synchronously before phase 2 is
//complete
OmDereferenceObject(Resource);
}
//ss: for now we dont use it, so dont delete it
//DeleteCriticalSection(&Resource->Lock);
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpDestroyResource Exit.\n");
return;
} // FmpDestroyResource
///////////////////////////////////////////////////////////////////////////
//
// Initialization Routines
//
///////////////////////////////////////////////////////////////////////////
BOOL
FmDependentResource(
IN PFM_RESOURCE Resource,
IN PFM_RESOURCE DependentResource,
IN BOOL ImmediateOnly
)
/*++
Routine Description:
Returns indication of whether a resource is a dependent of another
resource.
Arguments:
Resource - The resource to scan if it depends on the dependent resource.
DependentResource - The dependent resource to check on.
ImmediateOnly - Specifies whether only immediate dependencies should be
checked. If this is FALSE, this routine recursively checks all
dependents.
Returns:
TRUE - The the resource does depend on the dependent resource.
FALSE - The resource does not depend on the dependent resource.
--*/
{
PLIST_ENTRY listEntry;
PDEPENDENCY dependency;
BOOL result = FALSE;
FmpAcquireLocalResourceLock( Resource );
listEntry = Resource->DependsOn.Flink;
while ( listEntry != &Resource->DependsOn ) {
dependency = CONTAINING_RECORD( listEntry,
DEPENDENCY,
DependentLinkage );
if ( dependency->ProviderResource == DependentResource ) {
result = TRUE;
break;
} else {
if (!ImmediateOnly) {
if (FmDependentResource(dependency->ProviderResource,
DependentResource,
FALSE)) {
result = TRUE;
break;
}
}
}
listEntry = listEntry->Flink;
} // while
FmpReleaseLocalResourceLock( Resource );
return(result);
} // FmpDependentResource
DWORD
FmpAddPossibleEntry(
IN PFM_RESOURCE Resource,
IN PNM_NODE Node
)
/*++
Routine Description:
Creates a new possible node entry and adds it to a resource's list.
If the node is already in the resource's list, it will not be added
again.
Arguments:
Resource - Supplies the resource whose node list is to be updated.
Node - Supplies the node to be added to the resource's list.
Return Value:
ERROR_SUCCESS if successful.
Win32 error otherwise.
--*/
{
PLIST_ENTRY ListEntry;
PPOSSIBLE_ENTRY PossibleEntry;
//
// First check to see if the node is already in the possible owners list.
//
ListEntry = Resource->PossibleOwners.Flink;
while (ListEntry != &Resource->PossibleOwners) {
PossibleEntry = CONTAINING_RECORD( ListEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
if (PossibleEntry->PossibleNode == Node) {
//
// Found a match, it's already here, so return
// success.
//
return(ERROR_SUCCESS);
}
ListEntry = ListEntry->Flink;
}
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpAddPossibleEntry: adding node %1!ws! as possible host for resource %2!ws!.\n",
OmObjectId(Node),
OmObjectId(Resource));
PossibleEntry = LocalAlloc(LMEM_FIXED, sizeof(POSSIBLE_ENTRY));
if (PossibleEntry == NULL) {
ClRtlLogPrint(LOG_CRITICAL,
"[FM] FmpAddPossibleEntry failed to allocated PossibleEntry\n");
return(ERROR_NOT_ENOUGH_MEMORY);
}
OmReferenceObject(Node);
PossibleEntry->PossibleNode = Node;
InsertTailList( &Resource->PossibleOwners,
&PossibleEntry->PossibleLinkage );
return(ERROR_SUCCESS);
}
DWORD
FmpAddPossibleNode(
IN PFM_RESOURCE Resource,
IN PNM_NODE Node
)
/*++
Routine Description:
Adds a node to the resource's list of possible nodes.
The resource lock must be held.
Arguments:
Resource - Supplies the resource whose list of nodes is to be updated
Node - Supplies the node to add to the specified resource's list.
Return Value:
ERROR_SUCCESS if successful
Win32 error otherwise
--*/
{
HDMKEY hGroup;
DWORD Status;
//
// Allocate the new possible node entry and add it to the list.
//
Status = FmpAddPossibleEntry(Resource, Node);
if (Status != ERROR_SUCCESS) {
return(Status);
}
//
// Need to check the group list to see if the specified node
// can be added to the preferred list now. The easiest way
// to do that is to simply recreate the entire preferred list,
// then reprune.
//
hGroup = DmOpenKey( DmGroupsKey,
OmObjectId(Resource->Group),
KEY_READ );
if (hGroup == NULL) {
Status = GetLastError();
ClRtlLogPrint(LOG_UNUSUAL,
"[FM] FmpAddPossibleNode failed to open group %1!ws! status %2!d!\n",
OmObjectId(Resource->Group),
Status);
return(Status);
}
Status = FmpQueryGroupNodes(Resource->Group,
hGroup);
CL_ASSERT(Status == ERROR_SUCCESS);
if (Status == ERROR_SUCCESS) {
FmpPruneGroupOwners(Resource->Group);
}
DmCloseKey(hGroup);
return(Status);
} // FmpAddPossibleNode
DWORD
FmpRemovePossibleNode(
IN PFM_RESOURCE Resource,
IN PNM_NODE Node,
IN BOOL RemoveQuorum
)
/*++
Routine Description:
Removes a node from the resource's list of possible nodes.
The resource lock must be held.
Arguments:
Resource - Supplies the resource whose list of nodes is to be updated
Node - Supplies the node to be removed from the specified resource's list.
RemoveQuorum - TRUE if we can remove node from quorum device.
FALSE otherwise.
Return Value:
ERROR_SUCCESS if successful
Win32 error otherwise
--*/
{
PLIST_ENTRY ListEntry;
PPOSSIBLE_ENTRY PossibleEntry;
DWORD Status = ERROR_CLUSTER_NODE_NOT_FOUND;
//
// If the resource is currently online on the node to be removed,
// fail the call.
//
if ((Resource->Group->OwnerNode == Node) &&
(Resource->State == ClusterResourceOnline)) {
return(ERROR_INVALID_STATE);
}
//
// If it is NOT okay to remove this node from the quorum device,
// and this is the quorum device, then fail the request.
//
if ( !RemoveQuorum &&
Resource->QuorumResource) {
return(ERROR_INVALID_OPERATION_ON_QUORUM);
}
//
// Find the possible entry on the resource's list.
//
ListEntry = Resource->PossibleOwners.Flink;
while (ListEntry != &Resource->PossibleOwners) {
PossibleEntry = CONTAINING_RECORD( ListEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
ListEntry = ListEntry->Flink;
if (PossibleEntry->PossibleNode == Node) {
//
// Found a match, remove it from the list.
//
RemoveEntryList(&PossibleEntry->PossibleLinkage);
OmDereferenceObject(PossibleEntry->PossibleNode);
LocalFree(PossibleEntry);
//
// Now prune the containing group. This is a little bit
// of overkill, if we were smarter, we could just
// remove the node from the preferred list directly.
//
FmpPrunePreferredList(Resource);
Status = ERROR_SUCCESS;
break;
}
}
return(Status);
} // FmpRemovePossibleNode
DWORD
FmpRemoveResourceDependency(
HLOCALXSACTION hXsaction,
IN PFM_RESOURCE Resource,
IN PFM_RESOURCE DependsOn
)
/*++
Routine Description:
Removes a dependency relationship to a given resource. Both
resources must be in the same group.
Arguments:
Resource - Supplies the resource which is dependent.
DependsOn - Supplies the resource that hResource depends on.
Return Value:
ERROR_SUCCESS if successful.
Win32 error code otherwise.
--*/
{
DWORD status;
HDMKEY resKey = NULL;
//
// If the resources are not in the same group, fail the
// call. Also fail if some one tries to make a resource
// dependent upon itself.
//
if ((Resource->Group != DependsOn->Group) ||
(Resource == DependsOn)) {
return(ERROR_INVALID_PARAMETER);
}
//
// Remove the dependency from the registry database.
//
resKey = DmOpenKey(DmResourcesKey,
OmObjectId(Resource),
KEY_READ | KEY_SET_VALUE);
if (resKey == NULL)
{
status = GetLastError();
CL_LOGFAILURE(status);
goto FnExit;
}
else
{
status = DmLocalRemoveFromMultiSz(hXsaction,
resKey,
CLUSREG_NAME_RES_DEPENDS_ON,
OmObjectId(DependsOn));
}
FnExit:
if ( resKey ) {
DmCloseKey(resKey);
}
return(status);
} // FmpRemoveResourceDependency
DWORD
FmpChangeResourceGroup(
IN PFM_RESOURCE pResource,
IN PFM_GROUP pNewGroup
)
/*++
Routine Description:
Moves a resource from one group to another.
Arguments:
pResource - Supplies the resource to move.
pNewGroup - Supplies the new group that the resource should be in.
Return Value:
ERROR_SUCCESS if successful
Win32 error code otherwise.
--*/
{
DWORD dwBufSize;
LPCWSTR pszResourceId;
DWORD dwResourceLen;
LPCWSTR pszGroupId;
DWORD dwGroupLen;
DWORD dwStatus;
PGUM_CHANGE_GROUP pGumChange;
// we need to validate here as well
// this is called by the server side
// this will help avoid a gum call if things have changed
// since the request started from the originator
// and got to the server
//
// Check if we're moving to same group.
//
if (pResource->Group == pNewGroup) {
dwStatus = ERROR_ALREADY_EXISTS;
goto FnExit;
}
//
// For now... both Groups must be owned by the same node.
//
if ( pResource->Group->OwnerNode != pNewGroup->OwnerNode ) {
dwStatus = ERROR_HOST_NODE_NOT_GROUP_OWNER;
goto FnExit;
}
pszResourceId = OmObjectId(pResource);
dwResourceLen = (lstrlenW(pszResourceId)+1)*sizeof(WCHAR);
pszGroupId = OmObjectId(pNewGroup);
dwGroupLen = (lstrlenW(pszGroupId)+1)*sizeof(WCHAR);
dwBufSize = sizeof(GUM_CHANGE_GROUP) - sizeof(WCHAR) + dwResourceLen + dwGroupLen;
pGumChange = LocalAlloc(LMEM_FIXED, dwBufSize);
if (pGumChange == NULL) {
dwStatus = ERROR_NOT_ENOUGH_MEMORY;
goto FnExit;
}
pGumChange->ResourceIdLen = dwResourceLen;
CopyMemory(pGumChange->ResourceId, pszResourceId, dwResourceLen);
CopyMemory((PCHAR)pGumChange->ResourceId + dwResourceLen,
pszGroupId,
dwGroupLen);
dwStatus = GumSendUpdate(GumUpdateFailoverManager,
FmUpdateChangeGroup,
dwBufSize,
pGumChange);
LocalFree(pGumChange);
FnExit:
return(dwStatus);
}// FmpChangeResourceGroup
DWORD
FmpClusterEventPropHandler(
IN PFM_RESOURCE pResource
)
/*++
Routine Description:
Post a worker item to process a cluster name change.
Arguments:
pResource - pointer to the resouce which is affected by the cluster
property change.
Return Value:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
--*/
{
PFM_RESTYPE pResType;
DWORD dwError=ERROR_SUCCESS;
pResType = pResource->Type;
if ((pResource->ExFlags & CLUS_FLAG_CORE) &&
( !lstrcmpiW(OmObjectId(pResType), CLUS_RESTYPE_NAME_NETNAME)))
{
FmResourceControl(pResource, NmLocalNode,
CLUSCTL_RESOURCE_CLUSTER_NAME_CHANGED, NULL, 0, NULL, 0, NULL, NULL);
}
return (dwError);
} // FmpClusterEventPropHandler
BOOL
FmpEnumResourceNodeEvict(
IN PVOID Context1,
IN PVOID Context2,
IN PVOID Object,
IN LPCWSTR Name
)
/*++
Routine Description:
Resource enumeration callback for removing node references when
a node is evicted.
Arguments:
Context1 - Supplies the node that is being evicted.
Context2 - not used
Object - Supplies a pointer to the resource object
Name - Supplies the resource's object name.
Return Value:
TRUE to continue enumeration
--*/
{
PFM_RESOURCE Resource = (PFM_RESOURCE)Object;
PNM_NODE Node = (PNM_NODE)Context1;
PLIST_ENTRY listEntry;
PPOSSIBLE_ENTRY possibleEntry;
ClRtlLogPrint(LOG_NOISE,
"[FM] EnumResourceNodeEvict: Removing references to node %1!ws! from resource %2!ws!\n",
OmObjectId(Node),
OmObjectId(Resource));
FmpAcquireLocalResourceLock(Resource);
FmpRemovePossibleNode(Resource, Node, TRUE);
FmpReleaseLocalResourceLock(Resource);
//
// Notify the resource of the removal of the node.
//
FmpRmResourceControl( Resource,
CLUSCTL_RESOURCE_EVICT_NODE,
(PUCHAR)OmObjectId(Node),
((lstrlenW(OmObjectId(Node)) + 1) * sizeof(WCHAR)),
NULL,
0,
NULL,
NULL );
// Ignore status return
ClusterEvent( CLUSTER_EVENT_RESOURCE_PROPERTY_CHANGE, Resource );
return(TRUE);
} // FmpEnumResourceNodeEvict
DWORD
FmpPrepareQuorumResChange(
IN PFM_RESOURCE pNewQuoRes,
IN LPCWSTR lpszQuoLogPath,
IN DWORD dwMaxQuoLogSize
)
/*++
Routine Description:
This routine prepares for a quorum resource change operation.
Arguments:
pNewQuoRes - pointer to the new quorum resource.
lpszQuoLogPath - pointer to the quorum log path string name.
dwMaxQuoLogSize - the maximum size of the quorum log path string.
--*/
{
CL_ASSERT(pNewQuoRes->Group->OwnerNode == NmLocalNode);
return(DmPrepareQuorumResChange(pNewQuoRes, lpszQuoLogPath, dwMaxQuoLogSize));
} // FmpPrepareQuorumResChange
DWORD
FmpCompleteQuorumResChange(
IN LPCWSTR lpszOldQuoResId,
IN LPCWSTR lpszQuoLogPath
)
/*++
Routine Description:
This routine is called if the new quorum log path is not the same as the old
quorum log path. This completes the change of quorum resource by deleting the old
quorum log files and creating a tompstone for them. A node that tries to do a form
with this as the quorum resource is prevented and has to do a join to get the location
of the new quorum resource and quorum log file.
Arguments:
pOldQuoRes - pointer to the new quorum resource.
lpszOldQuoLogPath - pointer to the quorum log path string name.
dwMaxQuoLogSize - the maximum size of the quorum log path string.
--*/
{
return(DmCompleteQuorumResChange(lpszOldQuoResId, lpszQuoLogPath));
} // FmpCompleteQuorumResChange
VOID
FmpResourceLastReference(
IN PFM_RESOURCE Resource
)
/*++
Routine Description:
Last dereference to resource object processing routine.
All cleanup for a resource should really be done here!
Arguments:
Resource - pointer the resource being removed.
Return Value:
None.
--*/
{
if ( Resource->DebugPrefix != NULL )
LocalFree(Resource->DebugPrefix);
if (Resource->Dependencies)
LocalFree(Resource->Dependencies);
if ( Resource->Group ) {
OmDereferenceObject(Resource->Group);
}
if (Resource->Type)
OmDereferenceObject(Resource->Type);
return;
} // FmpResourceLastReference
BOOL
FmpCheckNetworkDependencyWorker(
IN LPCWSTR DependentNetwork,
OUT PBOOL FoundDependency,
IN PFM_RESOURCE Resource,
IN LPCWSTR Name
)
/*++
Routine Description:
Enumeration callback routine for finding an IP Address resource
and checking its dependency on given network guid.
Arguments:
DependentNetwork - The GUID of the network to check for a dependency.
FoundDependency - Returns TRUE if a dependency is found.
Resource - Supplies the current resource.
Name - Supplies the current resource's name.
Return Value:
TRUE - to continue searching
FALSE - to stop the search. The matching resource is returned in
*FoundResource
Notes:
The IP Address resource's parameters are searched directly by this
routine. Fetching them from the resource itself causes a deadlock.
This routine is called by the NM from within a global udpate
handler. The resource would have to call back into the cluster registry
routines, which would deadlock over the GUM lock.
--*/
{
BOOL returnValue = TRUE;
if ( lstrcmpiW(
OmObjectId(Resource->Type),
CLUS_RESTYPE_NAME_IPADDR
) == 0
)
{
LPCWSTR resourceId = OmObjectId(Resource);
DWORD status;
HDMKEY resourceKey = DmOpenKey(DmResourcesKey, resourceId, KEY_READ);
if (resourceKey != NULL) {
HDMKEY paramsKey = DmOpenKey(
resourceKey,
L"Parameters",
KEY_READ
);
if (paramsKey != NULL) {
LPWSTR networkId = NULL;
DWORD valueLength = 0, valueSize = 0;
status = DmQueryString(
paramsKey,
L"Network",
REG_SZ,
&networkId,
&valueLength,
&valueSize
);
if (status == ERROR_SUCCESS) {
if ( lstrcmpiW( networkId, DependentNetwork ) == 0 ) {
*FoundDependency = TRUE;
returnValue = FALSE;
}
LocalFree(networkId);
}
else {
ClRtlLogPrint(LOG_WARNING,
"[NM] Query of Network value failed for ip addr resource %1!ws!, status %2!u!.\n",
resourceId,
status
);
}
DmCloseKey(paramsKey);
}
else {
status = GetLastError();
ClRtlLogPrint(LOG_WARNING,
"[FM] Failed to open params key for resource %1!ws!, status %2!u!\n",
resourceId,
status
);
}
DmCloseKey(resourceKey);
}
else {
status = GetLastError();
ClRtlLogPrint(LOG_WARNING,
"[FM] Failed to open key for resource %1!ws!, status %2!u!\n",
resourceId,
status
);
}
}
return(returnValue);
} // FmpCheckNetworkDependencyWorker
//lock must be held when this routine is called
DWORD FmpChangeResourceNode(
IN PFM_RESOURCE Resource,
IN LPCWSTR NodeId,
IN BOOL Add
)
{
PGUM_CHANGE_POSSIBLE_NODE GumChange;
LPCWSTR ResourceId;
DWORD ResourceLen;
DWORD NodeLen;
DWORD BufSize;
DWORD Status;
PLIST_ENTRY pListEntry;
PRESTYPE_POSSIBLE_ENTRY pResTypePosEntry = NULL;
BOOL bNodeSupportsResType = FALSE;
BOOL bRecalc = TRUE;
PPOSSIBLE_ENTRY PossibleEntry;
PNM_NODE pNode = NULL;
if ( Resource->QuorumResource ) {
Status = ERROR_INVALID_OPERATION_ON_QUORUM;
goto FnExit;
}
//
// We can't allow the owner node to be removed if the state
// of the resource or the group is not offline or failed.
//
if ( !Add &&
(NodeId == OmObjectId(NmLocalNode)) &&
(((Resource->State != ClusterResourceOffline) &&
(Resource->State != ClusterResourceFailed)) ||
(FmpGetGroupState( Resource->Group, TRUE ) != ClusterGroupOffline)) ) {
Status = ERROR_INVALID_STATE;
goto FnExit;
}
//make sure the node is on the list of possible nodes for this
// resource type
if (Add)
{
//if it is already on the list, return an error and dont
//send a gum update call
pNode = OmReferenceObjectById(ObjectTypeNode, NodeId);
pListEntry = Resource->PossibleOwners.Flink;
while (pListEntry != &Resource->PossibleOwners) {
PossibleEntry = CONTAINING_RECORD( pListEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
if (PossibleEntry->PossibleNode == pNode) {
//
// Found a match, fail the duplicate add. Note that
// we must fail here, not succeed, so that the API
// layer knows not to add a duplicate to the registry.
//
Status = ERROR_OBJECT_ALREADY_EXISTS;
goto FnExit;
}
pListEntry = pListEntry->Flink;
}
ChkResTypeList:
pListEntry = &(Resource->Type->PossibleNodeList);
for (pListEntry = pListEntry->Flink;
pListEntry != &(Resource->Type->PossibleNodeList);
pListEntry = pListEntry->Flink)
{
pResTypePosEntry = CONTAINING_RECORD(pListEntry, RESTYPE_POSSIBLE_ENTRY,
PossibleLinkage);
if (!lstrcmpW(OmObjectId(pResTypePosEntry->PossibleNode), NodeId))
{
bNodeSupportsResType = TRUE;
break;
}
}
if (!bNodeSupportsResType && bRecalc)
{
//if th node is not found, recalc again and retry..since then the
//dll might have been copied to this node
FmpSetPossibleNodeForResType(OmObjectId(Resource->Type), TRUE);
bRecalc = FALSE;
goto ChkResTypeList;
}
if (!bNodeSupportsResType)
{
Status = ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED;
goto FnExit;
}
}
ResourceId = OmObjectId(Resource);
ResourceLen = (lstrlenW(ResourceId)+1)*sizeof(WCHAR);
NodeLen = (lstrlenW(NodeId)+1)*sizeof(WCHAR);
BufSize = sizeof(GUM_CHANGE_POSSIBLE_NODE) - sizeof(WCHAR) + ResourceLen + NodeLen;
GumChange = LocalAlloc(LMEM_FIXED, BufSize);
if (GumChange == NULL) {
CsInconsistencyHalt( ERROR_NOT_ENOUGH_MEMORY );
Status = ERROR_NOT_ENOUGH_MEMORY;
goto FnExit;
}
GumChange->ResourceIdLen = ResourceLen;
CopyMemory(GumChange->ResourceId, ResourceId, ResourceLen);
CopyMemory((PCHAR)GumChange->ResourceId + ResourceLen,
NodeId,
NodeLen);
Status = GumSendUpdate(GumUpdateFailoverManager,
Add ? FmUpdateAddPossibleNode : FmUpdateRemovePossibleNode,
BufSize,
GumChange);
LocalFree(GumChange);
FnExit:
if (pNode)
OmDereferenceObject(pNode);
return(Status);
}
BOOL
FmpCheckNetworkDependency(
IN LPCWSTR DependentNetwork
)
/*++
Routine Description:
Checks for an IP Address resource that may be dependent on the given
Network.
Arguments:
DependentNetwork - the dependent network to check for.
Returns:
TRUE - if an IP Address depends on the given network.
FALSE otherwise.
--*/
{
BOOL dependent = FALSE;
OmEnumObjects(ObjectTypeResource,
(OM_ENUM_OBJECT_ROUTINE)FmpCheckNetworkDependencyWorker,
(PVOID)DependentNetwork,
&dependent);
return(dependent);
} // FmpCheckNetworkDependency
/****
@func DWORD | FmpFixupPossibleNodesForResources| This fixes the possible
node information for a resource based on whether this node
supports the given resource type.
@parm IN BOOL| bJoin | If this node is joining, bJoin is set to TRUE.
@comm This routine iterates thru all the resources in a system and fixes
their possible node information. If this node is not on the possible
node list for the resource type corresponding to the resource, it
is also removed from the possible node list for the resource.
@rdesc Returns a result code. ERROR_SUCCESS on success.
@xref <f FmpEnumFixupPossibleNodeForResource>
****/
DWORD
FmpFixupPossibleNodesForResources(
BOOL bJoin
)
{
DWORD dwStatus=ERROR_SUCCESS;
ClRtlLogPrint(LOG_NOISE,"[FM] FmpFixupPossibleNodesForResources Entry.\n");
//
// Fix up all resources's possible node list information
//
OmEnumObjects( ObjectTypeResource,
FmpEnumFixupPossibleNodesForResource,
NULL,
NULL);
ClRtlLogPrint(LOG_NOISE,"[FM] FmpFixupPossibleNodesForResources Exit\r\n");
return(dwStatus);
} // FmpFixupPossibleNodesForResources
/****
@func DWORD | FmpEnumFixupPossibleNodesForResource | This is the enumeration
callback for every resource type to fix the possible node
information related with it.
@parm IN PVOID | pContext1 | Not used.
@parm IN PVOID | pContext2 | Not Used.
@parm IN PFM_RESTYPE | pResType | Pointer to the resource type object.
@parm IN LPCWSTR | pszResTypeName | The name of the resource type.
@comm This routine iterates thru all the resources in a system and fixes
their possible node information. If this node is not on the possible
node list for the resource type corresponding to the resource, it
is also removed from the possible node list for the resource.
@rdesc Returns a result code. ERROR_SUCCESS on success.
@xref <f FmpFixupPossibleNodesForResources>
****/
BOOL
FmpEnumFixupPossibleNodesForResource(
IN PVOID pContext1,
IN PVOID pContext2,
IN PFM_RESOURCE pResource,
IN LPCWSTR pszResName
)
{
//if we are on the possible node list for the
//resource but not for the resource type, remove it
//from the possible node for the resource as well.
//We do this because the join logic adds all nodes
//as possible owners for a resource and we have
//the rolling upgrade requirements - hence the fixups
//have to be made later on
if ((FmpInPossibleListForResource(pResource, NmLocalNode)) &&
!(FmpInPossibleListForResType(pResource->Type, NmLocalNode)))
{
//if we dont support this resource type, make sure it is not on the possible node
//list for a resource of this type
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpEnumFixupPossibleNode:remove local node for resource %1!ws!\r\n",
OmObjectId(pResource));
//we send a gum update to remove it from all nodes
FmChangeResourceNode(pResource, NmLocalNode, FALSE);
}
//we add ourselves on the list only on a fresh install
//not on an upgrade
//csfirst run is also true on an upgrade, hence we need to
//check that csupgrade is false
if ((!FmpInPossibleListForResource(pResource, NmLocalNode)) &&
(FmpInPossibleListForResType(pResource->Type, NmLocalNode))
&& CsFirstRun && !CsUpgrade)
{
//if we support a resource of this type, but we are not on the possible
//list for this resource, then add the local node to the possible list
//this may happen because on a setup join the other nodes may not
//add us because the possible node list exists. The possible node list
//may exist either because the user set it or we internally set it due
//to non availability of this resource type dll on one of the nodes
//Note that irrespective of whether the user had set the possible list
//or we set it internally, we always add a new node that joins
//to the possible node list of resources that are supported.
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpEnumFixupPossibleNode:add local node for resource %1!ws!\r\n",
OmObjectId(pResource));
//we send a gum update to add it from all nodes
FmChangeResourceNode(pResource, NmLocalNode, TRUE);
}
//continue enumeration
return (TRUE);
}
DWORD FmpCleanupPossibleNodeList(
IN PFM_RESOURCE pResource)
{
PLIST_ENTRY pListEntry;
PPOSSIBLE_ENTRY pPossibleEntry;
DWORD dwStatus = ERROR_SUCCESS;
//for all possible nodes for this resource, check if the resource type
//supports it. If it doesnt, then remove that node from the in memory list
pListEntry = pResource->PossibleOwners.Flink;
while (pListEntry != &pResource->PossibleOwners)
{
//get the possible entry at this link
pPossibleEntry = CONTAINING_RECORD( pListEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
//save the pointer to the next link
pListEntry = pListEntry->Flink;
if (!FmpInPossibleListForResType(pResource->Type,
pPossibleEntry->PossibleNode))
{
ClRtlLogPrint(LOG_NOISE,
"[FM] FmpCleanupPossibleNodeList:remove local node %1!u! for resource %2!ws!\r\n",
NmGetNodeId(pPossibleEntry->PossibleNode), OmObjectId(pResource));
FmChangeResourceNode(pResource, pPossibleEntry->PossibleNode,
FALSE);
}
}
return (dwStatus);
}
/****
@func DWORD | FmpInPossibleListForResource| This checks if a given node
is in the possible list of nodes for a resource.
@parm IN PFM_RESOURCE | pResource | A pointer to the the resource.
@parm IN PNM_NODE | pNode | A pointer to the node object.
@comm This routine check if a node is in the list of possible nodes
for this resource.
@rdesc Returns a result code. ERROR_SUCCESS on success.
@xref <f FmpInPossibleListForResType>
****/
BOOL
FmpInPossibleListForResource(
IN PFM_RESOURCE pResource,
IN PNM_NODE pNode
)
{
PLIST_ENTRY plistEntry;
PPOSSIBLE_ENTRY pPossibleEntry;
//see if this node is on the possible node list for the resource
for ( plistEntry = pResource->PossibleOwners.Flink;
plistEntry != &(pResource->PossibleOwners);
plistEntry = plistEntry->Flink ) {
pPossibleEntry = CONTAINING_RECORD( plistEntry,
POSSIBLE_ENTRY,
PossibleLinkage );
if ( pPossibleEntry->PossibleNode == pNode ) {
return(TRUE);
}
}
return(FALSE);
} // FmpInPossibleListForResource
/****
@func DWORD | FmpInPossibleListForResType| This checks if a given node
is in the possible list of nodes for a resource type.
@parm IN PFM_RESTYPE| pResType | A pointer to the the resource type.
@parm IN PNM_NODE | pNode | A pointer to the node object.
@comm This routine check if a node is in the list of possible nodes
for this resource type.
@rdesc Returns a result code. ERROR_SUCCESS on success.
@xref <f FmpInPossibleListForResource>
****/
BOOL
FmpInPossibleListForResType(
IN PFM_RESTYPE pResType,
IN PNM_NODE pNode
)
{
PLIST_ENTRY pListEntry;
PRESTYPE_POSSIBLE_ENTRY pResTypePosEntry;
ACQUIRE_SHARED_LOCK(gResTypeLock);
//see if this node is on the possible node list for the resource
for ( pListEntry = pResType->PossibleNodeList.Flink;
pListEntry != &(pResType->PossibleNodeList);
pListEntry = pListEntry->Flink )
{
pResTypePosEntry = CONTAINING_RECORD(pListEntry, RESTYPE_POSSIBLE_ENTRY,
PossibleLinkage);
if ( pResTypePosEntry->PossibleNode == pNode )
{
RELEASE_LOCK(gResTypeLock);
return(TRUE);
}
}
RELEASE_LOCK(gResTypeLock);
return(FALSE);
} // FmpInPossibleListForResType
DWORD
FmpValAddResourceDependency(
IN PFM_RESOURCE pResource,
IN PFM_RESOURCE pDependentResource
)
/*++
Routine Description:
Add a dependency from one resource to another.
Arguments:
Resource - The resource to add the dependent resource.
DependentResource - The dependent resource.
Returns:
ERROR_SUCCESS if successful.
A Win32 error code on failure.
--*/
{
DWORD dwStatus = ERROR_SUCCESS;
//
// If the resource or dependent resource have been marked for
// delete, then dont let a dependency be added.
//
if ((!IS_VALID_FM_RESOURCE(pResource)) ||
(!IS_VALID_FM_RESOURCE(pDependentResource)))
{
dwStatus = ERROR_RESOURCE_NOT_AVAILABLE;
goto FnExit;
}
if (pResource->QuorumResource)
{
dwStatus = ERROR_DEPENDENCY_NOT_ALLOWED;
goto FnExit;
}
//
// If the resources are not in the same group, fail the
// call. Also fail if some one tries to make a resource
// dependent upon itself.
//
if ((pResource->Group != pDependentResource->Group) ||
(pResource == pDependentResource))
{
dwStatus = ERROR_INVALID_PARAMETER;
goto FnExit;
}
// The resource to which the dependency is being added must be offline
// Otherwise, it looks like the dependency is in effect when the depending
// resource was not really brought online at the time the dependency
// existed
// must also be offline or failed.
// SS: For instance if a network name is dependent on two ip addresesses
// and
// is online and a third ip address resource dependency is added, the
// network name must be brought offline and online for the dependency
// to be truly in effect
//
if ((pResource->State != ClusterResourceOffline) &&
(pResource->State != ClusterResourceFailed))
{
dwStatus = ERROR_RESOURCE_ONLINE;
goto FnExit;
}
//
// Make sure that we don't have any circular dependencies!
//
if ( FmDependentResource( pDependentResource, pResource, FALSE ) )
{
dwStatus = ERROR_CIRCULAR_DEPENDENCY;
goto FnExit;
}
//
// Make sure that this dependency does not already exist!
//
if ( FmDependentResource(pResource, pDependentResource, TRUE))
{
dwStatus = ERROR_DEPENDENCY_ALREADY_EXISTS;
goto FnExit;
}
FnExit:
return(dwStatus);
} // FmpValAddResourceDependency
DWORD
FmpValRemoveResourceDependency(
IN PFM_RESOURCE pResource,
IN PFM_RESOURCE pDependentResource
)
/*++
Routine Description:
Validation routine for dependency removal.
Arguments:
pResource - The resource to remove the dependent resource.
pDependentResource - The dependent resource.
Returns:
ERROR_SUCCESS if the validation is successful.
A Win32 error code if the validation fails.
--*/
{
DWORD dwStatus = ERROR_SUCCESS;
//
// Chittur Subbaraman (chitturs) - 8/3/99
//
// This function checks whether it is legal to remove the dependency
// relationship between 2 resources. Note that this function only
// does a partial validation, the rest is done in the GUM handler.
//
//
// If the resource has been marked for delete, then dont
// let any dependency changes be made.
//
if ( !IS_VALID_FM_RESOURCE( pResource ) )
{
dwStatus = ERROR_RESOURCE_NOT_AVAILABLE;
goto FnExit;
}
if ( pResource->QuorumResource )
{
dwStatus = ERROR_DEPENDENCY_NOT_ALLOWED;
goto FnExit;
}
//
// If the resources are not in the same group, fail the
// call. Also fail if some one tries to make a resource
// dependent upon itself.
//
if ( ( pResource->Group != pDependentResource->Group ) ||
( pResource == pDependentResource ) )
{
dwStatus = ERROR_INVALID_PARAMETER;
goto FnExit;
}
//
// Ensure that both the resource and the dependent resource are in
// a stable state. This is necessary to prevent cases in which the
// user gets rid of a dependency link when one of the resources is in
// a pending state and later when the notification from resmon comes
// in and you try to stablize the rest of the waiting tree, the
// dependency link is already cut and so the rest of the tree is
// stuck in pending state for ever !
//
if ( ( pResource->State > ClusterResourcePending ) ||
( pDependentResource->State > ClusterResourcePending ) )
{
dwStatus = ERROR_INVALID_STATE;
goto FnExit;
}
FnExit:
return( dwStatus );
} // FmpValRemoveResourceDependency
Reference in a new issue Copy permalink