Headers diff for clusapi.dll between 6.1.7601.17514-Windows_7.0 and 6.3.9600.17415-Windows_8.1 versions



 clusapi.h (6.1.7601.17514-Windows_7.0)   clusapi.h (6.3.9600.17415-Windows_8.1) 
skipping to change at line 24 skipping to change at line 25
Revision History: Revision History:
--*/ --*/
#ifndef _CLUSTER_API_ #ifndef _CLUSTER_API_
#define _CLUSTER_API_ #define _CLUSTER_API_
#if _MSC_VER > 1000 #if _MSC_VER > 1000
#pragma once #pragma once
#endif #endif
#include <winapifamily.h>
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#define CLUSAPI_VERSION_SERVER2008 0x00000600 #define CLUSAPI_VERSION_SERVER2008 0x00000600
#define CLUSAPI_VERSION_SERVER2008R2 0x00000700 #define CLUSAPI_VERSION_SERVER2008R2 0x00000700
#define CLUSAPI_VERSION_WINDOWS8 0x00000701
#define CLUSAPI_VERSION_WINDOWSBLUE 0x00000702
#if (!defined(CLUSAPI_VERSION)) #if (!defined(CLUSAPI_VERSION))
#if (!defined(NTDDI_VERSION) || (NTDDI_VERSION >= NTDDI_WIN7)) #if (!defined(NTDDI_VERSION) || (NTDDI_VERSION >= NTDDI_WINBLUE))
#define CLUSAPI_VERSION CLUSAPI_VERSION_WINDOWSBLUE
#elif (NTDDI_VERSION >= NTDDI_WIN8)
#define CLUSAPI_VERSION CLUSAPI_VERSION_WINDOWS8
#elif (NTDDI_VERSION >= NTDDI_WIN7)
#define CLUSAPI_VERSION CLUSAPI_VERSION_SERVER2008R2 #define CLUSAPI_VERSION CLUSAPI_VERSION_SERVER2008R2
#else #else
#define CLUSAPI_VERSION CLUSAPI_VERSION_SERVER2008 #define CLUSAPI_VERSION CLUSAPI_VERSION_SERVER2008
#endif #endif
#endif // !defined(CLUSAPI_VERSION) #endif // !defined(CLUSAPI_VERSION)
#define CREATE_CLUSTER_VERSION CLUSAPI_VERSION_SERVER2008 #define CREATE_CLUSTER_VERSION CLUSAPI_VERSION_SERVER2008
#define CREATE_CLUSTER_MAJOR_VERSION_MASK 0xFFFFFF00 #define CREATE_CLUSTER_MAJOR_VERSION_MASK 0xFFFFFF00
#ifdef __cplusplus #ifdef __cplusplus
skipping to change at line 75 skipping to change at line 86
typedef struct _HCHANGE *HCHANGE; typedef struct _HCHANGE *HCHANGE;
typedef struct _HCLUSENUM *HCLUSENUM; typedef struct _HCLUSENUM *HCLUSENUM;
typedef struct _HGROUPENUM *HGROUPENUM; typedef struct _HGROUPENUM *HGROUPENUM;
typedef struct _HRESENUM *HRESENUM; typedef struct _HRESENUM *HRESENUM;
typedef struct _HNETWORKENUM *HNETWORKENUM; typedef struct _HNETWORKENUM *HNETWORKENUM;
typedef struct _HNODEENUM *HNODEENUM; typedef struct _HNODEENUM *HNODEENUM;
typedef struct _HRESTYPEENUM *HRESTYPEENUM; typedef struct _HRESTYPEENUM *HRESTYPEENUM;
typedef struct _HREGBATCH *HREGBATCH; typedef struct _HREGBATCH *HREGBATCH;
typedef struct _HREGBATCHPORT *HREGBATCHPORT; typedef struct _HREGBATCHPORT *HREGBATCHPORT;
typedef struct _HREGBATCHNOTIFICATION *HREGBATCHNOTIFICATION; typedef struct _HREGBATCHNOTIFICATION *HREGBATCHNOTIFICATION;
typedef struct _HREGREADBATCH *HREGREADBATCH;
typedef struct _HREGREADBATCHREPLY *HREGREADBATCHREPLY;
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
typedef struct _HNODEENUMEX *HNODEENUMEX; typedef struct _HNODEENUMEX *HNODEENUMEX;
typedef struct _HCLUSENUMEX *HCLUSENUMEX; typedef struct _HCLUSENUMEX *HCLUSENUMEX;
#endif #endif
#if(CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
typedef struct _HGROUPENUMEX *HGROUPENUMEX;
typedef struct _HRESENUMEX *HRESENUMEX;
#endif
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Definitions used in cluster management routines. // Definitions used in cluster management routines.
// //
#define MAX_CLUSTERNAME_LENGTH DNS_MAX_LABEL_LENGTH #define MAX_CLUSTERNAME_LENGTH DNS_MAX_LABEL_LENGTH
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
skipping to change at line 132 skipping to change at line 150
typedef struct CLUS_STARTING_PARAMS { typedef struct CLUS_STARTING_PARAMS {
DWORD dwSize; DWORD dwSize;
BOOL bForm; BOOL bForm;
BOOL bFirst; BOOL bFirst;
} CLUS_STARTING_PARAMS, * PCLUS_STARTING_PARAMS; } CLUS_STARTING_PARAMS, * PCLUS_STARTING_PARAMS;
#define CLUSTER_VERSION_FLAG_MIXED_MODE 0x00000001 #define CLUSTER_VERSION_FLAG_MIXED_MODE 0x00000001
#define CLUSTER_VERSION_UNKNOWN 0xFFFFFFFF #define CLUSTER_VERSION_UNKNOWN 0xFFFFFFFF
// these defines represent cluster numbers, not windows OS numbers
#define NT4_MAJOR_VERSION 1 #define NT4_MAJOR_VERSION 1
#define NT4SP4_MAJOR_VERSION 2 #define NT4SP4_MAJOR_VERSION 2
#define NT5_MAJOR_VERSION 3 #define NT5_MAJOR_VERSION 3
#define NT51_MAJOR_VERSION 4 #define NT51_MAJOR_VERSION 4
#define NT6_MAJOR_VERSION 5 #define NT6_MAJOR_VERSION 5
#define NT7_MAJOR_VERSION 6 #define NT7_MAJOR_VERSION 6
#define NT8_MAJOR_VERSION 7
#define NT9_MAJOR_VERSION 8
// //
// Version number macros // Version number macros
// //
#define CLUSTER_MAKE_VERSION( _maj, _min ) ((( _maj ) << 16 ) | ( _min )) #define CLUSTER_MAKE_VERSION( _maj, _min ) ((( _maj ) << 16 ) | ( _min ))
#define CLUSTER_GET_MAJOR_VERSION( _ver ) (( _ver ) >> 16 ) #define CLUSTER_GET_MAJOR_VERSION( _ver ) (( _ver ) >> 16 )
#define CLUSTER_GET_MINOR_VERSION( _ver ) (( _ver ) & 0xFFFF ) #define CLUSTER_GET_MINOR_VERSION( _ver ) (( _ver ) & 0xFFFF )
#endif // MIDL_PASS #endif // MIDL_PASS
skipping to change at line 194 skipping to change at line 215
{ {
CLUSREG_COMMAND_NONE = 0, CLUSREG_COMMAND_NONE = 0,
CLUSREG_SET_VALUE = 1, CLUSREG_SET_VALUE = 1,
CLUSREG_CREATE_KEY, CLUSREG_CREATE_KEY,
CLUSREG_DELETE_KEY, CLUSREG_DELETE_KEY,
CLUSREG_DELETE_VALUE, CLUSREG_DELETE_VALUE,
CLUSREG_SET_KEY_SECURITY, CLUSREG_SET_KEY_SECURITY,
CLUSREG_VALUE_DELETED, CLUSREG_VALUE_DELETED,
// Commands for read batch
CLUSREG_READ_KEY,
CLUSREG_READ_VALUE,
CLUSREG_READ_ERROR,
// Control command
CLUSREG_CONTROL_COMMAND,
CLUSREG_LAST_COMMAND CLUSREG_LAST_COMMAND
} CLUSTER_REG_COMMAND; } CLUSTER_REG_COMMAND;
#define CLUSREG_DATABASE_SYNC_WRITE_TO_ALL_NODES 1
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
typedef struct _CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT { typedef struct _CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT {
DWORD dwSize; DWORD dwSize;
DWORD dwVersion; DWORD dwVersion;
CLUSTER_RESOURCE_STATE_CHANGE_REASON eReason; CLUSTER_RESOURCE_STATE_CHANGE_REASON eReason;
} CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT, *PCLUSCTL_RESOURCE_STATE_CHANGE_R EASON_STRUCT; } CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT, *PCLUSCTL_RESOURCE_STATE_CHANGE_R EASON_STRUCT;
typedef struct _CLUSTER_BATCH_COMMAND typedef struct _CLUSTER_BATCH_COMMAND
{ {
CLUSTER_REG_COMMAND Command; CLUSTER_REG_COMMAND Command;
DWORD dwOptions; DWORD dwOptions;
LPCWSTR wzName; LPCWSTR wzName;
BYTE CONST * lpData; BYTE CONST * lpData;
DWORD cbData; DWORD cbData;
} CLUSTER_BATCH_COMMAND; } CLUSTER_BATCH_COMMAND;
typedef struct _CLUSTER_READ_BATCH_COMMAND
{
CLUSTER_REG_COMMAND Command;
DWORD dwOptions;
LPCWSTR wzSubkeyName;
LPCWSTR wzValueName;
BYTE CONST * lpData;
DWORD cbData;
} CLUSTER_READ_BATCH_COMMAND;
#endif // MIDL_PASS #endif // MIDL_PASS
#if CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2 #if CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2
#define CLUSTER_ENUM_ITEM_VERSION_1 0x00000001 #define CLUSTER_ENUM_ITEM_VERSION_1 0x00000001
#define CLUSTER_ENUM_ITEM_VERSION CLUSTER_ENUM_ITEM_VERSION_1 #define CLUSTER_ENUM_ITEM_VERSION CLUSTER_ENUM_ITEM_VERSION_1
typedef struct _CLUSTER_ENUM_ITEM { typedef struct _CLUSTER_ENUM_ITEM {
DWORD dwVersion; DWORD dwVersion;
DWORD dwType; DWORD dwType;
DWORD cbId; DWORD cbId;
LPWSTR lpszId; LPWSTR lpszId;
DWORD cbName; DWORD cbName;
LPWSTR lpszName; LPWSTR lpszName;
} CLUSTER_ENUM_ITEM, *PCLUSTER_ENUM_ITEM; } CLUSTER_ENUM_ITEM, *PCLUSTER_ENUM_ITEM;
#endif // CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2 #endif // CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2
typedef enum {
ClusGroupTypeCoreCluster = 1,
ClusGroupTypeAvailableStorage = 2,
ClusGroupTypeTemporary = 3,
ClusGroupTypeSharedVolume = 4,
ClusGroupTypeStoragePool = 5,
ClusGroupTypeFileServer = 100,
ClusGroupTypePrintServer = 101,
ClusGroupTypeDhcpServer = 102,
ClusGroupTypeDtc = 103,
ClusGroupTypeMsmq = 104,
ClusGroupTypeWins = 105,
ClusGroupTypeStandAloneDfs = 106,
ClusGroupTypeGenericApplication = 107,
ClusGroupTypeGenericService = 108,
ClusGroupTypeGenericScript = 109,
ClusGroupTypeIScsiNameService = 110,
ClusGroupTypeVirtualMachine = 111,
ClusGroupTypeTsSessionBroker = 112,
ClusGroupTypeIScsiTarget = 113,
ClusGroupTypeScaleoutFileServer = 114,
ClusGroupTypeVMReplicaBroker = 115,
ClusGroupTypeTaskScheduler = 116,
ClusGroupTypeClusterUpdateAgent = 117,
ClusGroupTypeUnknown = 9999
} CLUSGROUP_TYPE, *PCLUSGROUP_TYPE;
#if CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8
#define CLUSTER_CREATE_GROUP_INFO_VERSION_1 0x00000001
#define CLUSTER_CREATE_GROUP_INFO_VERSION CLUSTER_CREATE_GROUP_INFO_VERSION_1
typedef struct _CLUSTER_CREATE_GROUP_INFO {
DWORD dwVersion;
CLUSGROUP_TYPE groupType;
}CLUSTER_CREATE_GROUP_INFO, *PCLUSTER_CREATE_GROUP_INFO;
#endif
typedef enum
{
CLUSTER_MGMT_POINT_TYPE_NONE = 0,
CLUSTER_MGMT_POINT_TYPE_CNO,
CLUSTER_MGMT_POINT_TYPE_DNS_ONLY
} CLUSTER_MGMT_POINT_TYPE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing clusters // Interfaces for managing clusters
// //
// //
// Cluster API Specific Access Rights // Cluster API Specific Access Rights
// //
#define CLUSAPI_READ_ACCESS 0x00000001L #define CLUSAPI_READ_ACCESS 0x00000001L
skipping to change at line 312 skipping to change at line 398
typedef struct _CREATE_CLUSTER_CONFIG typedef struct _CREATE_CLUSTER_CONFIG
{ {
DWORD dwVersion; DWORD dwVersion;
PCWSTR lpszClusterName; PCWSTR lpszClusterName;
DWORD cNodes; DWORD cNodes;
PCWSTR * ppszNodeNames; PCWSTR * ppszNodeNames;
DWORD cIpEntries; DWORD cIpEntries;
PCLUSTER_IP_ENTRY pIpEntries; PCLUSTER_IP_ENTRY pIpEntries;
BOOLEAN fEmptyCluster; BOOLEAN fEmptyCluster;
CLUSTER_MGMT_POINT_TYPE managementPointType;
} CREATE_CLUSTER_CONFIG, *PCREATE_CLUSTER_CONFIG; } CREATE_CLUSTER_CONFIG, *PCREATE_CLUSTER_CONFIG;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
DWORD DWORD
WINAPI WINAPI
GetNodeClusterState( GetNodeClusterState(
__in_opt LPCWSTR lpszNodeName, _In_opt_ LPCWSTR lpszNodeName,
__out LPDWORD pdwClusterState _Out_ LPDWORD pdwClusterState
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_NODE_CLUSTER_STATE)( (WINAPI * PCLUSAPI_GET_NODE_CLUSTER_STATE)(
__in_opt LPCWSTR lpszNodeName, _In_opt_ LPCWSTR lpszNodeName,
__out LPDWORD pdwClusterState _Out_ LPDWORD pdwClusterState
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
OpenCluster( OpenCluster(
__in_opt LPCWSTR lpszClusterName _In_opt_ LPCWSTR lpszClusterName
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_OPEN_CLUSTER)( (WINAPI * PCLUSAPI_OPEN_CLUSTER)(
__in_opt LPCWSTR lpszClusterName _In_opt_ LPCWSTR lpszClusterName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HCLUSTER HCLUSTER
WINAPI WINAPI
OpenClusterEx( OpenClusterEx(
__in_opt LPCWSTR lpszClusterName, _In_opt_ LPCWSTR lpszClusterName,
__in DWORD DesiredAccess, _In_ DWORD DesiredAccess,
__out_opt DWORD* GrantedAccess _Out_opt_ DWORD* GrantedAccess
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_OPEN_CLUSTER_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_EX)(
__in_opt LPCWSTR lpszClusterName, _In_opt_ LPCWSTR lpszClusterName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
BOOL BOOL
WINAPI WINAPI
CloseCluster( CloseCluster(
__in HCLUSTER hCluster _In_ HCLUSTER hCluster
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER)(
__in HCLUSTER hCluster _In_ HCLUSTER hCluster
); );
DWORD DWORD
WINAPI WINAPI
SetClusterName( SetClusterName(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNewClusterName _In_ LPCWSTR lpszNewClusterName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SetClusterName)( (WINAPI * PCLUSAPI_SetClusterName)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNewClusterName _In_ LPCWSTR lpszNewClusterName
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterInformation( GetClusterInformation(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__out_ecount_part(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszClust _Out_writes_to_(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszCluster
erName, Name,
__inout LPDWORD lpcchClusterName, _Inout_ LPDWORD lpcchClusterName,
__out_opt LPCLUSTERVERSIONINFO lpClusterInfo _Out_opt_ LPCLUSTERVERSIONINFO lpClusterInfo
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_INFORMATION)( (WINAPI * PCLUSAPI_GET_CLUSTER_INFORMATION)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__out_ecount_part(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszClust _Out_writes_to_(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszCluster
erName, Name,
__inout LPDWORD lpcchClusterName, _Inout_ LPDWORD lpcchClusterName,
__out_opt LPCLUSTERVERSIONINFO lpClusterInfo _Out_opt_ LPCLUSTERVERSIONINFO lpClusterInfo
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterQuorumResource( GetClusterQuorumResource(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__out_ecount_part(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszRes _Out_writes_to_(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszResou
ourceName, rceName,
__inout LPDWORD lpcchResourceName, _Inout_ LPDWORD lpcchResourceName,
__out_ecount_part(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceN _Out_writes_to_(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceNam
ame, e,
__inout LPDWORD lpcchDeviceName, _Inout_ LPDWORD lpcchDeviceName,
__out LPDWORD lpdwMaxQuorumLogSize _Out_ LPDWORD lpdwMaxQuorumLogSize
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_QUORUM_RESOURCE)( (WINAPI * PCLUSAPI_GET_CLUSTER_QUORUM_RESOURCE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__out_ecount_part(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszRes _Out_writes_to_(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszResou
ourceName, rceName,
__inout LPDWORD lpcchResourceName, _Inout_ LPDWORD lpcchResourceName,
__out_ecount_part(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceN _Out_writes_to_(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceNam
ame, e,
__inout LPDWORD lpcchDeviceName, _Inout_ LPDWORD lpcchDeviceName,
__out LPDWORD lpdwMaxQuorumLogSize _Out_ LPDWORD lpdwMaxQuorumLogSize
); );
DWORD DWORD
WINAPI WINAPI
SetClusterQuorumResource( SetClusterQuorumResource(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in_opt LPCWSTR lpszDeviceName, _In_opt_ LPCWSTR lpszDeviceName,
__in DWORD dwMaxQuoLogSize _In_ DWORD dwMaxQuoLogSize
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_QUORUM_RESOURCE)( (WINAPI * PCLUSAPI_SET_CLUSTER_QUORUM_RESOURCE)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in_opt LPCWSTR lpszDeviceName, _In_opt_ LPCWSTR lpszDeviceName,
__in DWORD dwMaxQuoLogSize _In_ DWORD dwMaxQuoLogSize
); );
DWORD DWORD
WINAPI WINAPI
BackupClusterDatabase( BackupClusterDatabase(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszPathName _In_ LPCWSTR lpszPathName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_BACKUP_CLUSTER_DATABASE)( (WINAPI * PCLUSAPI_BACKUP_CLUSTER_DATABASE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszPathName _In_ LPCWSTR lpszPathName
); );
DWORD DWORD
WINAPI WINAPI
RestoreClusterDatabase( RestoreClusterDatabase(
__in LPCWSTR lpszPathName, _In_ LPCWSTR lpszPathName,
__in BOOL bForce, _In_ BOOL bForce,
__in_opt LPCWSTR lpszQuorumDriveLetter _In_opt_ LPCWSTR lpszQuorumDriveLetter
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_RESTORE_CLUSTER_DATABASE)( (WINAPI * PCLUSAPI_RESTORE_CLUSTER_DATABASE)(
__in LPCWSTR lpszPathName, _In_ LPCWSTR lpszPathName,
__in BOOL bForce, _In_ BOOL bForce,
__in_opt LPCWSTR lpszQuorumDriveLetter _In_opt_ LPCWSTR lpszQuorumDriveLetter
); );
DWORD DWORD
WINAPI WINAPI
SetClusterNetworkPriorityOrder( SetClusterNetworkPriorityOrder(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD NetworkCount, _In_ DWORD NetworkCount,
__in_ecount( NetworkCount ) HNETWORK NetworkList[] _In_reads_( NetworkCount ) HNETWORK NetworkList[]
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_PRIORITY_ORDER)( (WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_PRIORITY_ORDER)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD NetworkCount, _In_ DWORD NetworkCount,
__in_ecount( NetworkCount ) HNETWORK NetworkList[] _In_reads_( NetworkCount ) HNETWORK NetworkList[]
); );
DWORD DWORD
WINAPI WINAPI
SetClusterServiceAccountPassword( SetClusterServiceAccountPassword(
__in LPCWSTR lpszClusterName, _In_ LPCWSTR lpszClusterName,
__in LPCWSTR lpszNewPassword, _In_ LPCWSTR lpszNewPassword,
__in DWORD dwFlags, _In_ DWORD dwFlags,
__out_bcount_part_opt(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBufferSi _Out_writes_bytes_to_opt_(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBuff
ze) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer, erSize) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer,
__inout LPDWORD lpcbReturnStatusBufferSize _Inout_ LPDWORD lpcbReturnStatusBufferSize
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_SERVICE_ACCOUNT_PASSWORD)( (WINAPI * PCLUSAPI_SET_CLUSTER_SERVICE_ACCOUNT_PASSWORD)(
__in LPCWSTR lpszClusterName, _In_ LPCWSTR lpszClusterName,
__in LPCWSTR lpszNewPassword, _In_ LPCWSTR lpszNewPassword,
__in DWORD dwFlags, _In_ DWORD dwFlags,
__out_bcount_part_opt(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBufferSi _Out_writes_bytes_to_opt_(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBuff
ze) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer, erSize) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer,
__inout LPDWORD lpcbReturnStatusBufferSize _Inout_ LPDWORD lpcbReturnStatusBufferSize
); );
DWORD DWORD
WINAPI WINAPI
ClusterControl( ClusterControl(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_CONTROL)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster Event Notification API // Cluster Event Notification API
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Cluster event filter flags. // Cluster notification enums original
// //
typedef enum CLUSTER_CHANGE { typedef enum CLUSTER_CHANGE {
CLUSTER_CHANGE_NODE_STATE = 0x00000001, CLUSTER_CHANGE_NODE_STATE = 0x00000001,
CLUSTER_CHANGE_NODE_DELETED = 0x00000002, CLUSTER_CHANGE_NODE_DELETED = 0x00000002,
CLUSTER_CHANGE_NODE_ADDED = 0x00000004, CLUSTER_CHANGE_NODE_ADDED = 0x00000004,
CLUSTER_CHANGE_NODE_PROPERTY = 0x00000008, CLUSTER_CHANGE_NODE_PROPERTY = 0x00000008,
CLUSTER_CHANGE_REGISTRY_NAME = 0x00000010, CLUSTER_CHANGE_REGISTRY_NAME = 0x00000010,
CLUSTER_CHANGE_REGISTRY_ATTRIBUTES = 0x00000020, CLUSTER_CHANGE_REGISTRY_ATTRIBUTES = 0x00000020,
CLUSTER_CHANGE_REGISTRY_VALUE = 0x00000040, CLUSTER_CHANGE_REGISTRY_VALUE = 0x00000040,
skipping to change at line 610 skipping to change at line 697
CLUSTER_CHANGE_NETINTERFACE_ADDED | CLUSTER_CHANGE_NETINTERFACE_ADDED |
CLUSTER_CHANGE_NETINTERFACE_PROPE RTY | CLUSTER_CHANGE_NETINTERFACE_PROPE RTY |
CLUSTER_CHANGE_QUORUM_STATE | CLUSTER_CHANGE_QUORUM_STATE |
CLUSTER_CHANGE_CLUSTER_STATE | CLUSTER_CHANGE_CLUSTER_STATE |
CLUSTER_CHANGE_CLUSTER_PROPERTY | CLUSTER_CHANGE_CLUSTER_PROPERTY |
CLUSTER_CHANGE_CLUSTER_RECONNECT | CLUSTER_CHANGE_CLUSTER_RECONNECT |
CLUSTER_CHANGE_HANDLE_CLOSE) CLUSTER_CHANGE_HANDLE_CLOSE)
} CLUSTER_CHANGE; } CLUSTER_CHANGE;
#if ( CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8 )
//
// Cluster notification enums V2
//
typedef enum CLUSTER_NOTIFICATIONS_VERSION {
CLUSTER_NOTIFICATIONS_V1 = 0x00000001,
CLUSTER_NOTIFICATIONS_V2 = 0x00000002
} CLUSTER_NOTIFICATIONS_VERSION;
typedef enum CLUSTER_CHANGE_CLUSTER_V2 {
CLUSTER_CHANGE_CLUSTER_RECONNECT_V2 = 0x00000001,
CLUSTER_CHANGE_CLUSTER_STATE_V2 = 0x00000002,
CLUSTER_CHANGE_CLUSTER_GROUP_ADDED_V2 = 0x00000004,
CLUSTER_CHANGE_CLUSTER_HANDLE_CLOSE_V2 = 0x00000008,
CLUSTER_CHANGE_CLUSTER_NETWORK_ADDED_V2 = 0x00000010,
CLUSTER_CHANGE_CLUSTER_NODE_ADDED_V2 = 0x00000020,
CLUSTER_CHANGE_CLUSTER_RESOURCE_TYPE_ADDED_V2 = 0x00000040,
CLUSTER_CHANGE_CLUSTER_COMMON_PROPERTY_V2 = 0x00000080,
CLUSTER_CHANGE_CLUSTER_PRIVATE_PROPERTY_V2 = 0x00000100,
CLUSTER_CHANGE_CLUSTER_LOST_NOTIFICATIONS_V2 = 0x00000200,
CLUSTER_CHANGE_CLUSTER_RENAME_V2 = 0x00000400,
CLUSTER_CHANGE_CLUSTER_MEMBERSHIP_V2 = 0x00000800,
CLUSTER_CHANGE_CLUSTER_ALL_V2 = (CLUSTER_CHANGE_CLUSTER
_RECONNECT_V2 |
CLUSTER_CHANGE_CLUSTER
_STATE_V2 |
CLUSTER_CHANGE_CLUSTER
_GROUP_ADDED_V2 |
CLUSTER_CHANGE_CLUSTER
_HANDLE_CLOSE_V2 |
CLUSTER_CHANGE_CLUSTER
_NETWORK_ADDED_V2 |
CLUSTER_CHANGE_CLUSTER
_NODE_ADDED_V2 |
CLUSTER_CHANGE_CLUSTER
_RESOURCE_TYPE_ADDED_V2 |
CLUSTER_CHANGE_CLUSTER
_COMMON_PROPERTY_V2 |
CLUSTER_CHANGE_CLUSTER
_PRIVATE_PROPERTY_V2 |
CLUSTER_CHANGE_CLUSTER
_LOST_NOTIFICATIONS_V2 |
CLUSTER_CHANGE_CLUSTER
_RENAME_V2 |
CLUSTER_CHANGE_CLUSTER
_MEMBERSHIP_V2)
} CLUSTER_CHANGE_CLUSTER_V2;
typedef enum CLUSTER_CHANGE_GROUP_V2 {
CLUSTER_CHANGE_GROUP_DELETED_V2 = 0x00000001,
CLUSTER_CHANGE_GROUP_COMMON_PROPERTY_V2 = 0x00000002,
CLUSTER_CHANGE_GROUP_PRIVATE_PROPERTY_V2 = 0x00000004,
CLUSTER_CHANGE_GROUP_STATE_V2 = 0x00000008,
CLUSTER_CHANGE_GROUP_OWNER_NODE_V2 = 0x00000010,
CLUSTER_CHANGE_GROUP_PREFERRED_OWNERS_V2 = 0x00000020,
CLUSTER_CHANGE_GROUP_RESOURCE_ADDED_V2 = 0x00000040,
CLUSTER_CHANGE_GROUP_RESOURCE_GAINED_V2 = 0x00000080,
CLUSTER_CHANGE_GROUP_RESOURCE_LOST_V2 = 0x00000100,
CLUSTER_CHANGE_GROUP_HANDLE_CLOSE_V2 = 0x00000200,
CLUSTER_CHANGE_GROUP_ALL_V2 = (CLUSTER_CHANGE_GROUP_DELETE
D_V2 |
CLUSTER_CHANGE_GROUP_COMMON
_PROPERTY_V2 |
CLUSTER_CHANGE_GROUP_PRIVAT
E_PROPERTY_V2 |
CLUSTER_CHANGE_GROUP_STATE_
V2 |
CLUSTER_CHANGE_GROUP_OWNER_
NODE_V2 |
CLUSTER_CHANGE_GROUP_PREFER
RED_OWNERS_V2 |
CLUSTER_CHANGE_GROUP_RESOUR
CE_ADDED_V2 |
CLUSTER_CHANGE_GROUP_RESOUR
CE_GAINED_V2 |
CLUSTER_CHANGE_GROUP_RESOUR
CE_LOST_V2 |
CLUSTER_CHANGE_GROUP_HANDLE
_CLOSE_V2)
} CLUSTER_CHANGE_GROUP_V2;
typedef enum CLUSTER_CHANGE_RESOURCE_V2 {
CLUSTER_CHANGE_RESOURCE_COMMON_PROPERTY_V2 = 0x00000001,
CLUSTER_CHANGE_RESOURCE_PRIVATE_PROPERTY_V2 = 0x00000002,
CLUSTER_CHANGE_RESOURCE_STATE_V2 = 0x00000004,
CLUSTER_CHANGE_RESOURCE_OWNER_GROUP_V2 = 0x00000008,
CLUSTER_CHANGE_RESOURCE_DEPENDENCIES_V2 = 0x00000010,
CLUSTER_CHANGE_RESOURCE_DEPENDENTS_V2 = 0x00000020,
CLUSTER_CHANGE_RESOURCE_POSSIBLE_OWNERS_V2 = 0x00000040,
CLUSTER_CHANGE_RESOURCE_DELETED_V2 = 0x00000080,
CLUSTER_CHANGE_RESOURCE_DLL_UPGRADED_V2 = 0x00000100,
CLUSTER_CHANGE_RESOURCE_HANDLE_CLOSE_V2 = 0x00000200,
CLUSTER_CHANGE_RESOURCE_TERMINAL_STATE_V2 = 0X00000400,
CLUSTER_CHANGE_RESOURCE_ALL_V2 = (CLUSTER_CHANGE_RESOURCE_
COMMON_PROPERTY_V2 |
CLUSTER_CHANGE_RESOURCE_
PRIVATE_PROPERTY_V2 |
CLUSTER_CHANGE_RESOURCE_
STATE_V2 |
CLUSTER_CHANGE_RESOURCE_
OWNER_GROUP_V2 |
CLUSTER_CHANGE_RESOURCE_
DEPENDENCIES_V2 |
CLUSTER_CHANGE_RESOURCE_
DEPENDENTS_V2 |
CLUSTER_CHANGE_RESOURCE_
POSSIBLE_OWNERS_V2 |
CLUSTER_CHANGE_RESOURCE_
DELETED_V2 |
CLUSTER_CHANGE_RESOURCE_
DLL_UPGRADED_V2 |
CLUSTER_CHANGE_RESOURCE_
HANDLE_CLOSE_V2 |
CLUSTER_CHANGE_RESOURCE_
TERMINAL_STATE_V2 )
} CLUSTER_CHANGE_RESOURCE_V2;
typedef enum CLUSTER_CHANGE_RESOURCE_TYPE_V2 {
CLUSTER_CHANGE_RESOURCE_TYPE_DELETED_V2 = 0x00000001,
CLUSTER_CHANGE_RESOURCE_TYPE_COMMON_PROPERTY_V2 = 0x00000002,
CLUSTER_CHANGE_RESOURCE_TYPE_PRIVATE_PROPERTY_V2 = 0x00000004,
CLUSTER_CHANGE_RESOURCE_TYPE_POSSIBLE_OWNERS_V2 = 0x00000008,
CLUSTER_CHANGE_RESOURCE_TYPE_DLL_UPGRADED_V2 = 0x00000010,
CLUSTER_CHANGE_RESOURCE_TYPE_ALL_V2 = (CLUSTER_CHANGE_RESO
URCE_TYPE_DELETED_V2 |
CLUSTER_CHANGE_RESO
URCE_TYPE_COMMON_PROPERTY_V2 |
CLUSTER_CHANGE_RESO
URCE_TYPE_PRIVATE_PROPERTY_V2 |
CLUSTER_CHANGE_RESO
URCE_TYPE_POSSIBLE_OWNERS_V2 |
CLUSTER_CHANGE_RESO
URCE_TYPE_DLL_UPGRADED_V2)
} CLUSTER_CHANGE_RESOURCE_TYPE_V2;
typedef enum CLUSTER_CHANGE_NETINTERFACE_V2 {
CLUSTER_CHANGE_NETINTERFACE_DELETED_V2 = 0x00000001,
CLUSTER_CHANGE_NETINTERFACE_COMMON_PROPERTY_V2 = 0x00000002,
CLUSTER_CHANGE_NETINTERFACE_PRIVATE_PROPERTY_V2 = 0x00000004,
CLUSTER_CHANGE_NETINTERFACE_STATE_V2 = 0x00000008,
CLUSTER_CHANGE_NETINTERFACE_HANDLE_CLOSE_V2 = 0x00000010,
CLUSTER_CHANGE_NETINTERFACE_ALL_V2 = (CLUSTER_CHANGE_NETIN
TERFACE_DELETED_V2 |
CLUSTER_CHANGE_NETIN
TERFACE_COMMON_PROPERTY_V2 |
CLUSTER_CHANGE_NETIN
TERFACE_PRIVATE_PROPERTY_V2 |
CLUSTER_CHANGE_NETIN
TERFACE_STATE_V2 |
CLUSTER_CHANGE_NETIN
TERFACE_HANDLE_CLOSE_V2)
} CLUSTER_CHANGE_NETINTERFACE_V2;
typedef enum CLUSTER_CHANGE_NETWORK_V2 {
CLUSTER_CHANGE_NETWORK_DELETED_V2 = 0x00000001,
CLUSTER_CHANGE_NETWORK_COMMON_PROPERTY_V2 = 0x00000002,
CLUSTER_CHANGE_NETWORK_PRIVATE_PROPERTY_V2 = 0x00000004,
CLUSTER_CHANGE_NETWORK_STATE_V2 = 0x00000008,
CLUSTER_CHANGE_NETWORK_HANDLE_CLOSE_V2 = 0x00000010,
CLUSTER_CHANGE_NETWORK_ALL_V2 = (CLUSTER_CHANGE_NETWORK_DE
LETED_V2 |
CLUSTER_CHANGE_NETWORK_CO
MMON_PROPERTY_V2 |
CLUSTER_CHANGE_NETWORK_PR
IVATE_PROPERTY_V2 |
CLUSTER_CHANGE_NETWORK_ST
ATE_V2 |
CLUSTER_CHANGE_NETWORK_HA
NDLE_CLOSE_V2)
} CLUSTER_CHANGE_NETWORK_V2;
typedef enum CLUSTER_CHANGE_NODE_V2 {
CLUSTER_CHANGE_NODE_NETINTERFACE_ADDED_V2 = 0x00000001,
CLUSTER_CHANGE_NODE_DELETED_V2 = 0x00000002,
CLUSTER_CHANGE_NODE_COMMON_PROPERTY_V2 = 0x00000004,
CLUSTER_CHANGE_NODE_PRIVATE_PROPERTY_V2 = 0x00000008,
CLUSTER_CHANGE_NODE_STATE_V2 = 0x00000010,
CLUSTER_CHANGE_NODE_GROUP_GAINED_V2 = 0x00000020,
CLUSTER_CHANGE_NODE_GROUP_LOST_V2 = 0x00000040,
CLUSTER_CHANGE_NODE_HANDLE_CLOSE_V2 = 0x00000080,
CLUSTER_CHANGE_NODE_ALL_V2 = (CLUSTER_CHANGE_NODE_NETINT
ERFACE_ADDED_V2 |
CLUSTER_CHANGE_NODE_DELETE
D_V2 |
CLUSTER_CHANGE_NODE_COMMON
_PROPERTY_V2 |
CLUSTER_CHANGE_NODE_PRIVAT
E_PROPERTY_V2 |
CLUSTER_CHANGE_NODE_STATE_
V2 |
CLUSTER_CHANGE_NODE_GROUP_
GAINED_V2 |
CLUSTER_CHANGE_NODE_GROUP_
LOST_V2 |
CLUSTER_CHANGE_NODE_HANDLE
_CLOSE_V2)
} CLUSTER_CHANGE_NODE_V2;
typedef enum CLUSTER_CHANGE_REGISTRY_V2 {
CLUSTER_CHANGE_REGISTRY_ATTRIBUTES_V2 = 0x00000001,
CLUSTER_CHANGE_REGISTRY_NAME_V2 = 0x00000002,
CLUSTER_CHANGE_REGISTRY_SUBTREE_V2 = 0x00000004,
CLUSTER_CHANGE_REGISTRY_VALUE_V2 = 0x00000008,
CLUSTER_CHANGE_REGISTRY_HANDLE_CLOSE_V2 = 0x00000010,
CLUSTER_CHANGE_REGISTRY_ALL_V2 = (CLUSTER_CHANGE_REGISTRY_ATTRIB
UTES_V2 |
CLUSTER_CHANGE_REGISTRY_NAME_V
2 |
CLUSTER_CHANGE_REGISTRY_SUBTRE
E_V2 |
CLUSTER_CHANGE_REGISTRY_VALUE_
V2 |
CLUSTER_CHANGE_REGISTRY_HANDLE
_CLOSE_V2)
} CLUSTER_CHANGE_REGISTRY_V2;
typedef enum CLUSTER_CHANGE_QUORUM_V2 {
CLUSTER_CHANGE_QUORUM_STATE_V2 = 0x00000001,
CLUSTER_CHANGE_QUORUM_ALL_V2 = (CLUSTER_CHANGE_QUORUM_STATE_V2)
} CLUSTER_CHANGE_QUORUM_V2;
typedef enum CLUSTER_CHANGE_SHARED_VOLUME_V2 {
CLUSTER_CHANGE_SHARED_VOLUME_STATE_V2 = 0x00000001,
CLUSTER_CHANGE_SHARED_VOLUME_ADDED_V2 = 0x00000002,
CLUSTER_CHANGE_SHARED_VOLUME_REMOVED_V2 = 0x00000004,
CLUSTER_CHANGE_SHARED_VOLUME_ALL_V2 = (CLUSTER_CHANGE_SHARED_VOLUME_STAT
E_V2 |
CLUSTER_CHANGE_SHARED_VOLUME_ADDE
D_V2 |
CLUSTER_CHANGE_SHARED_VOLUME_REMO
VED_V2)
} CLUSTER_CHANGE_SHARED_VOLUME_V2;
typedef enum CLUSTER_CHANGE_SPACEPORT_V2 {
CLUSTER_CHANGE_SPACEPORT_CUSTOM_PNP_V2 = 0x00000001,
} CLUSTER_CHANGE_SPACEPORT_V2;
typedef enum CLUSTER_OBJECT_TYPE {
CLUSTER_OBJECT_TYPE_NONE = 0x00000000,
CLUSTER_OBJECT_TYPE_CLUSTER = 0x00000001,
CLUSTER_OBJECT_TYPE_GROUP = 0x00000002,
CLUSTER_OBJECT_TYPE_RESOURCE = 0x00000003,
CLUSTER_OBJECT_TYPE_RESOURCE_TYPE = 0x00000004,
CLUSTER_OBJECT_TYPE_NETWORK_INTERFACE = 0x00000005,
CLUSTER_OBJECT_TYPE_NETWORK = 0x00000006,
CLUSTER_OBJECT_TYPE_NODE = 0x00000007,
CLUSTER_OBJECT_TYPE_REGISTRY = 0x00000008,
CLUSTER_OBJECT_TYPE_QUORUM = 0x00000009,
CLUSTER_OBJECT_TYPE_SHARED_VOLUME = 0x0000000a,
} CLUSTER_OBJECT_TYPE;
//
// Cluster notification structs V2
//
typedef struct _NOTIFY_FILTER_AND_TYPE
{
DWORD dwObjectType; // Uses CLUSTER_OBJECT_TYPE, but used for RPC so lef
t
// as DWORD
LONGLONG FilterFlags;
} NOTIFY_FILTER_AND_TYPE, *PNOTIFY_FILTER_AND_TYPE;
// Membership info returned as an array of up nodes
typedef struct _CLUSTER_MEMBERSHIP_INFO {
BOOL HasQuorum;
DWORD UpnodesSize;
BYTE Upnodes[1];
} CLUSTER_MEMBERSHIP_INFO, *PCLUSTER_MEMBERSHIP_INFO;
#endif // (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
#if ( CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8 )
//
// V2 Notifications DLL Functions
//
HCHANGE
WINAPI
CreateClusterNotifyPortV2(
_In_ HCHANGE hChange,
_In_ HCLUSTER hCluster,
_In_ NOTIFY_FILTER_AND_TYPE * Filters,
_In_ DWORD dwFilterCount,
_In_ DWORD_PTR dwNotifyKey
);
typedef HCHANGE
(WINAPI * PCLUSAPI_CREATE_CLUSTER_NOTIFY_PORT_V2)(
_In_ HCHANGE hChange,
_In_ HCLUSTER hCluster,
_In_ NOTIFY_FILTER_AND_TYPE * Filters,
_In_ DWORD dwFilterCount,
_In_ DWORD_PTR dwNotifyKey
);
DWORD
WINAPI
RegisterClusterNotifyV2(
_In_ HCHANGE hChange,
_In_ NOTIFY_FILTER_AND_TYPE Filter,
_In_ HANDLE hObject,
_In_ DWORD_PTR dwNotifyKey
);
typedef DWORD
(WINAPI * PCLUSAPI_REGISTER_CLUSTER_NOTIFY_V2)(
_In_ HCHANGE hChange,
_In_ NOTIFY_FILTER_AND_TYPE Filter,
_In_ HANDLE hObject,
_In_ DWORD_PTR dwNotifyKey
);
DWORD
WINAPI
GetNotifyEventHandle(
_In_ HCHANGE hChange,
_Out_ LPHANDLE lphTargetEvent
);
typedef DWORD
(WINAPI * PCLUSAPI_GET_NOTIFY_EVENT_HANDLE_V2)(
_In_ HCHANGE hChange,
_Out_ LPHANDLE lphTargetEvent
);
_Success_(return == ERROR_SUCCESS)
DWORD
WINAPI
GetClusterNotifyV2(
_In_ HCHANGE hCha
nge,
_Out_ DWORD_PTR* l
pdwNotifyKey,
_Inout_opt_ PNOTIFY_FILT
ER_AND_TYPE pFilterAndType,
_Inout_updates_bytes_opt_(*lpbBufferSize) BYTE*
buffer,
_Inout_opt_ LPDWORD lpbB
ufferSize,
_Inout_updates_to_opt_(*lpcchObjectId, *lpcchObjectId + 1 ) LPWSTR lpszOb
jectId,
_Inout_opt_ LPDWORD lpcc
hObjectId,
_Inout_updates_to_opt_(*lpcchParentId, *lpcchParentId + 1 ) LPWSTR lpszPa
rentId,
_Inout_opt_ LPDWORD lpcc
hParentId,
_Inout_updates_to_opt_(*lpcchName, *lpcchName + 1 ) LPWSTR lpszNa
me,
_Inout_opt_ LPDWORD lpcc
hName,
_Inout_updates_to_opt_(*lpcchType, *lpcchType + 1 ) LPWSTR lpszTy
pe,
_Inout_opt_ LPDWORD lpcc
hType,
_In_opt_ DWORD dwMill
iseconds
);
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NOTIFY_V2)(
_In_ HCHANGE hChange,
_Out_ DWORD_PTR* lpdwNotifyKey,
_Inout_opt_ PNOTIFY_FILTER_AND_TYPE pFilterAndType,
_Inout_opt_ BYTE* buffer,
_Inout_opt_ LPDWORD lpcchBufferSize,
_Inout_opt_ LPWSTR lpszObjectId,
_Inout_opt_ LPDWORD lpcchObjectId,
_Inout_opt_ LPWSTR lpszParentId,
_Inout_opt_ LPDWORD lpcchParentId,
_Inout_opt_ LPWSTR lpszName,
_Inout_opt_ LPDWORD lpcchName,
_Inout_opt_ LPWSTR lpszType,
_Inout_opt_ LPDWORD lpcchType,
_In_opt_ DWORD dwMilliseconds
);
#endif // (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
//
// Begin original notification DLL function defs
//
HCHANGE HCHANGE
WINAPI WINAPI
CreateClusterNotifyPort( CreateClusterNotifyPort(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwFilter, _In_ DWORD dwFilter,
__in DWORD_PTR dwNotifyKey _In_ DWORD_PTR dwNotifyKey
); );
typedef HCHANGE typedef HCHANGE
(WINAPI * PCLUSAPI_CREATE_CLUSTER_NOTIFY_PORT)( (WINAPI * PCLUSAPI_CREATE_CLUSTER_NOTIFY_PORT)(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwFilter, _In_ DWORD dwFilter,
__in DWORD_PTR dwNotifyKey _In_ DWORD_PTR dwNotifyKey
); );
DWORD DWORD
WINAPI WINAPI
RegisterClusterNotify( RegisterClusterNotify(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__in DWORD dwFilterType, _In_ DWORD dwFilterType,
__in HANDLE hObject, _In_ HANDLE hObject,
__in DWORD_PTR dwNotifyKey _In_ DWORD_PTR dwNotifyKey
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_REGISTER_CLUSTER_NOTIFY)( (WINAPI * PCLUSAPI_REGISTER_CLUSTER_NOTIFY)(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__in DWORD dwFilterType, _In_ DWORD dwFilterType,
__in HANDLE hObject, _In_ HANDLE hObject,
__in DWORD_PTR dwNotifyKey _In_ DWORD_PTR dwNotifyKey
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNotify( GetClusterNotify(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__out DWORD_PTR *lpdwNotifyKey, _Out_ DWORD_PTR *lpdwNotifyKey,
__out LPDWORD lpdwFilterType, _Out_ LPDWORD lpdwFilterType,
__out_ecount(*lpcchName) LPWSTR lpszName, _Out_writes_(*lpcchName) LPWSTR lpszName,
__inout LPDWORD lpcchName, _Inout_ LPDWORD lpcchName,
__in DWORD dwMilliseconds _In_ DWORD dwMilliseconds
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NOTIFY)( (WINAPI * PCLUSAPI_GET_CLUSTER_NOTIFY)(
__in HCHANGE hChange, _In_ HCHANGE hChange,
__out DWORD_PTR *lpdwNotifyKey, _Out_ DWORD_PTR *lpdwNotifyKey,
__out LPDWORD lpdwFilterType, _Out_ LPDWORD lpdwFilterType,
__out_ecount_part_opt(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_opt_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName, _Inout_ LPDWORD lpcchName,
__in DWORD dwMilliseconds _In_ DWORD dwMilliseconds
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterNotifyPort( CloseClusterNotifyPort(
__in HCHANGE hChange _In_ HCHANGE hChange
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NOTIFY_PORT)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_NOTIFY_PORT)(
__in HCHANGE hChange _In_ HCHANGE hChange
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Enumeration routines // Enumeration routines
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable types // Define enumerable types
// //
typedef enum CLUSTER_ENUM { typedef enum CLUSTER_ENUM {
CLUSTER_ENUM_NODE = 0x00000001, CLUSTER_ENUM_NODE = 0x00000001,
CLUSTER_ENUM_RESTYPE = 0x00000002, CLUSTER_ENUM_RESTYPE = 0x00000002,
CLUSTER_ENUM_RESOURCE = 0x00000004, CLUSTER_ENUM_RESOURCE = 0x00000004,
CLUSTER_ENUM_GROUP = 0x00000008, CLUSTER_ENUM_GROUP = 0x00000008,
CLUSTER_ENUM_NETWORK = 0x00000010, CLUSTER_ENUM_NETWORK = 0x00000010,
CLUSTER_ENUM_NETINTERFACE = 0x00000020, CLUSTER_ENUM_NETINTERFACE = 0x00000020,
CLUSTER_ENUM_SHARED_VOLUME_GROUP = 0x20000000,
CLUSTER_ENUM_SHARED_VOLUME_RESOURCE = 0x40000000, CLUSTER_ENUM_SHARED_VOLUME_RESOURCE = 0x40000000,
CLUSTER_ENUM_INTERNAL_NETWORK = 0x80000000, CLUSTER_ENUM_INTERNAL_NETWORK = 0x80000000,
CLUSTER_ENUM_ALL = (CLUSTER_ENUM_NODE | CLUSTER_ENUM_ALL = (CLUSTER_ENUM_NODE |
CLUSTER_ENUM_RESTYPE | CLUSTER_ENUM_RESTYPE |
CLUSTER_ENUM_RESOURCE | CLUSTER_ENUM_RESOURCE |
CLUSTER_ENUM_GROUP | CLUSTER_ENUM_GROUP |
CLUSTER_ENUM_NETWORK | CLUSTER_ENUM_NETWORK |
CLUSTER_ENUM_NETINTERFACE) CLUSTER_ENUM_NETINTERFACE)
} CLUSTER_ENUM; } CLUSTER_ENUM;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HCLUSENUM HCLUSENUM
WINAPI WINAPI
ClusterOpenEnum( ClusterOpenEnum(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HCLUSENUM typedef HCLUSENUM
(WINAPI * PCLUSAPI_CLUSTER_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_OPEN_ENUM)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwType _In_ DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterGetEnumCount( ClusterGetEnumCount(
__in HCLUSENUM hEnum _In_ HCLUSENUM hEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_GET_ENUM_COUNT)(
__in HCLUSENUM hEnum _In_ HCLUSENUM hEnum
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterEnum( ClusterEnum(
__in HCLUSENUM hEnum, _In_ HCLUSENUM hEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_ENUM)(
__in HCLUSENUM hEnum, _In_ HCLUSENUM hEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterCloseEnum( ClusterCloseEnum(
__in HCLUSENUM hEnum _In_ HCLUSENUM hEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_CLOSE_ENUM)(
__in HCLUSENUM hEnum _In_ HCLUSENUM hEnum
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HCLUSENUMEX HCLUSENUMEX
WINAPI WINAPI
ClusterOpenEnumEx( ClusterOpenEnumEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwType, _In_ DWORD dwType,
__in PVOID pOptions _In_opt_ PVOID pOptions
); );
typedef HCLUSENUMEX typedef HCLUSENUMEX
(WINAPI * PCLUSAPI_CLUSTER_OPEN_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_OPEN_ENUM_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in DWORD dwType, _In_ DWORD dwType,
__in PVOID pOptions _In_opt_ PVOID pOptions
); );
DWORD DWORD
WINAPI WINAPI
ClusterGetEnumCountEx( ClusterGetEnumCountEx(
__in HCLUSENUMEX hClusterEnum _In_ HCLUSENUMEX hClusterEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GET_ENUM_COUNT_EX)( (WINAPI * PCLUSAPI_CLUSTER_GET_ENUM_COUNT_EX)(
__in HCLUSENUMEX hClusterEnum _In_ HCLUSENUMEX hClusterEnum
); );
DWORD DWORD
WINAPI WINAPI
ClusterEnumEx( ClusterEnumEx(
__in HCLUSENUMEX hClusterEnum, _In_ HCLUSENUMEX hClusterEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__inout PCLUSTER_ENUM_ITEM pItem, _Inout_ PCLUSTER_ENUM_ITEM pItem,
__inout LPDWORD cbItem _Inout_ LPDWORD cbItem
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_ENUM_EX)(
__in HCLUSENUMEX hClusterEnum, _In_ HCLUSENUMEX hClusterEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__inout PCLUSTER_ENUM_ITEM pItem, _Inout_ PCLUSTER_ENUM_ITEM pItem,
__inout LPDWORD cbItem _Inout_ LPDWORD cbItem
); );
DWORD DWORD
WINAPI WINAPI
ClusterCloseEnumEx( ClusterCloseEnumEx(
__in HCLUSENUMEX hClusterEnum _In_ HCLUSENUMEX hClusterEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_CLOSE_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_CLOSE_ENUM_EX)(
__in HCLUSENUMEX hClusterEnum _In_ HCLUSENUMEX hClusterEnum
); );
#endif // CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2 #endif // CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable node types // Define enumerable node types
// //
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
typedef enum CLUSTER_NODE_ENUM { typedef enum CLUSTER_NODE_ENUM {
CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001, CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001,
CLUSTER_NODE_ENUM_GROUPS = 0x00000002, CLUSTER_NODE_ENUM_GROUPS = 0x00000002,
CLUSTER_NODE_ENUM_PREFERRED_GROUPS = 0x00000004,
CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES | CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES
CLUSTER_NODE_ENUM_GROUPS) |
CLUSTER_NODE_ENUM_GROUPS)
} CLUSTER_NODE_ENUM; } CLUSTER_NODE_ENUM;
#else #else
typedef enum CLUSTER_NODE_ENUM { typedef enum CLUSTER_NODE_ENUM {
CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001, CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001,
CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES) CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES)
} CLUSTER_NODE_ENUM; } CLUSTER_NODE_ENUM;
skipping to change at line 863 skipping to change at line 1255
// Node-related structures and types. // Node-related structures and types.
// //
typedef enum CLUSTER_NODE_STATE { typedef enum CLUSTER_NODE_STATE {
ClusterNodeStateUnknown = -1, ClusterNodeStateUnknown = -1,
ClusterNodeUp, ClusterNodeUp,
ClusterNodeDown, ClusterNodeDown,
ClusterNodePaused, ClusterNodePaused,
ClusterNodeJoining ClusterNodeJoining
} CLUSTER_NODE_STATE; } CLUSTER_NODE_STATE;
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
typedef enum CLUSTER_NODE_DRAIN_STATUS {
NodeDrainStatusNotInitiated = 0,
NodeDrainStatusInProgress,
NodeDrainStatusCompleted,
NodeDrainStatusFailed,
ClusterNodeDrainStatusCount
} CLUSTER_NODE_DRAIN_STATUS;
#endif //CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the nodes of a cluster. // Interfaces for managing the nodes of a cluster.
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HNODE HNODE
WINAPI WINAPI
OpenClusterNode( OpenClusterNode(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNodeName _In_ LPCWSTR lpszNodeName
); );
typedef HNODE typedef HNODE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NODE)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NODE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNodeName _In_ LPCWSTR lpszNodeName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HNODE HNODE
WINAPI WINAPI
OpenClusterNodeEx( OpenClusterNodeEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszNodeName, _In_opt_ LPCWSTR lpszNodeName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt DWORD* lpdwGrantedAccess _Out_opt_ DWORD* lpdwGrantedAccess
); );
typedef HNODE typedef HNODE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NODE_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NODE_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszNodeName, _In_opt_ LPCWSTR lpszNodeName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
BOOL BOOL
WINAPI WINAPI
CloseClusterNode( CloseClusterNode(
__in HNODE hNode _In_ HNODE hNode
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NODE)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_NODE)(
__in HNODE hNode _In_ HNODE hNode
); );
CLUSTER_NODE_STATE CLUSTER_NODE_STATE
WINAPI WINAPI
GetClusterNodeState( GetClusterNodeState(
__in HNODE hNode _In_ HNODE hNode
); );
typedef CLUSTER_NODE_STATE typedef CLUSTER_NODE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_STATE)( (WINAPI * PCLUSAPI_GET_CLUSTER_NODE_STATE)(
__in HNODE hNode _In_ HNODE hNode
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNodeId( GetClusterNodeId(
__in_opt HNODE hNode, _In_opt_ HNODE hNode,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_ID)( (WINAPI * PCLUSAPI_GET_CLUSTER_NODE_ID)(
__in_opt HNODE hNode, _In_opt_ HNODE hNode,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
#define GetCurrentClusterNodeId(_lpszNodeId_, _lpcchName_) \ #define GetCurrentClusterNodeId(_lpszNodeId_, _lpcchName_) \
GetClusterNodeId(NULL, (_lpszNodeId_), (_lpcchName_)) GetClusterNodeId(NULL, (_lpszNodeId_), (_lpcchName_))
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNode( GetClusterFromNode(
__in HNODE hNode _In_ HNODE hNode
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NODE)( (WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NODE)(
__in HNODE hNode _In_ HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
PauseClusterNode( PauseClusterNode(
__in HNODE hNode _In_ HNODE hNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_PAUSE_CLUSTER_NODE)( (WINAPI * PCLUSAPI_PAUSE_CLUSTER_NODE)(
__in HNODE hNode _In_ HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
ResumeClusterNode( ResumeClusterNode(
__in HNODE hNode _In_ HNODE hNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_RESUME_CLUSTER_NODE)( (WINAPI * PCLUSAPI_RESUME_CLUSTER_NODE)(
__in HNODE hNode _In_ HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
EvictClusterNode( EvictClusterNode(
__in HNODE hNode _In_ HNODE hNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE)( (WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE)(
__in HNODE hNode _In_ HNODE hNode
); );
HNODEENUM HNODEENUM
WINAPI WINAPI
ClusterNodeOpenEnum( ClusterNodeOpenEnum(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HNODEENUM typedef HNODEENUM
(WINAPI * PCLUSAPI_CLUSTER_NODE_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NODE_OPEN_ENUM)(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwType _In_ DWORD dwType
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HNODEENUMEX HNODEENUMEX
WINAPI WINAPI
ClusterNodeOpenEnumEx( ClusterNodeOpenEnumEx(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwType, _In_ DWORD dwType,
__in PVOID pOptions _In_opt_ PVOID pOptions
); );
typedef HNODEENUMEX typedef HNODEENUMEX
(WINAPI * PCLUSAPI_CLUSTER_NODE_OPEN_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_NODE_OPEN_ENUM_EX)(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwType, _In_ DWORD dwType,
__in PVOID pOptions _In_opt_ PVOID pOptions
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeGetEnumCountEx( ClusterNodeGetEnumCountEx(
__in HNODEENUMEX hNodeEnum _In_ HNODEENUMEX hNodeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_GET_ENUM_COUNT_EX)( (WINAPI * PCLUSAPI_CLUSTER_NODE_GET_ENUM_COUNT_EX)(
__in HNODEENUMEX hNodeEnum _In_ HNODEENUMEX hNodeEnum
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeEnumEx( ClusterNodeEnumEx(
__in HNODEENUMEX hNodeEnum, _In_ HNODEENUMEX hNodeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__inout PCLUSTER_ENUM_ITEM pItem, _Inout_ PCLUSTER_ENUM_ITEM pItem,
__inout LPDWORD cbItem _Inout_ LPDWORD cbItem
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_NODE_ENUM_EX)(
__in HNODEENUMEX hNodeEnum, _In_ HNODEENUMEX hNodeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__inout PCLUSTER_ENUM_ITEM pItem, _Inout_ PCLUSTER_ENUM_ITEM pItem,
__inout LPDWORD cbItem _Inout_ LPDWORD cbItem
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeCloseEnumEx( ClusterNodeCloseEnumEx(
__in HNODEENUMEX hNodeEnum _In_ HNODEENUMEX hNodeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_CLOSE_ENUM_EX)( (WINAPI * PCLUSAPI_CLUSTER_NODE_CLOSE_ENUM_EX)(
__in HNODEENUMEX hNodeEnum _In_ HNODEENUMEX hNodeEnum
); );
#endif #endif
DWORD DWORD
WINAPI WINAPI
ClusterNodeGetEnumCount( ClusterNodeGetEnumCount(
__in HNODEENUM hNodeEnum _In_ HNODEENUM hNodeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_NODE_GET_ENUM_COUNT)(
__in HNODEENUM hNodeEnum _In_ HNODEENUM hNodeEnum
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeCloseEnum( ClusterNodeCloseEnum(
__in HNODEENUM hNodeEnum _In_ HNODEENUM hNodeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NODE_CLOSE_ENUM)(
__in HNODEENUM hNodeEnum _In_ HNODEENUM hNodeEnum
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNodeEnum( ClusterNodeEnum(
__in HNODEENUM hNodeEnum, _In_ HNODEENUM hNodeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NODE_ENUM)(
__in HNODEENUM hNodeEnum, _In_ HNODEENUM hNodeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
EvictClusterNodeEx( EvictClusterNodeEx(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwTimeOut, _In_ DWORD dwTimeOut,
__out HRESULT * phrCleanupStatus _Out_ HRESULT * phrCleanupStatus
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE_EX)( (WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE_EX)(
__in HNODE hNode, _In_ HNODE hNode,
__in DWORD dwTimeOut, _In_ DWORD dwTimeOut,
__out HRESULT * phrCleanupStatus _Out_ HRESULT * phrCleanupStatus
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Interfaces for managing the resource types in a cluster // Interfaces for managing the resource types in a cluster
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HKEY HKEY
WINAPI WINAPI
GetClusterResourceTypeKey( GetClusterResourceTypeKey(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszTypeName, _In_ LPCWSTR lpszTypeName,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_TYPE_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_TYPE_KEY)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszTypeName, _In_ LPCWSTR lpszTypeName,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable group types // Define enumerable group types
// //
typedef enum CLUSTER_GROUP_ENUM { typedef enum CLUSTER_GROUP_ENUM {
CLUSTER_GROUP_ENUM_CONTAINS = 0x00000001, CLUSTER_GROUP_ENUM_CONTAINS = 0x00000001,
skipping to change at line 1163 skipping to change at line 1567
// //
typedef enum CLUSTER_GROUP_STATE { typedef enum CLUSTER_GROUP_STATE {
ClusterGroupStateUnknown = -1, ClusterGroupStateUnknown = -1,
ClusterGroupOnline, ClusterGroupOnline,
ClusterGroupOffline, ClusterGroupOffline,
ClusterGroupFailed, ClusterGroupFailed,
ClusterGroupPartialOnline, ClusterGroupPartialOnline,
ClusterGroupPending ClusterGroupPending
} CLUSTER_GROUP_STATE; } CLUSTER_GROUP_STATE;
typedef enum CLUSTER_GROUP_PRIORITY
{
PriorityDisabled = 0, // Groups with disabled priorities do not auto-start
PriorityLow = 1000,
PriorityMedium = 2000,
PriorityHigh = 3000,
} CLUSTER_GROUP_PRIORITY;
typedef enum CLUSTER_GROUP_AUTOFAILBACK_TYPE typedef enum CLUSTER_GROUP_AUTOFAILBACK_TYPE
{ {
ClusterGroupPreventFailback = 0, ClusterGroupPreventFailback = 0,
ClusterGroupAllowFailback, ClusterGroupAllowFailback,
ClusterGroupFailbackTypeCount ClusterGroupFailbackTypeCount
} CLUSTER_GROUP_AUTOFAILBACK_TYPE, CGAFT; } CLUSTER_GROUP_AUTOFAILBACK_TYPE, CGAFT;
#if CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8
#define CLUSTER_GROUP_ENUM_ITEM_VERSION_1 0x00000001
#define CLUSTER_GROUP_ENUM_ITEM_VERSION CLUSTER_GROUP_ENUM_ITEM_VERSION_1
typedef struct _CLUSTER_GROUP_ENUM_ITEM {
DWORD dwVersion;
DWORD cbId;
LPWSTR lpszId;
DWORD cbName;
LPWSTR lpszName;
CLUSTER_GROUP_STATE state;
DWORD cbOwnerNode;
LPWSTR lpszOwnerNode;
DWORD dwFlags;
DWORD cbProperties;
PVOID pProperties;
DWORD cbRoProperties;
PVOID pRoProperties;
} CLUSTER_GROUP_ENUM_ITEM, *PCLUSTER_GROUP_ENUM_ITEM;
#define CLUSTER_RESOURCE_ENUM_ITEM_VERSION_1 0x00000001
#define CLUSTER_RESOURCE_ENUM_ITEM_VERSION CLUSTER_RESOURCE_ENUM_ITEM_VERSION_
1
typedef struct _CLUSTER_RESOURCE_ENUM_ITEM {
DWORD dwVersion;
DWORD cbId;
LPWSTR lpszId;
DWORD cbName;
LPWSTR lpszName;
DWORD cbOwnerGroupName;
LPWSTR lpszOwnerGroupName;
DWORD cbOwnerGroupId;
LPWSTR lpszOwnerGroupId;
DWORD cbProperties;
PVOID pProperties;
DWORD cbRoProperties;
PVOID pRoProperties;
} CLUSTER_RESOURCE_ENUM_ITEM, *PCLUSTER_RESOURCE_ENUM_ITEM;
#endif // CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HGROUP HGROUP
WINAPI WINAPI
CreateClusterGroup( CreateClusterGroup(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszGroupName _In_ LPCWSTR lpszGroupName
); );
typedef HGROUP typedef HGROUP
(WINAPI * PCLUSAPI_CREATE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_CREATE_CLUSTER_GROUP)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszGroupName _In_ LPCWSTR lpszGroupName
); );
HGROUP HGROUP
WINAPI WINAPI
OpenClusterGroup( OpenClusterGroup(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszGroupName _In_ LPCWSTR lpszGroupName
); );
typedef HGROUP typedef HGROUP
(WINAPI * PCLUSAPI_OPEN_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_GROUP)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszGroupName _In_ LPCWSTR lpszGroupName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HGROUP HGROUP
WINAPI WINAPI
OpenClusterGroupEx( OpenClusterGroupEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszGroupName, _In_opt_ LPCWSTR lpszGroupName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt DWORD* lpdwGrantedAccess _Out_opt_ DWORD* lpdwGrantedAccess
); );
typedef HGROUP typedef HGROUP
(WINAPI * PCLUSAPI_OPEN_CLUSTER_GROUP_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_GROUP_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszGroupName, _In_opt_ LPCWSTR lpszGroupName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
// flags for PauseClusterNodeEx
#define CLUSAPI_NODE_PAUSE_REMAIN_ON_PAUSED_NODE_ON_MOVE_ERROR 0x00000001
DWORD
WINAPI
PauseClusterNodeEx(
_In_ HNODE hNode,
_In_ BOOL bDrainNode,
_In_ DWORD dwPauseFlags,
_In_opt_ HNODE hNodeDrainTarget
);
typedef DWORD
(WINAPI * PCLUSAPI_PAUSE_CLUSTER_NODE_EX)(
_In_ HNODE hNode,
_In_ BOOL bDrainNode,
_In_ DWORD dwPauseFlags,
_In_opt_ HNODE hNodeDrainTarget
);
typedef enum CLUSTER_NODE_RESUME_FAILBACK_TYPE
{
DoNotFailbackGroups = 0,
FailbackGroupsImmediately,
FailbackGroupsPerPolicy,
ClusterNodeResumeFailbackTypeCount
} CLUSTER_NODE_RESUME_FAILBACK_TYPE;
DWORD
WINAPI
ResumeClusterNodeEx(
_In_ HNODE hNode,
_In_ CLUSTER_NODE_RESUME_FAILBACK_TYPE eResumeFailbackType,
_In_ DWORD dwResumeFlagsReserved
);
typedef DWORD
(WINAPI * PCLUSAPI_RESUME_CLUSTER_NODE_EX)(
_In_ HNODE hNode,
_In_ CLUSTER_NODE_RESUME_FAILBACK_TYPE eResumeFailbackType,
_In_ DWORD dwResumeFlagsReserved
);
// Group StatusInformation Flags; These flags are set only by Cluster Service On
ly;
#define CLUSGRP_STATUS_LOCKED_MODE 0
x0000000000000001
#define CLUSGRP_STATUS_PREEMPTED 0
x0000000000000002
#define CLUSGRP_STATUS_WAITING_IN_QUEUE_FOR_MOVE 0
x0000000000000004
#define CLUSGRP_STATUS_PHYSICAL_RESOURCES_LACKING 0
x0000000000000008
#define CLUSGRP_STATUS_WAITING_TO_START 0
x0000000000000010
#define CLUSGRP_STATUS_EMBEDDED_FAILURE 0
x0000000000000020
#define CLUSGRP_STATUS_OFFLINE_DUE_TO_ANTIAFFINITY_CONFLICT 0
x0000000000000040
#define CLUSGRP_STATUS_NETWORK_FAILURE 0
x0000000000000080
HGROUP
WINAPI
CreateClusterGroupEx(
_In_ HCLUSTER hCluster,
_In_ LPCWSTR lpszGroupName,
_In_opt_ PCLUSTER_CREATE_GROUP_INFO pGroupInfo
);
typedef HGROUP
(WINAPI * PCLUSAPI_CREATE_CLUSTER_GROUPEX)(
_In_ HCLUSTER hCluster,
_In_ LPCWSTR lpszGroupName,
_In_opt_ PCLUSTER_CREATE_GROUP_INFO pGroupInfo
);
HGROUPENUMEX
WINAPI
ClusterGroupOpenEnumEx(
_In_ HCLUSTER hCluster,
_In_reads_bytes_opt_(cbProperties)LPCWSTR lpszProperties,
_In_ DWORD cbProperties,
_In_reads_bytes_opt_(cbRoProperties) LPCWSTR lpszRoProperties,
_In_ DWORD cbRoProperties,
_In_ DWORD dwFlags
);
typedef HGROUPENUMEX
(WINAPI * PCLUSAPI_CLUSTER_GROUP_OPEN_ENUM_EX)(
_In_ HCLUSTER hCluster,
_In_reads_bytes_opt_(cbProperties)LPCWSTR lpszProperties,
_In_ DWORD cbProperties,
_In_reads_bytes_opt_(cbRoProperties) LPCWSTR lpszRoProperties,
_In_ DWORD cbRoProperties,
_In_ DWORD dwFlags
);
DWORD
WINAPI
ClusterGroupGetEnumCountEx(
_In_ HGROUPENUMEX hGroupEnumEx
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_GET_ENUM_COUNT_EX)(
_In_ HGROUPENUMEX hGroupEnumEx
);
DWORD
WINAPI
ClusterGroupEnumEx(
_In_ HGROUPENUMEX hGroupEnumEx,
_In_ DWORD dwIndex,
_Inout_ PCLUSTER_GROUP_ENUM_ITEM pItem,
_Inout_ LPDWORD cbItem
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_ENUM_EX)(
_In_ HGROUPENUMEX hGroupEnumEx,
_In_ DWORD dwIndex,
_Inout_ PCLUSTER_GROUP_ENUM_ITEM pItem,
_Inout_ LPDWORD cbItem
);
DWORD
WINAPI
ClusterGroupCloseEnumEx(
_In_ HGROUPENUMEX hGroupEnumEx
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_CLOSE_ENUM_EX)(
_In_ HGROUPENUMEX hGroupEnumEx
);
// Resource StatusInformation Flags; These are set by Cluster Service Only;
#define CLUSRES_STATUS_LOCKED_MODE 0
x0000000000000001
#define CLUSRES_STATUS_EMBEDDED_FAILURE 0
x0000000000000002
#define CLUSRES_STATUS_FAILED_DUE_TO_INSUFFICIENT_CPU 0
x0000000000000004
#define CLUSRES_STATUS_FAILED_DUE_TO_INSUFFICIENT_MEMORY 0
x0000000000000008
#define CLUSRES_STATUS_FAILED_DUE_TO_INSUFFICIENT_GENERIC_RESOURCES 0
x0000000000000010
#define CLUSRES_STATUS_NETWORK_FAILURE 0
x0000000000000020
HRESENUMEX
WINAPI
ClusterResourceOpenEnumEx(
_In_ HCLUSTER hCluster,
_In_reads_bytes_opt_(cbProperties)LPCWSTR lpszProperties,
_In_ DWORD cbProperties,
_In_reads_bytes_opt_(cbRoProperties) LPCWSTR lpszRoProperties,
_In_ DWORD cbRoProperties,
_In_ DWORD dwFlags
);
typedef HRESENUMEX
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_OPEN_ENUM_EX)(
_In_ HCLUSTER hCluster,
_In_reads_bytes_opt_(cbProperties)LPCWSTR lpszProperties,
_In_ DWORD cbProperties,
_In_reads_bytes_opt_(cbRoProperties) LPCWSTR lpszRoProperties,
_In_ DWORD cbRoProperties,
_In_ DWORD dwFlags
);
DWORD
WINAPI
ClusterResourceGetEnumCountEx(
_In_ HRESENUMEX hResourceEnumEx
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_GET_ENUM_COUNT_EX)(
_In_ HRESENUMEX hResourceEnumEx
);
DWORD
WINAPI
ClusterResourceEnumEx(
_In_ HRESENUMEX hResourceEnumEx,
_In_ DWORD dwIndex,
_Inout_ PCLUSTER_RESOURCE_ENUM_ITEM pItem,
_Inout_ LPDWORD cbItem
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_ENUM_EX)(
_In_ HRESENUMEX hResourceEnumEx,
_In_ DWORD dwIndex,
_Inout_ PCLUSTER_RESOURCE_ENUM_ITEM pItem,
_Inout_ LPDWORD cbItem
);
DWORD
WINAPI
ClusterResourceCloseEnumEx(
_In_ HRESENUMEX hResourceEnumEx
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CLOSE_ENUM_EX)(
_In_ HRESENUMEX hResourceEnumEx
);
#define CLUSAPI_GROUP_ONLINE_IGNORE_RESOURCE_STATUS 0x00000001
DWORD WINAPI OnlineClusterGroupEx(
_In_ HGROUP hGroup,
_In_opt_ HNODE hDestinationNode,
_In_ DWORD dwOnlineFlags,
_In_reads_bytes_opt_(cbInBufferSize) PBYTE lpInBuffer,
_In_ DWORD cbInBufferSize
);
#define CLUSAPI_GROUP_OFFLINE_IGNORE_RESOURCE_STATUS 0x00000001
DWORD WINAPI OfflineClusterGroupEx(
_In_ HGROUP hGroup,
_In_ DWORD dwOfflineFlags,
_In_reads_bytes_opt_(cbInBufferSize) PBYTE lpInBuffer,
_In_ DWORD cbInBufferSize
);
#define CLUSAPI_RESOURCE_ONLINE_IGNORE_RESOURCE_STATUS 0x00000001
#define CLUSAPI_RESOURCE_ONLINE_DO_NOT_UPDATE_PERSISTENT_STATE 0x00000002
#define CLUSAPI_RESOURCE_ONLINE_NECESSARY_FOR_QUORUM 0x00000004
DWORD WINAPI OnlineClusterResourceEx(
_In_ HRESOURCE hResource,
_In_ DWORD dwOnlineFlags,
_In_reads_bytes_opt_(cbInBufferSize) PBYTE lpInBuffer,
_In_ DWORD cbInBufferSize
);
#define CLUSAPI_RESOURCE_OFFLINE_IGNORE_RESOURCE_STATUS 0x00000001
#define CLUSAPI_RESOURCE_OFFLINE_FORCE_WITH_TERMINATION 0x00000002
// these are passed through the RHS offline resource call for V2 and later resou
rces
#define CLUSAPI_RESOURCE_OFFLINE_REASON_NONE 0x00000000
#define CLUSAPI_RESOURCE_OFFLINE_REASON_UNKNOWN 0x00000001
#define CLUSAPI_RESOURCE_OFFLINE_REASON_MOVING 0x00000002
#define CLUSAPI_RESOURCE_OFFLINE_REASON_USER_REQUESTED 0x00000004
#define CLUSAPI_RESOURCE_OFFLINE_REASON_BEING_DELETED 0x00000008
#define CLUSAPI_RESOURCE_OFFLINE_REASON_BEING_RESTARTED 0x00000010
#define CLUSAPI_RESOURCE_OFFLINE_REASON_PREEMPTED 0x00000020
#define CLUSAPI_RESOURCE_OFFLINE_REASON_SHUTTING_DOWN 0x00000040
DWORD WINAPI OfflineClusterResourceEx(
_In_ HRESOURCE hResource,
_In_ DWORD dwOfflineFlags,
_In_reads_bytes_opt_(cbInBufferSize) PBYTE lpInBuffer,
_In_ DWORD cbInBufferSize
);
#define CLUSAPI_GROUP_MOVE_IGNORE_RESOURCE_STATUS 0x00000001
#define CLUSAPI_GROUP_MOVE_RETURN_TO_SOURCE_NODE_ON_ERROR 0x00000002
#define CLUSAPI_GROUP_MOVE_QUEUE_ENABLED 0x00000004
#define CLUSAPI_GROUP_MOVE_HIGH_PRIORITY_START 0x00000008
#define CLUSAPI_GROUP_MOVE_FAILBACK 0x00000010
DWORD
WINAPI
MoveClusterGroupEx(
_In_ HGROUP hGroup,
_In_opt_ HNODE hDestinationNode,
_In_ DWORD dwMoveFlags,
_In_reads_bytes_opt_(cbInBufferSize) PBYTE lpInBuffer,
_In_ DWORD cbInBufferSize
);
DWORD WINAPI CancelClusterGroupOperation(
_In_ HGROUP hGroup,
_In_ DWORD dwCancelFlags_RESERVED
);
DWORD WINAPI RestartClusterResource(
_In_ HRESOURCE hResource,
_In_ DWORD dwFlags
);
typedef DWORD
(WINAPI * PCLUSAPI_RESTART_CLUSTER_RESOURCE)(
HRESOURCE hResource,
DWORD dwFlags
);
#endif // (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
BOOL BOOL
WINAPI WINAPI
CloseClusterGroup( CloseClusterGroup(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_GROUP)(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromGroup( GetClusterFromGroup(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_GROUP)( (WINAPI * PCLUSAPI_GET_CLUSTER_FROM_GROUP)(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
__success(return >= 0) //!= ClusterGroupStateUnknown _Success_(return >= 0) //!= ClusterGroupStateUnknown
CLUSTER_GROUP_STATE CLUSTER_GROUP_STATE
WINAPI WINAPI
GetClusterGroupState( GetClusterGroupState(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam _Out_writes_to_opt_(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeName,
e, _Inout_opt_ LPDWORD lpcchNodeName
__inout_opt LPDWORD lpcchNodeName
); );
typedef CLUSTER_GROUP_STATE typedef CLUSTER_GROUP_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_STATE)( (WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_STATE)(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam _Out_writes_to_opt_(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeName,
e, _Inout_opt_ LPDWORD lpcchNodeName
__inout_opt LPDWORD lpcchNodeName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterGroupName( SetClusterGroupName(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in LPCWSTR lpszGroupName _In_ LPCWSTR lpszGroupName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NAME)( (WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NAME)(
HGROUP hGroup, HGROUP hGroup,
LPCWSTR lpszGroupName LPCWSTR lpszGroupName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterGroupNodeList( SetClusterGroupNodeList(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in DWORD NodeCount, _In_ DWORD NodeCount,
__in_ecount( NodeCount ) HNODE NodeList[] _In_reads_opt_( NodeCount ) HNODE NodeList[]
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NODE_LIST)( (WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NODE_LIST)(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in DWORD NodeCount, _In_ DWORD NodeCount,
__in_ecount( NodeCount ) HNODE NodeList[] _In_reads_opt_( NodeCount ) HNODE NodeList[]
); );
DWORD DWORD
WINAPI WINAPI
OnlineClusterGroup( OnlineClusterGroup(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hDestinationNode _In_opt_ HNODE hDestinationNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_ONLINE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_ONLINE_CLUSTER_GROUP)(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hDestinationNode _In_opt_ HNODE hDestinationNode
); );
DWORD DWORD
WINAPI WINAPI
MoveClusterGroup( MoveClusterGroup(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hDestinationNode _In_opt_ HNODE hDestinationNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_MOVE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_MOVE_CLUSTER_GROUP)(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hDestinationNode _In_opt_ HNODE hDestinationNode
); );
DWORD DWORD
WINAPI WINAPI
OfflineClusterGroup( OfflineClusterGroup(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_OFFLINE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_OFFLINE_CLUSTER_GROUP)(
HGROUP hGroup HGROUP hGroup
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterGroup( DeleteClusterGroup(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_DELETE_CLUSTER_GROUP)(
HGROUP hGroup HGROUP hGroup
); );
DWORD DWORD
WINAPI WINAPI
DestroyClusterGroup( DestroyClusterGroup(
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_DESTROY_CLUSTER_GROUP)( (WINAPI * PCLUSAPI_DESTROY_CLUSTER_GROUP)(
HGROUP hGroup HGROUP hGroup
); );
HGROUPENUM HGROUPENUM
WINAPI WINAPI
ClusterGroupOpenEnum( ClusterGroupOpenEnum(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HGROUPENUM typedef HGROUPENUM
(WINAPI * PCLUSAPI_CLUSTER_GROUP_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_GROUP_OPEN_ENUM)(
HGROUP hGroup, HGROUP hGroup,
DWORD dwType DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterGroupGetEnumCount( ClusterGroupGetEnumCount(
__in HGROUPENUM hGroupEnum _In_ HGROUPENUM hGroupEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_GROUP_GET_ENUM_COUNT)(
__in HGROUPENUM hGroupEnum _In_ HGROUPENUM hGroupEnum
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterGroupEnum( ClusterGroupEnum(
__in HGROUPENUM hGroupEnum, _In_ HGROUPENUM hGroupEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_GROUP_ENUM)(
__in HGROUPENUM hGroupEnum, _In_ HGROUPENUM hGroupEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterGroupCloseEnum( ClusterGroupCloseEnum(
__in HGROUPENUM hGroupEnum _In_ HGROUPENUM hGroupEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_GROUP_CLOSE_ENUM)(
HGROUPENUM hGroupEnum HGROUPENUM hGroupEnum
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
skipping to change at line 1427 skipping to change at line 2164
ClusterResourceOfflinePending ClusterResourceOfflinePending
} CLUSTER_RESOURCE_STATE; } CLUSTER_RESOURCE_STATE;
typedef enum CLUSTER_RESOURCE_RESTART_ACTION { typedef enum CLUSTER_RESOURCE_RESTART_ACTION {
ClusterResourceDontRestart = 0, ClusterResourceDontRestart = 0,
ClusterResourceRestartNoNotify, ClusterResourceRestartNoNotify,
ClusterResourceRestartNotify, ClusterResourceRestartNotify,
ClusterResourceRestartActionCount ClusterResourceRestartActionCount
} CLUSTER_RESOURCE_RESTART_ACTION, CRRA; } CLUSTER_RESOURCE_RESTART_ACTION, CRRA;
typedef enum CLUSTER_RESOURCE_EMBEDDED_FAILURE_ACTION {
ClusterResourceEmbeddedFailureActionNone = 0,
ClusterResourceEmbeddedFailureActionLogOnly = 1,
ClusterResourceEmbeddedFailureActionRecover
} CLUSTER_RESOURCE_EMBEDDED_FAILURE_ACTION;
// //
// Flags for resource creation // Flags for resource creation
// //
typedef enum CLUSTER_RESOURCE_CREATE_FLAGS { typedef enum CLUSTER_RESOURCE_CREATE_FLAGS {
CLUSTER_RESOURCE_DEFAULT_MONITOR = 0, CLUSTER_RESOURCE_DEFAULT_MONITOR = 0,
CLUSTER_RESOURCE_SEPARATE_MONITOR = 1, CLUSTER_RESOURCE_SEPARATE_MONITOR = 1,
CLUSTER_RESOURCE_VALID_FLAGS = CLUSTER_RESOURCE_SEPARATE_MONITOR CLUSTER_RESOURCE_VALID_FLAGS = CLUSTER_RESOURCE_SEPARATE_MONITOR
} CLUSTER_RESOURCE_CREATE_FLAGS; } CLUSTER_RESOURCE_CREATE_FLAGS;
typedef enum CLUSTER_SHARED_VOLUME_SNAPSHOT_STATE {
ClusterSharedVolumeSnapshotStateUnknown,
ClusterSharedVolumePrepareForHWSnapshot,
ClusterSharedVolumeHWSnapshotCompleted,
ClusterSharedVolumePrepareForFreeze
} CLUSTER_SHARED_VOLUME_SNAPSHOT_STATE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the resources in a cluster // Interfaces for managing the resources in a cluster
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HRESOURCE HRESOURCE
WINAPI WINAPI
CreateClusterResource( CreateClusterResource(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in LPCWSTR lpszResourceName, _In_ LPCWSTR lpszResourceName,
__in LPCWSTR lpszResourceType, _In_ LPCWSTR lpszResourceType,
__in DWORD dwFlags _In_ DWORD dwFlags
); );
typedef HRESOURCE typedef HRESOURCE
(WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE)(
HGROUP hGroup, HGROUP hGroup,
LPCWSTR lpszResourceName, LPCWSTR lpszResourceName,
LPCWSTR lpszResourceType, LPCWSTR lpszResourceType,
DWORD dwFlags DWORD dwFlags
); );
HRESOURCE HRESOURCE
WINAPI WINAPI
OpenClusterResource( OpenClusterResource(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceName _In_ LPCWSTR lpszResourceName
); );
typedef HRESOURCE typedef HRESOURCE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_RESOURCE)(
HCLUSTER hCluster, HCLUSTER hCluster,
LPCWSTR lpszResourceName LPCWSTR lpszResourceName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HRESOURCE HRESOURCE
WINAPI WINAPI
OpenClusterResourceEx( OpenClusterResourceEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszResourceName, _In_opt_ LPCWSTR lpszResourceName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt DWORD* lpdwGrantedAccess _Out_opt_ DWORD* lpdwGrantedAccess
); );
typedef HRESOURCE typedef HRESOURCE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_RESOURCE_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_RESOURCE_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszResourceName, _In_opt_ LPCWSTR lpszResourceName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
BOOL BOOL
WINAPI WINAPI
CloseClusterResource( CloseClusterResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_RESOURCE)(
HRESOURCE hResource HRESOURCE hResource
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromResource( GetClusterFromResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_RESOURCE)( (WINAPI * PCLUSAPI_GET_CLUSTER_FROM_RESOURCE)(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterResource( DeleteClusterResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE)(
HRESOURCE hResource HRESOURCE hResource
); );
__success(return >= 0) // != ClusterResourceStateUnknown _Success_(return >= 0) // != ClusterResourceStateUnknown
CLUSTER_RESOURCE_STATE CLUSTER_RESOURCE_STATE
WINAPI WINAPI
GetClusterResourceState( GetClusterResourceState(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam _Out_writes_to_opt_(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeName,
e, _Inout_opt_ LPDWORD lpcchNodeName,
__inout_opt LPDWORD lpcchNodeName, _Out_writes_to_opt_(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroupNa
__out_ecount_part_opt(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroup me,
Name, _Inout_opt_ LPDWORD lpcchGroupName
__inout_opt LPDWORD lpcchGroupName
); );
typedef CLUSTER_RESOURCE_STATE typedef CLUSTER_RESOURCE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_STATE)( (WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_STATE)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam _Out_writes_to_opt_(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeName,
e, _Inout_opt_ LPDWORD lpcchNodeName,
__inout_opt LPDWORD lpcchNodeName, _Out_writes_to_opt_(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroupNa
__out_ecount_part_opt(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroup me,
Name, _Inout_opt_ LPDWORD lpcchGroupName
__inout_opt LPDWORD lpcchGroupName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterResourceName( SetClusterResourceName(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in LPCWSTR lpszResourceName _In_ LPCWSTR lpszResourceName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_NAME)( (WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_NAME)(
HRESOURCE hResource, HRESOURCE hResource,
LPCWSTR lpszResourceName LPCWSTR lpszResourceName
); );
DWORD DWORD
WINAPI WINAPI
FailClusterResource( FailClusterResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_FAIL_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_FAIL_CLUSTER_RESOURCE)(
HRESOURCE hResource HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
OnlineClusterResource( OnlineClusterResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_ONLINE_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_ONLINE_CLUSTER_RESOURCE)(
HRESOURCE hResource HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
OfflineClusterResource( OfflineClusterResource(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_OFFLINE_CLUSTER_RESOURCE)( (WINAPI * PCLUSAPI_OFFLINE_CLUSTER_RESOURCE)(
HRESOURCE hResource HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
ChangeClusterResourceGroup( ChangeClusterResourceGroup(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HGROUP hGroup _In_ HGROUP hGroup
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CHANGE_CLUSTER_RESOURCE_GROUP)( (WINAPI * PCLUSAPI_CHANGE_CLUSTER_RESOURCE_GROUP)(
HRESOURCE hResource, HRESOURCE hResource,
HGROUP hGroup HGROUP hGroup
); );
DWORD DWORD
WINAPI WINAPI
AddClusterResourceNode( AddClusterResourceNode(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HNODE hNode _In_ HNODE hNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_NODE)( (WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_NODE)(
HRESOURCE hResource, HRESOURCE hResource,
HNODE hNode HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
RemoveClusterResourceNode( RemoveClusterResourceNode(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HNODE hNode _In_ HNODE hNode
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_NODE)( (WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_NODE)(
HRESOURCE hResource, HRESOURCE hResource,
HNODE hNode HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
AddClusterResourceDependency( AddClusterResourceDependency(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HRESOURCE hDependsOn _In_ HRESOURCE hDependsOn
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_DEPENDENCY)( (WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_DEPENDENCY)(
HRESOURCE hResource, HRESOURCE hResource,
HRESOURCE hDependsOn HRESOURCE hDependsOn
); );
DWORD DWORD
WINAPI WINAPI
RemoveClusterResourceDependency( RemoveClusterResourceDependency(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HRESOURCE hDependsOn _In_ HRESOURCE hDependsOn
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_DEPENDENCY)( (WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_DEPENDENCY)(
HRESOURCE hResource, HRESOURCE hResource,
HRESOURCE hDependsOn HRESOURCE hDependsOn
); );
DWORD DWORD
WINAPI WINAPI
SetClusterResourceDependencyExpression( SetClusterResourceDependencyExpression(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in LPCWSTR lpszDependencyExpression _In_ LPCWSTR lpszDependencyExpression
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)( (WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in LPCWSTR lpszDependencyExpression _In_ LPCWSTR lpszDependencyExpression
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterResourceDependencyExpression( GetClusterResourceDependencyExpression(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part_opt(*lpcchDependencyExpression, *lpcchDependencyExpression _Out_writes_to_opt_(*lpcchDependencyExpression, *lpcchDependencyExpression +
+ 1) 1)
LPWSTR lpszDependencyExpression, LPWSTR lpszDependencyExpression,
__inout LPDWORD lpcchDependencyExpression _Inout_ LPDWORD lpcchDependencyExpression
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)( (WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part_opt(*lpcchDependencyExpression, *lpcchDependencyExpression _Out_writes_to_opt_(*lpcchDependencyExpression, *lpcchDependencyExpression +
+ 1) 1)
LPWSTR lpszDependencyExpression, LPWSTR lpszDependencyExpression,
__inout LPDWORD lpcchDependencyExpression _Inout_ LPDWORD lpcchDependencyExpression
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
DWORD DWORD
WINAPI WINAPI
AddResourceToClusterSharedVolumes( AddResourceToClusterSharedVolumes(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
#endif #endif
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_ADD_RESOURCE_TO_CLUSTER_SHARED_VOLUMES)( (WINAPI * PCLUSAPI_ADD_RESOURCE_TO_CLUSTER_SHARED_VOLUMES)(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
DWORD DWORD
WINAPI WINAPI
RemoveResourceFromClusterSharedVolumes( RemoveResourceFromClusterSharedVolumes(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
#endif #endif
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_REMOVE_RESOURCE_FROM_CLUSTER_SHARED_VOLUMES)( (WINAPI * PCLUSAPI_REMOVE_RESOURCE_FROM_CLUSTER_SHARED_VOLUMES)(
__in HRESOURCE hResource _In_ HRESOURCE hResource
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
DWORD DWORD
WINAPI WINAPI
IsFileOnClusterSharedVolume( IsFileOnClusterSharedVolume(
__in LPCWSTR lpszPathName, _In_ LPCWSTR lpszPathName,
__out PBOOL pbFileIsOnSharedVolume _Out_ PBOOL pbFileIsOnSharedVolume
); );
#endif #endif
typedef DWORD typedef DWORD
(WINAPI *PCLUSAPI_IS_FILE_ON_CLUSTER_SHARED_VOLUME)( (WINAPI *PCLUSAPI_IS_FILE_ON_CLUSTER_SHARED_VOLUME)(
__in LPCWSTR lpszPathName, _In_ LPCWSTR lpszPathName,
__out PBOOL pbFileIsOnSharedVolume _Out_ PBOOL pbFileIsOnSharedVolume
);
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
DWORD
WINAPI
ClusterSharedVolumeSetSnapshotState(
_In_ GUID guidSnapshotSet,
_In_ LPCWSTR lpszVolumeName,
_In_ CLUSTER_SHARED_VOLUME_SNAPSHOT_STATE state
);
#endif
typedef DWORD
(WINAPI *PCLUSAPI_SHARED_VOLUME_SET_SNAPSHOT_STATE)(
_In_ GUID guidSnapshotSet,
_In_ LPCWSTR lpszVolumeName,
_In_ CLUSTER_SHARED_VOLUME_SNAPSHOT_STATE state
); );
BOOL BOOL
WINAPI WINAPI
CanResourceBeDependent( CanResourceBeDependent(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in HRESOURCE hResourceDependent _In_ HRESOURCE hResourceDependent
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CAN_RESOURCE_BE_DEPENDENT)( (WINAPI * PCLUSAPI_CAN_RESOURCE_BE_DEPENDENT)(
HRESOURCE hResource, HRESOURCE hResource,
HRESOURCE hResourceDependent HRESOURCE hResourceDependent
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceControl( ClusterResourceControl(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(cbInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(cbInBufferSize) LPVOID lpInBuffer,
__in DWORD cbInBufferSize, _In_ DWORD cbInBufferSize,
__out_bcount_part_opt(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuf
__in DWORD cbOutBufferSize, fer,
__out_opt LPDWORD lpBytesReturned _In_ DWORD cbOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CONTROL)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(cbInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(cbInBufferSize) LPVOID lpInBuffer,
__in DWORD cbInBufferSize, _In_ DWORD cbInBufferSize,
__out_bcount_part_opt(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuf
__in DWORD cbOutBufferSize, fer,
__out_opt LPDWORD lpBytesReturned _In_ DWORD cbOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeControl( ClusterResourceTypeControl(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CONTROL)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterGroupControl( ClusterGroupControl(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_GROUP_CONTROL)(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNodeControl( ClusterNodeControl(
__in HNODE hNode, _In_ HNODE hNode,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_NODE_CONTROL)(
__in HNODE hNode, _In_ HNODE hNode,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
__success(return != FALSE) _Success_(return != FALSE)
BOOL BOOL
WINAPI WINAPI
GetClusterResourceNetworkName( GetClusterResourceNetworkName(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part(*nSize, *nSize + 1) LPWSTR lpBuffer, _Out_writes_to_(*nSize, *nSize + 1) LPWSTR lpBuffer,
__inout LPDWORD nSize _Inout_ LPDWORD nSize
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_NETWORK_NAME)( (WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_NETWORK_NAME)(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__out_ecount_part(*nSize, *nSize + 1) LPWSTR lpBuffer, _Out_writes_to_(*nSize, *nSize + 1) LPWSTR lpBuffer,
__inout LPDWORD nSize _Inout_ LPDWORD nSize
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster control properties // Cluster control properties
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
skipping to change at line 1909 skipping to change at line 2677
CLUSPROP_FORMAT_SZ, CLUSPROP_FORMAT_SZ,
CLUSPROP_FORMAT_EXPAND_SZ, CLUSPROP_FORMAT_EXPAND_SZ,
CLUSPROP_FORMAT_MULTI_SZ, CLUSPROP_FORMAT_MULTI_SZ,
CLUSPROP_FORMAT_ULARGE_INTEGER, CLUSPROP_FORMAT_ULARGE_INTEGER,
CLUSPROP_FORMAT_LONG, CLUSPROP_FORMAT_LONG,
CLUSPROP_FORMAT_EXPANDED_SZ, CLUSPROP_FORMAT_EXPANDED_SZ,
CLUSPROP_FORMAT_SECURITY_DESCRIPTOR, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR,
CLUSPROP_FORMAT_LARGE_INTEGER, CLUSPROP_FORMAT_LARGE_INTEGER,
CLUSPROP_FORMAT_WORD, CLUSPROP_FORMAT_WORD,
CLUSPROP_FORMAT_FILETIME, CLUSPROP_FORMAT_FILETIME,
CLUSPROP_FORMAT_VALUE_LIST,
CLUSPROP_FORMAT_PROPERTY_LIST,
CLUSPROP_FORMAT_USER=32768 CLUSPROP_FORMAT_USER=32768
} CLUSTER_PROPERTY_FORMAT; } CLUSTER_PROPERTY_FORMAT;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Cluster Control Property Data - Syntax // Cluster Control Property Data - Syntax
// //
#define CLUSPROP_SYNTAX_VALUE( type, format ) ((DWORD) ((type << 16) | format)) #define CLUSPROP_SYNTAX_VALUE( type, format ) ((DWORD) ((type << 16) | format))
skipping to change at line 1941 skipping to change at line 2712
CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_MULTI_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_MULTI_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_LONG = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LONG ), CLUSPROP_SYNTAX_LIST_VALUE_LONG = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LONG ),
CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPANDED_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPANDED_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR ), CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR ),
CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LARGE_INTEGER ), CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LARGE_INTEGER ),
CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_ULARGE_INTEGER ), CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_ULARGE_INTEGER ),
CLUSPROP_SYNTAX_LIST_VALUE_WORD = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_WORD ), CLUSPROP_SYNTAX_LIST_VALUE_WORD = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_WORD ),
// Storage syntax values // Storage syntax values
CLUSPROP_SYNTAX_DISK_SIGNATURE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S CLUSPROP_SYNTAX_DISK_SIGNATURE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
IGNATURE, CLUSPROP_FORMAT_DWORD ), SIGNATURE, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_SCSI_ADDRESS = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S CLUSPROP_SYNTAX_SCSI_ADDRESS = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
CSI_ADDRESS, CLUSPROP_FORMAT_DWORD ), SCSI_ADDRESS, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_DISK_NUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D CLUSPROP_SYNTAX_DISK_NUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ISK_NUMBER, CLUSPROP_FORMAT_DWORD ), DISK_NUMBER, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_PARTITION_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_P CLUSPROP_SYNTAX_PARTITION_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ARTITION_INFO, CLUSPROP_FORMAT_BINARY ), PARTITION_INFO, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_FTSET_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_F CLUSPROP_SYNTAX_FTSET_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
TSET_INFO, CLUSPROP_FORMAT_BINARY ), FTSET_INFO, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_DISK_SERIALNUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D CLUSPROP_SYNTAX_DISK_SERIALNUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ISK_SERIALNUMBER, CLUSPROP_FORMAT_SZ ), DISK_SERIALNUMBER, CLUSPROP_FORMAT_SZ ),
CLUSPROP_SYNTAX_DISK_GUID = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D CLUSPROP_SYNTAX_DISK_GUID = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ISK_GUID, CLUSPROP_FORMAT_SZ ), DISK_GUID, CLUSPROP_FORMAT_SZ ),
CLUSPROP_SYNTAX_DISK_SIZE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D CLUSPROP_SYNTAX_DISK_SIZE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ISK_SIZE, CLUSPROP_FORMAT_ULARGE_INTEGER ), DISK_SIZE, CLUSPROP_FORMAT_ULARGE_INTEGER ),
CLUSPROP_SYNTAX_PARTITION_INFO_EX = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_P CLUSPROP_SYNTAX_PARTITION_INFO_EX = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
ARTITION_INFO_EX, CLUSPROP_FORMAT_BINARY ), PARTITION_INFO_EX, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_L CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_
IST_VALUE, CLUSPROP_FORMAT_FILETIME ), LIST_VALUE, CLUSPROP_FORMAT_FILETIME ),
} CLUSTER_PROPERTY_SYNTAX; } CLUSTER_PROPERTY_SYNTAX;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
#define GROUP_FAILURE_INFO_VERSION_1 0x1
typedef struct GROUP_FAILURE_INFO {
DWORD dwFailoverAttemptsRemaining;
DWORD dwFailoverPeriodRemaining; // in sec
} GROUP_FAILURE_INFO, *PGROUP_FAILURE_INFO;
typedef struct GROUP_FAILURE_INFO_BUFFER {
DWORD dwVersion;
GROUP_FAILURE_INFO Info;
} GROUP_FAILURE_INFO_BUFFER, *PGROUP_FAILURE_INFO_BUFFER;
#define RESOURCE_FAILURE_INFO_VERSION_1 0x1
typedef struct RESOURCE_FAILURE_INFO {
DWORD dwRestartAttemptsRemaining;
DWORD dwRestartPeriodRemaining; // in sec
} RESOURCE_FAILURE_INFO, *PRESOURCE_FAILURE_INFO;
typedef struct RESOURCE_FAILURE_INFO_BUFFER {
DWORD dwVersion;
RESOURCE_FAILURE_INFO Info;
} RESOURCE_FAILURE_INFO_BUFFER, *PRESOURCE_FAILURE_INFO_BUFFER;
typedef struct RESOURCE_TERMINAL_FAILURE_INFO_BUFFER {
BOOL isTerminalFailure;
DWORD restartPeriodRemaining;
} RESOURCE_TERMINAL_FAILURE_INFO_BUFFER, *PRESOURCE_TERMINAL_FAILURE_INFO_BUFFER
;
#endif //(CLUSAPI_VERSION >= CLUSAPI_VERSION_WINDOWS8)
// //
// Define Cluster Control Code access methods // Define Cluster Control Code access methods
// //
#define CLUS_ACCESS_ANY 0 #define CLUS_ACCESS_ANY 0
#define CLUS_ACCESS_READ 0x01 #define CLUS_ACCESS_READ 0x01
#define CLUS_ACCESS_WRITE 0x02 #define CLUS_ACCESS_WRITE 0x02
// //
// Define Cluster Control Code modification actions // Define Cluster Control Code modification actions
// //
skipping to change at line 2060 skipping to change at line 2864
typedef enum CLCTL_CODES { typedef enum CLCTL_CODES {
// //
// External control codes // External control codes
// //
CLCTL_UNKNOWN = CLCTL_EXTERNAL_CODE( 0, CLUS_ACCES S_ANY, CLUS_NO_MODIFY ), CLCTL_UNKNOWN = CLCTL_EXTERNAL_CODE( 0, CLUS_ACCES S_ANY, CLUS_NO_MODIFY ),
CLCTL_GET_CHARACTERISTICS = CLCTL_EXTERNAL_CODE( 1, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_CHARACTERISTICS = CLCTL_EXTERNAL_CODE( 1, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_FLAGS = CLCTL_EXTERNAL_CODE( 2, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_FLAGS = CLCTL_EXTERNAL_CODE( 2, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_CLASS_INFO = CLCTL_EXTERNAL_CODE( 3, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_CLASS_INFO = CLCTL_EXTERNAL_CODE( 3, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_REQUIRED_DEPENDENCIES = CLCTL_EXTERNAL_CODE( 4, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_REQUIRED_DEPENDENCIES = CLCTL_EXTERNAL_CODE( 4, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_ARB_TIMEOUT = CLCTL_EXTERNAL_CODE( 5, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_ARB_TIMEOUT = CLCTL_EXTERNAL_CODE( 5, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_FAILURE_INFO = CLCTL_EXTERNAL_CODE( 6, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NAME = CLCTL_EXTERNAL_CODE( 10, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NAME = CLCTL_EXTERNAL_CODE( 10, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_RESOURCE_TYPE = CLCTL_EXTERNAL_CODE( 11, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_RESOURCE_TYPE = CLCTL_EXTERNAL_CODE( 11, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NODE = CLCTL_EXTERNAL_CODE( 12, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NODE = CLCTL_EXTERNAL_CODE( 12, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NETWORK = CLCTL_EXTERNAL_CODE( 13, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NETWORK = CLCTL_EXTERNAL_CODE( 13, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_ID = CLCTL_EXTERNAL_CODE( 14, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_ID = CLCTL_EXTERNAL_CODE( 14, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_FQDN = CLCTL_EXTERNAL_CODE( 15, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_FQDN = CLCTL_EXTERNAL_CODE( 15, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME = CLCTL_EXTERNAL_CODE( 16, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME = CLCTL_EXTERNAL_CODE( 16, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_CHECK_VOTER_EVICT = CLCTL_EXTERNAL_CODE( 17, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_CHECK_VOTER_EVICT = CLCTL_EXTERNAL_CODE( 17, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_CHECK_VOTER_DOWN = CLCTL_EXTERNAL_CODE( 18, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_CHECK_VOTER_DOWN = CLCTL_EXTERNAL_CODE( 18, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
skipping to change at line 2111 skipping to change at line 2916
CLCTL_GET_LOADBAL_PROCESS_LIST = CLCTL_EXTERNAL_CODE( 50, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_LOADBAL_PROCESS_LIST = CLCTL_EXTERNAL_CODE( 50, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NETWORK_NAME = CLCTL_EXTERNAL_CODE( 90, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NETWORK_NAME = CLCTL_EXTERNAL_CODE( 90, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLCTL_EXTERNAL_CODE( 91, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLCTL_EXTERNAL_CODE( 91, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_REGISTER_DNS_RECORDS = CLCTL_EXTERNAL_CODE( 92, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ), CLCTL_NETNAME_REGISTER_DNS_RECORDS = CLCTL_EXTERNAL_CODE( 92, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_GET_DNS_NAME = CLCTL_EXTERNAL_CODE( 93, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_DNS_NAME = CLCTL_EXTERNAL_CODE( 93, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_SET_PWD_INFO = CLCTL_EXTERNAL_CODE( 94, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ), CLCTL_NETNAME_SET_PWD_INFO = CLCTL_EXTERNAL_CODE( 94, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_NETNAME_DELETE_CO = CLCTL_EXTERNAL_CODE( 95, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ), CLCTL_NETNAME_DELETE_CO = CLCTL_EXTERNAL_CODE( 95, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_NETNAME_VALIDATE_VCO = CLCTL_EXTERNAL_CODE( 96, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_NETNAME_VALIDATE_VCO = CLCTL_EXTERNAL_CODE( 96, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_RESET_VCO = CLCTL_EXTERNAL_CODE( 97, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_NETNAME_RESET_VCO = CLCTL_EXTERNAL_CODE( 97, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_CREDS_UPDATED = CLCTL_EXTERNAL_CODE( 98, CLUS_ACCE SS_WRITE, CLUS_MODIFY )|CLCTL_GLOBAL_MASK, CLCTL_NETNAME_REPAIR_VCO = CLCTL_EXTERNAL_CODE( 99, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_DISK_INFO = CLCTL_EXTERNAL_CODE( 100, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DISK_INFO = CLCTL_EXTERNAL_CODE( 100, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_AVAILABLE_DISKS = CLCTL_EXTERNAL_CODE( 101, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_AVAILABLE_DISKS = CLCTL_EXTERNAL_CODE( 101, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_IS_PATH_VALID = CLCTL_EXTERNAL_CODE( 102, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_IS_PATH_VALID = CLCTL_EXTERNAL_CODE( 102, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_SYNC_CLUSDISK_DB = CLCTL_EXTERNAL_CODE( 103, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_STORAGE_SYNC_CLUSDISK_DB = CLCTL_EXTERNAL_CODE( 103, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_QUERY_DELETE = CLCTL_EXTERNAL_CODE( 110, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_QUERY_DELETE = CLCTL_EXTERNAL_CODE( 110, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_IPADDRESS_RENEW_LEASE = CLCTL_EXTERNAL_CODE( 111, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_IPADDRESS_RENEW_LEASE = CLCTL_EXTERNAL_CODE( 111, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_IPADDRESS_RELEASE_LEASE = CLCTL_EXTERNAL_CODE( 112, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_IPADDRESS_RELEASE_LEASE = CLCTL_EXTERNAL_CODE( 112, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
skipping to change at line 2134 skipping to change at line 2939
CLCTL_SET_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 121, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_SET_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 121, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_SET_DRIVELETTER = CLCTL_EXTERNAL_CODE( 122, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_STORAGE_SET_DRIVELETTER = CLCTL_EXTERNAL_CODE( 122, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_DRIVELETTERS = CLCTL_EXTERNAL_CODE( 123, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DRIVELETTERS = CLCTL_EXTERNAL_CODE( 123, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_DISK_INFO_EX = CLCTL_EXTERNAL_CODE( 124, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DISK_INFO_EX = CLCTL_EXTERNAL_CODE( 124, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX = CLCTL_EXTERNAL_CODE( 125, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX = CLCTL_EXTERNAL_CODE( 125, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_REMAP_DRIVELETTER = CLCTL_EXTERNAL_CODE( 128, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_REMAP_DRIVELETTER = CLCTL_EXTERNAL_CODE( 128, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_DISKID = CLCTL_EXTERNAL_CODE( 129, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DISKID = CLCTL_EXTERNAL_CODE( 129, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_IS_CLUSTERABLE = CLCTL_EXTERNAL_CODE( 130, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_IS_CLUSTERABLE = CLCTL_EXTERNAL_CODE( 130, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_REMOVE_VM_OWNERSHIP = CLCTL_EXTERNAL_CODE( 131, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_STORAGE_REMOVE_VM_OWNERSHIP = CLCTL_EXTERNAL_CODE( 131, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_MOUNTPOINTS = CLCTL_EXTERNAL_CODE( 132, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_MOUNTPOINTS = CLCTL_EXTERNAL_CODE( 132, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
// This control was erroneously numbered as 132 in Win2k8, but does not coll
ide with the above because
// of the access mask. Changing it to 133 causes incompatibility with apps c
ompiled against Win2k8.
CLCTL_STORAGE_CLUSTER_DISK = CLCTL_EXTERNAL_CODE( 132, CLUS_ACC
ESS_WRITE, CLUS_MODIFY )|CLCTL_GLOBAL_MASK,
CLCTL_STORAGE_GET_DIRTY = CLCTL_EXTERNAL_CODE( 134, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DIRTY = CLCTL_EXTERNAL_CODE( 134, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
// Codes 135-136 are available for storage after the two previous squatters were made internal. // Codes 135-136 are available for storage after the two previous squatters were made internal.
CLCTL_STORAGE_GET_SHARED_VOLUME_INFO = CLCTL_EXTERNAL_CODE( 137, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_SHARED_VOLUME_INFO = CLCTL_EXTERNAL_CODE( 137, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_IS_CSV_FILE = CLCTL_EXTERNAL_CODE( 138, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_IS_CSV_FILE = CLCTL_EXTERNAL_CODE( 138, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_RESOURCEID = CLCTL_EXTERNAL_CODE( 139, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_VALIDATE_PATH = CLCTL_EXTERNAL_CODE( 140, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_VALIDATE_PATH = CLCTL_EXTERNAL_CODE( 140, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_VALIDATE_NETNAME = CLCTL_EXTERNAL_CODE( 141, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_VALIDATE_NETNAME = CLCTL_EXTERNAL_CODE( 141, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_VALIDATE_DIRECTORY = CLCTL_EXTERNAL_CODE( 142, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_VALIDATE_DIRECTORY = CLCTL_EXTERNAL_CODE( 142, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_BATCH_BLOCK_KEY = CLCTL_EXTERNAL_CODE( 143, CLUS_ACC ESS_WRITE, CLUS_NO_MODIFY ), CLCTL_BATCH_BLOCK_KEY = CLCTL_EXTERNAL_CODE( 143, CLUS_ACC ESS_WRITE, CLUS_NO_MODIFY ),
CLCTL_BATCH_UNBLOCK_KEY = CLCTL_EXTERNAL_CODE( 144, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_BATCH_UNBLOCK_KEY = CLCTL_EXTERNAL_CODE( 144, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_FILESERVER_SHARE_ADD = CLCTL_EXTERNAL_CODE( 145, CLUS_ACC
ESS_READ, CLUS_MODIFY ), CLCTL_FILESERVER_SHARE_ADD = CLCTL_EXTERNAL_CODE( 145, CLUS_ACC
CLCTL_FILESERVER_SHARE_DEL = CLCTL_EXTERNAL_CODE( 146, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
ESS_READ, CLUS_MODIFY ), CLCTL_FILESERVER_SHARE_DEL = CLCTL_EXTERNAL_CODE( 146, CLUS_ACC
CLCTL_FILESERVER_SHARE_MODIFY = CLCTL_EXTERNAL_CODE( 147, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
ESS_READ, CLUS_MODIFY ), CLCTL_FILESERVER_SHARE_MODIFY = CLCTL_EXTERNAL_CODE( 147, CLUS_ACC
CLCTL_FILESERVER_SHARE_REPORT = CLCTL_EXTERNAL_CODE( 148, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
ESS_READ, CLUS_NO_MODIFY ), CLCTL_FILESERVER_SHARE_REPORT = CLCTL_EXTERNAL_CODE( 148, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_GET_OU_FOR_VCO = CLCTL_EXTERNAL_CODE( 155, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
// Codes 160-161 are available for storage after the two previous squatters were made internal. // Codes 160-161 are available for storage after the two previous squatters were made internal.
CLCTL_ENABLE_SHARED_VOLUME_DIRECTIO = CLCTL_EXTERNAL_CODE( 162, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_ENABLE_SHARED_VOLUME_DIRECTIO = CLCTL_EXTERNAL_CODE( 162, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_DISABLE_SHARED_VOLUME_DIRECTIO = CLCTL_EXTERNAL_CODE( 163, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_DISABLE_SHARED_VOLUME_DIRECTIO = CLCTL_EXTERNAL_CODE( 163, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_GET_SHARED_VOLUME_ID = CLCTL_EXTERNAL_CODE( 164, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_GET_SHARED_VOLUME_ID = CLCTL_EXTERNAL_CODE( 164, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_SET_CSV_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 165, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_SET_CSV_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 165, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_SET_SHARED_VOLUME_BACKUP_MODE = CLCTL_EXTERNAL_CODE( 166, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_SET_SHARED_VOLUME_BACKUP_MODE = CLCTL_EXTERNAL_CODE( 166, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_SHARED_VOLUME_PARTITION_NAMES = CLCTL_EXTERNAL_CODE( 167,
CLUS_ACCESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_SHARED_VOLUME_STATES = CLCTL_EXTERNAL_CODE( 168, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_IS_SHARED_VOLUME = CLCTL_EXTERNAL_CODE( 169, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_CLUSDB_TIMESTAMP = CLCTL_EXTERNAL_CODE( 170, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
// this control has CLUS_MODIFY bit set and will trigger property change not
ification, that is the only purpose of this control
CLCTL_RW_MODIFY_NOOP = CLCTL_EXTERNAL_CODE( 171, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
CLCTL_IS_QUORUM_BLOCKED = CLCTL_EXTERNAL_CODE( 172, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_POOL_GET_DRIVE_INFO = CLCTL_EXTERNAL_CODE( 173, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_GUM_LOCK_OWNER = CLCTL_EXTERNAL_CODE( 174, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_STUCK_NODES = CLCTL_EXTERNAL_CODE( 175, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY),
CLCTL_INJECT_GEM_FAULT = CLCTL_EXTERNAL_CODE( 176, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY),
CLCTL_INTRODUCE_GEM_REPAIR_DELAY = CLCTL_EXTERNAL_CODE( 177, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY),
CLCTL_SEND_DUMMY_GEM_MESSAGES = CLCTL_EXTERNAL_CODE( 178, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY),
CLCTL_BLOCK_GEM_SEND_RECV = CLCTL_EXTERNAL_CODE( 179, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY),
CLCTL_GET_GEMID_VECTOR = CLCTL_EXTERNAL_CODE( 180, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY),
CLCTL_ADD_CRYPTO_CHECKPOINT_EX = CLCTL_EXTERNAL_CODE( 181, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
// Control codes 2000 to 2999 are reserved. // Control codes 2000 to 2999 are reserved.
CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX2_INT = CLCTL_EXTERNAL_CODE( 2040, CLU
S_ACCESS_READ, CLUS_NO_MODIFY ),
// //
// Internal control codes // Internal control codes
// //
CLCTL_DELETE = CLCTL_INTERNAL_CODE( 1, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_DELETE = CLCTL_INTERNAL_CODE( 1, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_INSTALL_NODE = CLCTL_INTERNAL_CODE( 2, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_INSTALL_NODE = CLCTL_INTERNAL_CODE( 2, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_EVICT_NODE = CLCTL_INTERNAL_CODE( 3, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_EVICT_NODE = CLCTL_INTERNAL_CODE( 3, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_ADD_DEPENDENCY = CLCTL_INTERNAL_CODE( 4, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_ADD_DEPENDENCY = CLCTL_INTERNAL_CODE( 4, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_REMOVE_DEPENDENCY = CLCTL_INTERNAL_CODE( 5, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_REMOVE_DEPENDENCY = CLCTL_INTERNAL_CODE( 5, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_ADD_OWNER = CLCTL_INTERNAL_CODE( 6, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_ADD_OWNER = CLCTL_INTERNAL_CODE( 6, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_REMOVE_OWNER = CLCTL_INTERNAL_CODE( 7, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_REMOVE_OWNER = CLCTL_INTERNAL_CODE( 7, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
skipping to change at line 2192 skipping to change at line 3022
CLCTL_PROVIDER_STATE_CHANGE = CLCTL_INTERNAL_CODE( 20, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_PROVIDER_STATE_CHANGE = CLCTL_INTERNAL_CODE( 20, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_LEAVING_GROUP = CLCTL_INTERNAL_CODE( 21, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_LEAVING_GROUP = CLCTL_INTERNAL_CODE( 21, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_JOINING_GROUP = CLCTL_INTERNAL_CODE( 22, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_JOINING_GROUP = CLCTL_INTERNAL_CODE( 22, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_FSWITNESS_GET_EPOCH_INFO = CLCTL_INTERNAL_CODE( 23, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_FSWITNESS_GET_EPOCH_INFO = CLCTL_INTERNAL_CODE( 23, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_FSWITNESS_SET_EPOCH_INFO = CLCTL_INTERNAL_CODE( 24, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_FSWITNESS_SET_EPOCH_INFO = CLCTL_INTERNAL_CODE( 24, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_FSWITNESS_RELEASE_LOCK = CLCTL_INTERNAL_CODE( 25, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_FSWITNESS_RELEASE_LOCK = CLCTL_INTERNAL_CODE( 25, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_NETNAME_CREDS_NOTIFYCAM = CLCTL_INTERNAL_CODE( 26, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_NETNAME_CREDS_NOTIFYCAM = CLCTL_INTERNAL_CODE( 26, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_DISK_NUMBER = CLCTL_INTERNAL_CODE( 27, CLUS_ACCE CLCTL_NOTIFY_QUORUM_STATUS = CLCTL_INTERNAL_CODE( 31, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ), SS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_CSV_DISK_INFO = CLCTL_INTERNAL_CODE( 28, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_OPERATION_CONTEXT = CLCTL_INTERNAL_CODE( 2106, CLUS_AC
CLCTL_SET_CLUSTER_MEMBERSHIP = CLCTL_INTERNAL_CODE( 29, CLUS_ACCE CESS_READ, CLUS_NO_MODIFY ),
SS_WRITE, CLUS_MODIFY ), CLCTL_NOTIFY_OWNER_CHANGE = CLCTL_INTERNAL_CODE( 2120, CLUS_AC
CLCTL_SET_SHARED_PR_KEY = CLCTL_INTERNAL_CODE( 30, CLUS_ACCE CESS_WRITE, CLUS_MODIFY ),
SS_WRITE, CLUS_MODIFY ),
CLCTL_QUERY_CSV_MAINTENANCE_MODE = CLCTL_INTERNAL_CODE( 31, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
} CLCTL_CODES; } CLCTL_CODES;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Define macros to generate object specific control codes // Define macros to generate object specific control codes
// //
#define CLUSCTL_RESOURCE_CODE( Function ) ( \ #define CLUSCTL_RESOURCE_CODE( Function ) ( \
((CLUS_OBJECT_RESOURCE << CLUSCTL_OBJECT_SHIFT) | Function) ) ((CLUS_OBJECT_RESOURCE << CLUSCTL_OBJECT_SHIFT) | Function) )
skipping to change at line 2226 skipping to change at line 3056
#define CLUSCTL_NETWORK_CODE( Function ) ( \ #define CLUSCTL_NETWORK_CODE( Function ) ( \
((CLUS_OBJECT_NETWORK << CLUSCTL_OBJECT_SHIFT) | Function) ) ((CLUS_OBJECT_NETWORK << CLUSCTL_OBJECT_SHIFT) | Function) )
#define CLUSCTL_NETINTERFACE_CODE( Function ) ( \ #define CLUSCTL_NETINTERFACE_CODE( Function ) ( \
((CLUS_OBJECT_NETINTERFACE << CLUSCTL_OBJECT_SHIFT) | Function) ) ((CLUS_OBJECT_NETINTERFACE << CLUSCTL_OBJECT_SHIFT) | Function) )
#define CLUSCTL_CLUSTER_CODE( Function ) ( \ #define CLUSCTL_CLUSTER_CODE( Function ) ( \
((CLUS_OBJECT_CLUSTER << CLUSCTL_OBJECT_SHIFT) | Function) ) ((CLUS_OBJECT_CLUSTER << CLUSCTL_OBJECT_SHIFT) | Function) )
#define CLUSCTL_USER_CODE( Function, Object ) ( \ #define CLUSCTL_USER_CODE( Function, Object ) ( \
((Object) << CLUSCTL_OBJECT_SHIFT) | ((CLCTL_USER_BASE + Function) << CLUSC TL_FUNCTION_SHIFT) ) ( (Object) << CLUSCTL_OBJECT_SHIFT) | CLCTL_USER_BASE | (Function << CL USCTL_FUNCTION_SHIFT) )
// //
// Define macros to get the function, object, access mode, or User Base flag out // Define macros to get the function, object, access mode, or User Base flag out
// of a control code // of a control code
// //
#define CLUSCTL_GET_CONTROL_FUNCTION( ControlCode ) \ #define CLUSCTL_GET_CONTROL_FUNCTION( ControlCode ) \
((ControlCode >> CLUSCTL_ACCESS_SHIFT) & CLUSCTL_CONTROL_CODE_MASK) ((ControlCode >> CLUSCTL_ACCESS_SHIFT) & CLUSCTL_CONTROL_CODE_MASK)
#define CLUSCTL_GET_ACCESS_MODE( ControlCode ) \ #define CLUSCTL_GET_ACCESS_MODE( ControlCode ) \
((ControlCode >> CLUSCTL_ACCESS_SHIFT) & CLUSCTL_ACCESS_MODE_MASK) ((ControlCode >> CLUSCTL_ACCESS_SHIFT) & CLUSCTL_ACCESS_MODE_MASK)
skipping to change at line 2250 skipping to change at line 3080
#define CLUSCTL_GET_USER( ControlCode ) \ #define CLUSCTL_GET_USER( ControlCode ) \
((ControlCode & CLCTL_USER_MASK) >> CLCTL_USER_SHIFT) ((ControlCode & CLCTL_USER_MASK) >> CLCTL_USER_SHIFT)
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Cluster Control Codes for Resources // Cluster Control Codes for Resources
// //
typedef enum CLUSCTL_RESOURCE_CODES { typedef enum CLUSCTL_RESOURCE_CODES {
// External //
// External resource codes
//
CLUSCTL_RESOURCE_UNKNOWN = CLUSCTL_RESOURCE_UNKNOWN =
CLUSCTL_RESOURCE_CODE( CLCTL_UNKNOWN ), CLUSCTL_RESOURCE_CODE( CLCTL_UNKNOWN ),
CLUSCTL_RESOURCE_GET_CHARACTERISTICS = CLUSCTL_RESOURCE_GET_CHARACTERISTICS =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_CHARACTERISTICS ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_CHARACTERISTICS ),
CLUSCTL_RESOURCE_GET_FLAGS = CLUSCTL_RESOURCE_GET_FLAGS =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_FLAGS ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_FLAGS ),
CLUSCTL_RESOURCE_GET_CLASS_INFO = CLUSCTL_RESOURCE_GET_CLASS_INFO =
skipping to change at line 2326 skipping to change at line 3158
CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS = CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_REGISTRY_CHECKPOINTS ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_REGISTRY_CHECKPOINTS ),
CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT = CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT =
CLUSCTL_RESOURCE_CODE( CLCTL_ADD_CRYPTO_CHECKPOINT ), CLUSCTL_RESOURCE_CODE( CLCTL_ADD_CRYPTO_CHECKPOINT ),
CLUSCTL_RESOURCE_DELETE_CRYPTO_CHECKPOINT = CLUSCTL_RESOURCE_DELETE_CRYPTO_CHECKPOINT =
CLUSCTL_RESOURCE_CODE( CLCTL_DELETE_CRYPTO_CHECKPOINT ), CLUSCTL_RESOURCE_CODE( CLCTL_DELETE_CRYPTO_CHECKPOINT ),
CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT_EX =
CLUSCTL_RESOURCE_CODE( CLCTL_ADD_CRYPTO_CHECKPOINT_EX ),
CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS = CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_CRYPTO_CHECKPOINTS ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_CRYPTO_CHECKPOINTS ),
CLUSCTL_RESOURCE_GET_LOADBAL_PROCESS_LIST = CLUSCTL_RESOURCE_GET_LOADBAL_PROCESS_LIST =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_LOADBAL_PROCESS_LIST ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_LOADBAL_PROCESS_LIST ),
CLUSCTL_RESOURCE_GET_NETWORK_NAME = CLUSCTL_RESOURCE_GET_NETWORK_NAME =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_NETWORK_NAME ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_NETWORK_NAME ),
CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN =
skipping to change at line 2350 skipping to change at line 3185
CLUSCTL_RESOURCE_NETNAME_DELETE_CO = CLUSCTL_RESOURCE_NETNAME_DELETE_CO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_DELETE_CO ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_DELETE_CO ),
CLUSCTL_RESOURCE_NETNAME_VALIDATE_VCO = CLUSCTL_RESOURCE_NETNAME_VALIDATE_VCO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_VALIDATE_VCO ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_VALIDATE_VCO ),
CLUSCTL_RESOURCE_NETNAME_RESET_VCO = CLUSCTL_RESOURCE_NETNAME_RESET_VCO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_RESET_VCO ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_RESET_VCO ),
CLUSCTL_RESOURCE_NETNAME_REPAIR_VCO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_REPAIR_VCO ),
CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS = CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_REGISTER_DNS_RECORDS ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_REGISTER_DNS_RECORDS ),
CLUSCTL_RESOURCE_GET_DNS_NAME = CLUSCTL_RESOURCE_GET_DNS_NAME =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_DNS_NAME ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_DNS_NAME ),
CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO = CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO ),
CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID = CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID =
skipping to change at line 2392 skipping to change at line 3230
CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE = CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE =
CLUSCTL_RESOURCE_CODE( CLCTL_SET_MAINTENANCE_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_SET_MAINTENANCE_MODE ),
CLUSCTL_RESOURCE_STORAGE_SET_DRIVELETTER = CLUSCTL_RESOURCE_STORAGE_SET_DRIVELETTER =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_SET_DRIVELETTER ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_SET_DRIVELETTER ),
CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO_EX = CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO_EX =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO_EX ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO_EX ),
CLUSCTL_RESOURCE_FILESERVER_SHARE_ADD =
CLUSCTL_RESOURCE_CODE( CLCTL_FILESERVER_SHARE_ADD ),
CLUSCTL_RESOURCE_FILESERVER_SHARE_DEL =
CLUSCTL_RESOURCE_CODE( CLCTL_FILESERVER_SHARE_DEL ),
CLUSCTL_RESOURCE_FILESERVER_SHARE_MODIFY =
CLUSCTL_RESOURCE_CODE( CLCTL_FILESERVER_SHARE_MODIFY ),
CLUSCTL_RESOURCE_FILESERVER_SHARE_REPORT =
CLUSCTL_RESOURCE_CODE( CLCTL_FILESERVER_SHARE_REPORT ),
CLUSCTL_RESOURCE_STORAGE_GET_MOUNTPOINTS = CLUSCTL_RESOURCE_STORAGE_GET_MOUNTPOINTS =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_MOUNTPOINTS ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_MOUNTPOINTS ),
CLUSCTL_RESOURCE_STORAGE_CLUSTER_DISK =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_CLUSTER_DISK ),
CLUSCTL_RESOURCE_STORAGE_GET_DIRTY = CLUSCTL_RESOURCE_STORAGE_GET_DIRTY =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DIRTY ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DIRTY ),
CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_INFO = CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_SHARED_VOLUME_INFO ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_SHARED_VOLUME_INFO ),
CLUSCTL_RESOURCE_SET_CSV_MAINTENANCE_MODE = CLUSCTL_RESOURCE_SET_CSV_MAINTENANCE_MODE =
CLUSCTL_RESOURCE_CODE( CLCTL_SET_CSV_MAINTENANCE_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_SET_CSV_MAINTENANCE_MODE ),
CLUSCTL_RESOURCE_ENABLE_SHARED_VOLUME_DIRECTIO = CLUSCTL_RESOURCE_ENABLE_SHARED_VOLUME_DIRECTIO =
CLUSCTL_RESOURCE_CODE( CLCTL_ENABLE_SHARED_VOLUME_DIRECTIO ), CLUSCTL_RESOURCE_CODE( CLCTL_ENABLE_SHARED_VOLUME_DIRECTIO ),
CLUSCTL_RESOURCE_DISABLE_SHARED_VOLUME_DIRECTIO = CLUSCTL_RESOURCE_DISABLE_SHARED_VOLUME_DIRECTIO =
CLUSCTL_RESOURCE_CODE( CLCTL_DISABLE_SHARED_VOLUME_DIRECTIO ), CLUSCTL_RESOURCE_CODE( CLCTL_DISABLE_SHARED_VOLUME_DIRECTIO ),
CLUSCTL_RESOURCE_SET_SHARED_VOLUME_BACKUP_MODE = CLUSCTL_RESOURCE_SET_SHARED_VOLUME_BACKUP_MODE =
CLUSCTL_RESOURCE_CODE( CLCTL_SET_SHARED_VOLUME_BACKUP_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_SET_SHARED_VOLUME_BACKUP_MODE ),
// Internal CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_PARTITION_NAMES =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_SHARED_VOLUME_PARTITION_NAMES )
,
// get diagnostics info about resource failures
CLUSCTL_RESOURCE_GET_FAILURE_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_FAILURE_INFO ),
CLUSCTL_RESOURCE_STORAGE_GET_DISKID =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISKID ),
CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_STATES =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_SHARED_VOLUME_STATES ),
CLUSCTL_RESOURCE_STORAGE_IS_SHARED_VOLUME =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_IS_SHARED_VOLUME ),
CLUSCTL_RESOURCE_IS_QUORUM_BLOCKED =
CLUSCTL_RESOURCE_CODE( CLCTL_IS_QUORUM_BLOCKED ),
CLUSCTL_RESOURCE_POOL_GET_DRIVE_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_POOL_GET_DRIVE_INFO ),
CLUSCTL_RESOURCE_RLUA_GET_VIRTUAL_SERVER_TOKEN =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN ),
CLUSCTL_RESOURCE_RLUA_SET_PWD_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_SET_PWD_INFO ),
//
// Internal resource codes
//
CLUSCTL_RESOURCE_DELETE = CLUSCTL_RESOURCE_DELETE =
CLUSCTL_RESOURCE_CODE( CLCTL_DELETE ), CLUSCTL_RESOURCE_CODE( CLCTL_DELETE ),
CLUSCTL_RESOURCE_INSTALL_NODE = CLUSCTL_RESOURCE_INSTALL_NODE =
CLUSCTL_RESOURCE_CODE( CLCTL_INSTALL_NODE ), CLUSCTL_RESOURCE_CODE( CLCTL_INSTALL_NODE ),
CLUSCTL_RESOURCE_EVICT_NODE = CLUSCTL_RESOURCE_EVICT_NODE =
CLUSCTL_RESOURCE_CODE( CLCTL_EVICT_NODE ), CLUSCTL_RESOURCE_CODE( CLCTL_EVICT_NODE ),
CLUSCTL_RESOURCE_ADD_DEPENDENCY = CLUSCTL_RESOURCE_ADD_DEPENDENCY =
skipping to change at line 2486 skipping to change at line 3339
CLUSCTL_RESOURCE_FSWITNESS_GET_EPOCH_INFO = CLUSCTL_RESOURCE_FSWITNESS_GET_EPOCH_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_GET_EPOCH_INFO ), CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_GET_EPOCH_INFO ),
CLUSCTL_RESOURCE_FSWITNESS_SET_EPOCH_INFO = CLUSCTL_RESOURCE_FSWITNESS_SET_EPOCH_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_SET_EPOCH_INFO ), CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_SET_EPOCH_INFO ),
CLUSCTL_RESOURCE_FSWITNESS_RELEASE_LOCK = CLUSCTL_RESOURCE_FSWITNESS_RELEASE_LOCK =
CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_RELEASE_LOCK ), CLUSCTL_RESOURCE_CODE( CLCTL_FSWITNESS_RELEASE_LOCK ),
CLUSCTL_RESOURCE_NETNAME_CREDS_UPDATED =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_CREDS_UPDATED ),
CLUSCTL_RESOURCE_NETNAME_CREDS_NOTIFYCAM = CLUSCTL_RESOURCE_NETNAME_CREDS_NOTIFYCAM =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_CREDS_NOTIFYCAM ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_CREDS_NOTIFYCAM ),
CLUSCTL_RESOURCE_SET_CLUSTER_MEMBERSHIP = /*
CLUSCTL_RESOURCE_CODE( CLCTL_SET_CLUSTER_MEMBERSHIP ), CLUSCTL_RESOURCE_GET_OPERATION_CONTEXT
CLUSCTL_RESOURCE_SET_SHARED_PR_KEY = input is GET_OPERATION_CONTEXT_PARAMS
CLUSCTL_RESOURCE_CODE( CLCTL_SET_SHARED_PR_KEY ),
CLUSCTL_RESOURCE_STORAGE_GET_DISK_NUMBER = output should be a property list containing
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_NUMBER ), CLUSRES_GET_OPERATION_CONTEXT_FLAGS
CLUSCTL_RESOURCE_STORAGE_GET_CSV_DISK_INFO = and 0->many properties with the name being a resource type name
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_CSV_DISK_INFO ), and the value being what will be passed along with it
*/
CLUSCTL_RESOURCE_QUERY_CSV_MAINTENANCE_MODE = CLUSCTL_RESOURCE_GET_OPERATION_CONTEXT =
CLUSCTL_RESOURCE_CODE( CLCTL_QUERY_CSV_MAINTENANCE_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_OPERATION_CONTEXT ),
CLUSCTL_RESOURCE_RW_MODIFY_NOOP =
CLUSCTL_RESOURCE_CODE( CLCTL_RW_MODIFY_NOOP ),
CLUSCTL_RESOURCE_NOTIFY_QUORUM_STATUS =
CLUSCTL_RESOURCE_CODE( CLCTL_NOTIFY_QUORUM_STATUS ),
CLUSCTL_RESOURCE_NOTIFY_OWNER_CHANGE =
CLUSCTL_RESOURCE_CODE( CLCTL_NOTIFY_OWNER_CHANGE ),
} CLUSCTL_RESOURCE_CODES; } CLUSCTL_RESOURCE_CODES;
// //
// Cluster Control Codes for Resource Types // Cluster Control Codes for Resource Types
// //
typedef enum CLUSCTL_RESOURCE_TYPE_CODES { typedef enum CLUSCTL_RESOURCE_TYPE_CODES {
// External // External
CLUSCTL_RESOURCE_TYPE_UNKNOWN = CLUSCTL_RESOURCE_TYPE_UNKNOWN =
skipping to change at line 2590 skipping to change at line 3449
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS = CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS ),
CLUSCTL_RESOURCE_TYPE_STORAGE_SYNC_CLUSDISK_DB = CLUSCTL_RESOURCE_TYPE_STORAGE_SYNC_CLUSDISK_DB =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_SYNC_CLUSDISK_DB ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_SYNC_CLUSDISK_DB ),
CLUSCTL_RESOURCE_TYPE_NETNAME_VALIDATE_NETNAME = CLUSCTL_RESOURCE_TYPE_NETNAME_VALIDATE_NETNAME =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_NETNAME ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_NETNAME ),
CLUSCTL_RESOURCE_TYPE_NETNAME_GET_OU_FOR_VCO =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_NETNAME_GET_OU_FOR_VCO ),
CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_PATH = CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_PATH =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_PATH ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_PATH ),
CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_DIRECTORY = CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_DIRECTORY =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_DIRECTORY ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_DIRECTORY ),
CLUSCTL_RESOURCE_TYPE_GEN_SCRIPT_VALIDATE_PATH = CLUSCTL_RESOURCE_TYPE_GEN_SCRIPT_VALIDATE_PATH =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_PATH ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_VALIDATE_PATH ),
CLUSCTL_RESOURCE_TYPE_QUERY_DELETE = CLUSCTL_RESOURCE_TYPE_QUERY_DELETE =
skipping to change at line 2614 skipping to change at line 3476
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX = CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX ),
CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER = CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_REMAP_DRIVELETTER ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_REMAP_DRIVELETTER ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DISKID = CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DISKID =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_DISKID ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_DISKID ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_RESOURCEID =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_RESOURCEID ),
CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CLUSTERABLE = CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CLUSTERABLE =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_IS_CLUSTERABLE ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_IS_CLUSTERABLE ),
CLUSCTL_RESOURCE_TYPE_STORAGE_REMOVE_VM_OWNERSHIP = CLUSCTL_RESOURCE_TYPE_STORAGE_REMOVE_VM_OWNERSHIP =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_REMOVE_VM_OWNERSHIP ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_REMOVE_VM_OWNERSHIP ),
CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CSV_FILE = CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CSV_FILE =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_IS_CSV_FILE ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_IS_CSV_FILE ),
CLUSCTL_RESOURCE_TYPE_WITNESS_VALIDATE_PATH = CLUSCTL_RESOURCE_TYPE_WITNESS_VALIDATE_PATH =
skipping to change at line 2649 skipping to change at line 3514
CLUSCTL_RESOURCE_TYPE_STARTING_PHASE1 = CLUSCTL_RESOURCE_TYPE_STARTING_PHASE1 =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STARTING_PHASE1 ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STARTING_PHASE1 ),
CLUSCTL_RESOURCE_TYPE_STARTING_PHASE2 = CLUSCTL_RESOURCE_TYPE_STARTING_PHASE2 =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STARTING_PHASE2 ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STARTING_PHASE2 ),
CLUSCTL_RESOURCE_TYPE_HOLD_IO = CLUSCTL_RESOURCE_TYPE_HOLD_IO =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_HOLD_IO ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_HOLD_IO ),
CLUSCTL_RESOURCE_TYPE_RESUME_IO = CLUSCTL_RESOURCE_TYPE_RESUME_IO =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_RESUME_IO ) CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_RESUME_IO ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INT =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX2_INT ),
} CLUSCTL_RESOURCE_TYPE_CODES; } CLUSCTL_RESOURCE_TYPE_CODES;
// //
// Cluster Control Codes for Groups // Cluster Control Codes for Groups
// //
typedef enum CLUSCTL_GROUP_CODES { typedef enum CLUSCTL_GROUP_CODES {
// External // External
CLUSCTL_GROUP_UNKNOWN = CLUSCTL_GROUP_UNKNOWN =
CLUSCTL_GROUP_CODE( CLCTL_UNKNOWN ), CLUSCTL_GROUP_CODE( CLCTL_UNKNOWN ),
skipping to change at line 2711 skipping to change at line 3578
CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES = CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES =
CLUSCTL_GROUP_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ), CLUSCTL_GROUP_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ),
CLUSCTL_GROUP_QUERY_DELETE = CLUSCTL_GROUP_QUERY_DELETE =
CLUSCTL_GROUP_CODE( CLCTL_QUERY_DELETE ), CLUSCTL_GROUP_CODE( CLCTL_QUERY_DELETE ),
CLUSCTL_GROUP_GET_COMMON_PROPERTY_FMTS= CLUSCTL_GROUP_GET_COMMON_PROPERTY_FMTS=
CLUSCTL_GROUP_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ), CLUSCTL_GROUP_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ),
CLUSCTL_GROUP_GET_PRIVATE_PROPERTY_FMTS= CLUSCTL_GROUP_GET_PRIVATE_PROPERTY_FMTS=
CLUSCTL_GROUP_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ) CLUSCTL_GROUP_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ),
CLUSCTL_GROUP_GET_FAILURE_INFO =
CLUSCTL_GROUP_CODE( CLCTL_GET_FAILURE_INFO ),
// Internal // Internal
} CLUSCTL_GROUP_CODES; } CLUSCTL_GROUP_CODES;
// //
// Cluster Control Codes for Nodes // Cluster Control Codes for Nodes
// //
typedef enum CLUSCTL_NODE_CODES { typedef enum CLUSCTL_NODE_CODES {
skipping to change at line 2775 skipping to change at line 3645
CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES = CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES =
CLUSCTL_NODE_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ), CLUSCTL_NODE_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ),
CLUSCTL_NODE_GET_COMMON_PROPERTY_FMTS= CLUSCTL_NODE_GET_COMMON_PROPERTY_FMTS=
CLUSCTL_NODE_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ), CLUSCTL_NODE_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ),
CLUSCTL_NODE_GET_PRIVATE_PROPERTY_FMTS= CLUSCTL_NODE_GET_PRIVATE_PROPERTY_FMTS=
CLUSCTL_NODE_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ), CLUSCTL_NODE_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ),
CLUSCTL_NODE_GET_CLUSTER_SERVICE_ACCOUNT_NAME = CLUSCTL_NODE_GET_CLUSTER_SERVICE_ACCOUNT_NAME =
CLUSCTL_NODE_CODE( CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME ) CLUSCTL_NODE_CODE( CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME ),
CLUSCTL_NODE_GET_STUCK_NODES =
CLUSCTL_NODE_CODE( CLCTL_GET_STUCK_NODES),
CLUSCTL_NODE_INJECT_GEM_FAULT =
CLUSCTL_NODE_CODE( CLCTL_INJECT_GEM_FAULT),
CLUSCTL_NODE_INTRODUCE_GEM_REPAIR_DELAY =
CLUSCTL_NODE_CODE(CLCTL_INTRODUCE_GEM_REPAIR_DELAY),
CLUSCTL_NODE_SEND_DUMMY_GEM_MESSAGES =
CLUSCTL_NODE_CODE(CLCTL_SEND_DUMMY_GEM_MESSAGES),
CLUSCTL_NODE_BLOCK_GEM_SEND_RECV =
CLUSCTL_NODE_CODE(CLCTL_BLOCK_GEM_SEND_RECV),
CLUSCTL_NODE_GET_GEMID_VECTOR =
CLUSCTL_NODE_CODE(CLCTL_GET_GEMID_VECTOR),
} CLUSCTL_NODE_CODES; } CLUSCTL_NODE_CODES;
// //
// Cluster Control Codes for Networks // Cluster Control Codes for Networks
// //
typedef enum CLUSCTL_NETWORK_CODES { typedef enum CLUSCTL_NETWORK_CODES {
// External // External
CLUSCTL_NETWORK_UNKNOWN = CLUSCTL_NETWORK_UNKNOWN =
skipping to change at line 2834 skipping to change at line 3722
CLUSCTL_NETWORK_SET_PRIVATE_PROPERTIES = CLUSCTL_NETWORK_SET_PRIVATE_PROPERTIES =
CLUSCTL_NETWORK_CODE( CLCTL_SET_PRIVATE_PROPERTIES ), CLUSCTL_NETWORK_CODE( CLCTL_SET_PRIVATE_PROPERTIES ),
CLUSCTL_NETWORK_VALIDATE_PRIVATE_PROPERTIES = CLUSCTL_NETWORK_VALIDATE_PRIVATE_PROPERTIES =
CLUSCTL_NETWORK_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ), CLUSCTL_NETWORK_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ),
CLUSCTL_NETWORK_GET_COMMON_PROPERTY_FMTS= CLUSCTL_NETWORK_GET_COMMON_PROPERTY_FMTS=
CLUSCTL_NETWORK_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ), CLUSCTL_NETWORK_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ),
CLUSCTL_NETWORK_GET_PRIVATE_PROPERTY_FMTS= CLUSCTL_NETWORK_GET_PRIVATE_PROPERTY_FMTS=
CLUSCTL_NETWORK_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ) CLUSCTL_NETWORK_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ),
} CLUSCTL_NETWORK_CODES; } CLUSCTL_NETWORK_CODES;
// //
// Cluster Control Codes for Network Interfaces // Cluster Control Codes for Network Interfaces
// //
typedef enum CLUSCTL_NETINTERFACE_CODES { typedef enum CLUSCTL_NETINTERFACE_CODES {
// External // External
CLUSCTL_NETINTERFACE_UNKNOWN = CLUSCTL_NETINTERFACE_UNKNOWN =
skipping to change at line 2899 skipping to change at line 3787
CLUSCTL_NETINTERFACE_SET_PRIVATE_PROPERTIES = CLUSCTL_NETINTERFACE_SET_PRIVATE_PROPERTIES =
CLUSCTL_NETINTERFACE_CODE( CLCTL_SET_PRIVATE_PROPERTIES ), CLUSCTL_NETINTERFACE_CODE( CLCTL_SET_PRIVATE_PROPERTIES ),
CLUSCTL_NETINTERFACE_VALIDATE_PRIVATE_PROPERTIES = CLUSCTL_NETINTERFACE_VALIDATE_PRIVATE_PROPERTIES =
CLUSCTL_NETINTERFACE_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ), CLUSCTL_NETINTERFACE_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ),
CLUSCTL_NETINTERFACE_GET_COMMON_PROPERTY_FMTS= CLUSCTL_NETINTERFACE_GET_COMMON_PROPERTY_FMTS=
CLUSCTL_NETINTERFACE_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ), CLUSCTL_NETINTERFACE_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ),
CLUSCTL_NETINTERFACE_GET_PRIVATE_PROPERTY_FMTS= CLUSCTL_NETINTERFACE_GET_PRIVATE_PROPERTY_FMTS=
CLUSCTL_NETINTERFACE_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ) CLUSCTL_NETINTERFACE_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ),
} CLUSCTL_NETINTERFACE_CODES; } CLUSCTL_NETINTERFACE_CODES;
// //
// Cluster Control Codes for Clusters // Cluster Control Codes for Clusters
// //
typedef enum CLUSCTL_CLUSTER_CODES { typedef enum CLUSCTL_CLUSTER_CODES {
// External // External
CLUSCTL_CLUSTER_UNKNOWN = CLUSCTL_CLUSTER_UNKNOWN =
skipping to change at line 2969 skipping to change at line 3857
CLUSCTL_CLUSTER_BATCH_BLOCK_KEY = CLUSCTL_CLUSTER_BATCH_BLOCK_KEY =
CLUSCTL_CLUSTER_CODE( CLCTL_BATCH_BLOCK_KEY ), CLUSCTL_CLUSTER_CODE( CLCTL_BATCH_BLOCK_KEY ),
CLUSCTL_CLUSTER_BATCH_UNBLOCK_KEY = CLUSCTL_CLUSTER_BATCH_UNBLOCK_KEY =
CLUSCTL_CLUSTER_CODE( CLCTL_BATCH_UNBLOCK_KEY ), CLUSCTL_CLUSTER_CODE( CLCTL_BATCH_UNBLOCK_KEY ),
CLUSCTL_CLUSTER_GET_SHARED_VOLUME_ID = CLUSCTL_CLUSTER_GET_SHARED_VOLUME_ID =
CLUSCTL_CLUSTER_CODE( CLCTL_GET_SHARED_VOLUME_ID ), CLUSCTL_CLUSTER_CODE( CLCTL_GET_SHARED_VOLUME_ID ),
CLUSCTL_CLUSTER_GET_CLUSDB_TIMESTAMP =
CLUSCTL_CLUSTER_CODE( CLCTL_GET_CLUSDB_TIMESTAMP ),
CLUSCTL_CLUSTER_GET_GUM_LOCK_OWNER =
CLUSCTL_CLUSTER_CODE( CLCTL_GET_GUM_LOCK_OWNER ),
} CLUSCTL_CLUSTER_CODES; } CLUSCTL_CLUSTER_CODES;
// //
// Cluster Resource Class types // Cluster Resource Class types
// //
typedef enum CLUSTER_RESOURCE_CLASS { typedef enum CLUSTER_RESOURCE_CLASS {
CLUS_RESCLASS_UNKNOWN = 0, CLUS_RESCLASS_UNKNOWN = 0,
CLUS_RESCLASS_STORAGE, CLUS_RESCLASS_STORAGE,
CLUS_RESCLASS_NETWORK, CLUS_RESCLASS_NETWORK,
CLUS_RESCLASS_USER = 32768 CLUS_RESCLASS_USER = 32768
skipping to change at line 2991 skipping to change at line 3885
// //
// Define Resource SubClass bits // Define Resource SubClass bits
// //
// legacy subclass struct // legacy subclass struct
// //
typedef enum CLUS_RESSUBCLASS { typedef enum CLUS_RESSUBCLASS {
CLUS_RESSUBCLASS_SHARED = 0x80000000 CLUS_RESSUBCLASS_SHARED = 0x80000000
} CLUS_RESSUBCLASS; } CLUS_RESSUBCLASS;
typedef enum CLUS_RESSUBCLASS_STORAGE { typedef enum CLUS_RESSUBCLASS_STORAGE {
CLUS_RESSUBCLASS_STORAGE_SHARED_BUS = 0x80000000 CLUS_RESSUBCLASS_STORAGE_SHARED_BUS = 0x80000000,
CLUS_RESSUBCLASS_STORAGE_DISK = 0x40000000
} CLUS_RESSUBCLASS_STORAGE; } CLUS_RESSUBCLASS_STORAGE;
typedef enum CLUS_RESSUBCLASS_NETWORK { typedef enum CLUS_RESSUBCLASS_NETWORK {
CLUS_RESSUBCLASS_NETWORK_INTERNET_PROTOCOL = 0x80000000 // Identifies IP address providers CLUS_RESSUBCLASS_NETWORK_INTERNET_PROTOCOL = 0x80000000 // Identifies IP address providers
} CLUS_RESSUBCLASS_NETWORK; } CLUS_RESSUBCLASS_NETWORK;
// //
// Cluster Characteristics used by resource types and resources // Cluster Characteristics used by resource types and resources
// //
typedef enum CLUS_CHARACTERISTICS { typedef enum CLUS_CHARACTERISTICS {
CLUS_CHAR_UNKNOWN = 0x00000000, CLUS_CHAR_UNKNOWN = 0x00000000,
CLUS_CHAR_QUORUM = 0x00000001, CLUS_CHAR_QUORUM = 0x00000001,
CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002, CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002,
CLUS_CHAR_LOCAL_QUORUM = 0x00000004, // deprecated in Vista CLUS_CHAR_LOCAL_QUORUM = 0x00000004, // deprecated in Vista
CLUS_CHAR_LOCAL_QUORUM_DEBUG = 0x00000008, // deprecated in Vista CLUS_CHAR_LOCAL_QUORUM_DEBUG = 0x00000008, // deprecated in Vista
CLUS_CHAR_REQUIRES_STATE_CHANGE_REASON = 0x00000010, CLUS_CHAR_REQUIRES_STATE_CHANGE_REASON = 0x00000010,
CLUS_CHAR_BROADCAST_DELETE = 0x00000020, CLUS_CHAR_BROADCAST_DELETE = 0x00000020,
CLUS_CHAR_SINGLE_CLUSTER_INSTANCE = 0x00000040, // only one reso urce of this type allowed per cluster CLUS_CHAR_SINGLE_CLUSTER_INSTANCE = 0x00000040, // only one reso urce of this type allowed per cluster
CLUS_CHAR_SINGLE_GROUP_INSTANCE = 0x00000080 // only one reso CLUS_CHAR_SINGLE_GROUP_INSTANCE = 0x00000080, // only one reso
urce of this type allowed per group urce of this type allowed per group
CLUS_CHAR_COEXIST_IN_SHARED_VOLUME_GROUP= 0x00000100,
CLUS_CHAR_PLACEMENT_DATA = 0x00000200,
CLUS_CHAR_MONITOR_DETACH = 0x00000400,
CLUS_CHAR_MONITOR_REATTACH = 0x00000800,
CLUS_CHAR_OPERATION_CONTEXT = 0x00001000,
CLUS_CHAR_CLONES = 0x00002000,
CLUS_CHAR_NOT_PREEMPTABLE = 0x00004000,
CLUS_CHAR_NOTIFY_NEW_OWNER = 0x00008000
} CLUS_CHARACTERISTICS; } CLUS_CHARACTERISTICS;
// //
// Cluster Flags // Cluster Flags
// //
typedef enum CLUS_FLAGS { typedef enum CLUS_FLAGS {
CLUS_FLAG_CORE = 0x00000001 CLUS_FLAG_CORE = 0x00000001
} CLUS_FLAGS; } CLUS_FLAGS;
// //
skipping to change at line 3203 skipping to change at line 4106
#endif // MIDL_PASS #endif // MIDL_PASS
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// Disk partition information flags. // Disk partition information flags.
typedef enum CLUSPROP_PIFLAGS { typedef enum CLUSPROP_PIFLAGS {
CLUSPROP_PIFLAG_STICKY = 0x00000001, CLUSPROP_PIFLAG_STICKY = 0x00000001,
CLUSPROP_PIFLAG_REMOVABLE = 0x00000002, CLUSPROP_PIFLAG_REMOVABLE = 0x00000002,
CLUSPROP_PIFLAG_USABLE = 0x00000004, CLUSPROP_PIFLAG_USABLE = 0x00000004,
CLUSPROP_PIFLAG_DEFAULT_QUORUM = 0x00000008 CLUSPROP_PIFLAG_DEFAULT_QUORUM = 0x00000008,
CLUSPROP_PIFLAG_USABLE_FOR_CSV = 0x00000010
} CLUSPROP_PIFLAGS; } CLUSPROP_PIFLAGS;
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
//force quorum information, useful for QON type resources //force quorum information, useful for QON type resources
//to be able to continue operation without the quorum //to be able to continue operation without the quorum
typedef struct CLUS_FORCE_QUORUM_INFO { typedef struct CLUS_FORCE_QUORUM_INFO {
DWORD dwSize; // size of this struct including the nod es list. DWORD dwSize; // size of this struct including the nod es list.
DWORD dwNodeBitMask; // a bit mask representing the max assum ed node set DWORD dwNodeBitMask; // a bit mask representing the max assum ed node set
DWORD dwMaxNumberofNodes; // the number of bits set in the mask DWORD dwMaxNumberofNodes; // the number of bits set in the mask
WCHAR multiszNodeList[1]; // Multi sz list of nodes WCHAR multiszNodeList[1]; // Multi sz list of nodes
skipping to change at line 3256 skipping to change at line 4160
DWORD DeviceNumber; DWORD DeviceNumber;
DWORD PartitionNumber; DWORD PartitionNumber;
GUID VolumeGuid; GUID VolumeGuid;
} CLUS_PARTITION_INFO_EX, *PCLUS_PARTITION_INFO_EX; } CLUS_PARTITION_INFO_EX, *PCLUS_PARTITION_INFO_EX;
typedef enum _CLUSTER_CSV_VOLUME_FAULT_STATE { typedef enum _CLUSTER_CSV_VOLUME_FAULT_STATE {
VolumeStateNoFaults = 0x00000000, VolumeStateNoFaults = 0x00000000,
VolumeStateNoDirectIO = 0x00000001, VolumeStateNoDirectIO = 0x00000001,
VolumeStateNoAccess = 0x00000002, VolumeStateNoAccess = 0x00000002,
VolumeStateInMaintenance = 0x00000004, VolumeStateInMaintenance = 0x00000004,
VolumeStateDismounted = 0x00000008
} CLUSTER_CSV_VOLUME_FAULT_STATE, *PCLUSTER_CSV_VOLUME_FAULT_STATE; } CLUSTER_CSV_VOLUME_FAULT_STATE, *PCLUSTER_CSV_VOLUME_FAULT_STATE;
typedef enum _CLUSTER_SHARED_VOLUME_BACKUP_STATE { typedef enum _CLUSTER_SHARED_VOLUME_BACKUP_STATE {
VolumeBackupNone = 0x00000000, VolumeBackupNone = 0x00000000,
VolumeBackupInProgress = 0x00000001 VolumeBackupInProgress = 0x00000001
} CLUSTER_SHARED_VOLUME_BACKUP_STATE, *PCLUSTER_SHARED_VOLUME_BACKUP_STATE; } CLUSTER_SHARED_VOLUME_BACKUP_STATE, *PCLUSTER_SHARED_VOLUME_BACKUP_STATE;
typedef struct _CLUS_CSV_VOLUME_INFO { typedef struct _CLUS_CSV_VOLUME_INFO {
ULARGE_INTEGER VolumeOffset; ULARGE_INTEGER VolumeOffset;
DWORD PartitionNumber; DWORD PartitionNumber;
CLUSTER_CSV_VOLUME_FAULT_STATE FaultState; CLUSTER_CSV_VOLUME_FAULT_STATE FaultState;
CLUSTER_SHARED_VOLUME_BACKUP_STATE BackupState; CLUSTER_SHARED_VOLUME_BACKUP_STATE BackupState;
WCHAR szVolumeFriendlyName[MAX_PATH]; WCHAR szVolumeFriendlyName[MAX_PATH];
WCHAR szVolumeName[50]; // volume GUID WCHAR szVolumeName[50]; // CSV volume name
} CLUS_CSV_VOLUME_INFO, *PCLUS_CSV_VOLUME_INFO; } CLUS_CSV_VOLUME_INFO, *PCLUS_CSV_VOLUME_INFO;
typedef struct _CLUS_CSV_VOLUME_NAME {
LARGE_INTEGER VolumeOffset;
WCHAR szVolumeName[MAX_PATH];
WCHAR szRootPath[MAX_PATH+3];
} CLUS_CSV_VOLUME_NAME, *PCLUS_CSV_VOLUME_NAME;
typedef enum _CLUSTER_SHARED_VOLUME_STATE
{
SharedVolumeStateUnavailable = 0,
SharedVolumeStatePaused = 1,
SharedVolumeStateActive = 2,
SharedVolumeStateActiveRedirected = 3,
SharedVolumeStateActiveVolumeRedirected = 4
} CLUSTER_SHARED_VOLUME_STATE, *PCLUSTER_SHARED_VOLUME_STATE;
typedef struct _CLUSTER_SHARED_VOLUME_STATE_INFO
{
WCHAR szVolumeName[MAX_PATH];
WCHAR szNodeName[MAX_PATH];
CLUSTER_SHARED_VOLUME_STATE VolumeState;
} CLUSTER_SHARED_VOLUME_STATE_INFO, *PCLUSTER_SHARED_VOLUME_STATE_INFO;
// Bit mask values for CSV redirected IO reason - upto 64 reasons are supported.
#define RedirectedIOReasonUserRequest 0x0000000000000001
#define RedirectedIOReasonUnsafeFileSystemFilter 0x0000000000000002
#define RedirectedIOReasonUnsafeVolumeFilter 0x0000000000000004
#define RedirectedIOReasonFileSystemTiering 0x0000000000000008
#define RedirectedIOReasonBitLockerInitializing 0x0000000000000010
#define RedirectedIOReasonMax 0x8000000000000000
#define VolumeRedirectedIOReasonNoDiskConnectivity 0x0000000000000001
#define VolumeRedirectedIOReasonStorageSpaceNotAttached 0x0000000000000002
#define VolumeRedirectedIOReasonMax 0x8000000000000000
typedef struct _CLUSTER_SHARED_VOLUME_STATE_INFO_EX
{
WCHAR szVolumeName[MAX_PATH];
WCHAR szNodeName[MAX_PATH];
CLUSTER_SHARED_VOLUME_STATE VolumeState;
WCHAR szVolumeFriendlyName[MAX_PATH];
ULONGLONG RedirectedIOReason;
ULONGLONG VolumeRedirectedIOReason;
} CLUSTER_SHARED_VOLUME_STATE_INFO_EX, *PCLUSTER_SHARED_VOLUME_STATE_INFO_EX;
typedef struct _CLUS_CHKDSK_INFO {
DWORD PartitionNumber;
DWORD ChkdskState;
DWORD FileIdCount;
ULONGLONG FileIdList[1]; // variable length array
} CLUS_CHKDSK_INFO, *PCLUS_CHKDSK_INFO;
typedef struct _CLUS_DISK_NUMBER_INFO { typedef struct _CLUS_DISK_NUMBER_INFO {
DWORD DiskNumber; DWORD DiskNumber;
DWORD BytesPerSector; DWORD BytesPerSector;
} CLUS_DISK_NUMBER_INFO, *PCLUS_DISK_NUMBER_INFO; } CLUS_DISK_NUMBER_INFO, *PCLUS_DISK_NUMBER_INFO;
typedef struct _CLUS_SHARED_VOLUME_BACKUP_MODE { typedef struct _CLUS_SHARED_VOLUME_BACKUP_MODE {
CLUSTER_SHARED_VOLUME_BACKUP_STATE BackupState; CLUSTER_SHARED_VOLUME_BACKUP_STATE BackupState;
DWORD DelayTimerInSecs; DWORD DelayTimerInSecs;
WCHAR VolumeName[MAX_PATH]; WCHAR VolumeName[MAX_PATH];
} CLUS_SHARED_VOLUME_BACKUP_MODE, *PCLUS_SHARED_VOLUME_BACKUP_MODE; } CLUS_SHARED_VOLUME_BACKUP_MODE, *PCLUS_SHARED_VOLUME_BACKUP_MODE;
skipping to change at line 3364 skipping to change at line 4321
#endif #endif
} CLUSPROP_SCSI_ADDRESS, *PCLUSPROP_SCSI_ADDRESS; } CLUSPROP_SCSI_ADDRESS, *PCLUSPROP_SCSI_ADDRESS;
// //
// input structure for CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN // input structure for CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN
// //
typedef struct CLUS_NETNAME_VS_TOKEN_INFO { typedef struct CLUS_NETNAME_VS_TOKEN_INFO {
DWORD ProcessID; DWORD ProcessID;
DWORD DesiredAccess; DWORD DesiredAccess;
BOOL InheritHandle; BOOL InheritHandle;
} CLUS_NETNAME_VS_TOKEN_INFO, *PCLUS_NETNAME_VS_TOKEN_INFO; } CLUS_NETNAME_VS_TOKEN_INFO, CLUS_VS_TOKEN_INFO, *PCLUS_NETNAME_VS_TOKEN_INFO, *PCLUS_VS_TOKEN_INFO;
// //
// input structure for CLUSCTL_RESOURCE_NETNAME_SET_PWD // input structure for CLUSCTL_RESOURCE_NETNAME_SET_PWD_INFO and for CLUSCTL_RES OURCE_RLUA_SET_PWD_INFO
// //
#define MAX_OBJECTID 64 #define MAX_OBJECTID 64
#define MAX_CO_PASSWORD_LENGTH 16 #define MAX_CO_PASSWORD_LENGTH 16
#define GUID_PRESENT 0x1 #define GUID_PRESENT 0x1
#define CREATEDC_PRESENT 0x2 #define CREATEDC_PRESENT 0x2
#define MAX_CREATINGDC_LENGTH 256 #define MAX_CREATINGDC_LENGTH 256
typedef struct CLUS_NETNAME_PWD_INFO { typedef struct CLUS_NETNAME_PWD_INFO {
DWORD Flags; DWORD Flags;
WCHAR Password[MAX_CO_PASSWORD_LENGTH]; WCHAR Password[MAX_CO_PASSWORD_LENGTH];
WCHAR CreatingDC[MAX_CREATINGDC_LENGTH+2]; // including the '\\' prefix WCHAR CreatingDC[MAX_CREATINGDC_LENGTH+2]; // including the '\\' prefix
WCHAR ObjectGuid[MAX_OBJECTID]; // WCHAR ObjectGuid[MAX_OBJECTID]; //
} CLUS_NETNAME_PWD_INFO, *PCLUS_NETNAME_PWD_INFO; } CLUS_NETNAME_PWD_INFO, *PCLUS_NETNAME_PWD_INFO, CLUS_RLUA_PWD_INFO, *PCLUS_RLU
A_PWD_INFO;
//
// input structure for CLUSCTL_RESOURCE_DNN_SEND_LEADER_STATUS
//
typedef struct CLUS_DNN_LEADER_STATUS {
BOOL IsOnline; // Indicates if the leader is online or is shutting down
BOOL IsFileServerPresent; // Indicates if a file server is depending on the
netname
} CLUS_DNN_LEADER_STATUS , *PCLUS_DNN_LEADER_STATUS;
//
// input structure for CLUSCTL_RESOURCE_DNN_UPDATE_SODAFS_CLONE_STATUS
//
typedef struct CLUS_DNN_SODAFS_CLONE_STATUS {
DWORD NodeId; // Indicates the cluster assigned node id of the SODAFS clone
CLUSTER_RESOURCE_STATE Status; // Indicates the status of the clone (Online/
Failed)
} CLUS_DNN_SODAFS_CLONE_STATUS , *PCLUS_DNN_SODAFS_CLONE_STATUS;
//
// A single IP info entry consisting of the node and the IP address
//
typedef struct CLUS_NETNAME_IP_INFO_ENTRY {
DWORD NodeId; // Node to which this IP belongs to
DWORD AddressSize;
BYTE Address[ANYSIZE_ARRAY]; // The actual IP info
} CLUS_NETNAME_IP_INFO_ENTRY, *PCLUS_NETNAME_IP_INFO_ENTRY;
//
// input structure for CLUSCTL_RESOURCE_NETNAME_SEND_IP_INFO_FOR_MULTICHANNEL
//
#define DNS_LENGTH 64
typedef struct CLUS_NETNAME_IP_INFO_FOR_MULTICHANNEL {
WCHAR szName[DNS_LENGTH]; // The actual name
DWORD NumEntries; // Number of CLUS_NETNAME_IP_INFO_ENTRY
CLUS_NETNAME_IP_INFO_ENTRY IpInfo[ANYSIZE_ARRAY]; // The actual IP Info as a
n array
} CLUS_NETNAME_IP_INFO_FOR_MULTICHANNEL, *PCLUS_NETNAME_IP_INFO_FOR_MULTICHANNEL
;
// //
// input/output structure associated with Maintenance Mode // input/output structure associated with Maintenance Mode
// //
typedef struct CLUS_MAINTENANCE_MODE_INFO { typedef struct CLUS_MAINTENANCE_MODE_INFO {
BOOL InMaintenance; BOOL InMaintenance;
} CLUS_MAINTENANCE_MODE_INFO, *PCLUS_MAINTENANCE_MODE_INFO; } CLUS_MAINTENANCE_MODE_INFO, *PCLUS_MAINTENANCE_MODE_INFO;
typedef struct CLUS_CSV_MAINTENANCE_MODE_INFO { typedef struct CLUS_CSV_MAINTENANCE_MODE_INFO {
BOOL InMaintenance; BOOL InMaintenance;
skipping to change at line 3557 skipping to change at line 4549
CLUSTER_RESOURCE_TYPE_ENUM_ALL = (CLUSTER_RESOURCE_TYPE_ENUM_NODES | CLUSTER_RESOURCE_TYPE_ENUM_ALL = (CLUSTER_RESOURCE_TYPE_ENUM_NODES |
CLUSTER_RESOURCE_TYPE_ENUM_RESOURCES ) CLUSTER_RESOURCE_TYPE_ENUM_RESOURCES )
} CLUSTER_RESOURCE_TYPE_ENUM; } CLUSTER_RESOURCE_TYPE_ENUM;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HRESENUM HRESENUM
WINAPI WINAPI
ClusterResourceOpenEnum( ClusterResourceOpenEnum(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HRESENUM typedef HRESENUM
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_OPEN_ENUM)(
HRESOURCE hResource, HRESOURCE hResource,
DWORD dwType DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceGetEnumCount( ClusterResourceGetEnumCount(
__in HRESENUM hResEnum _In_ HRESENUM hResEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_GET_ENUM_COUNT)(
__in HRESENUM hResEnum _In_ HRESENUM hResEnum
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceEnum( ClusterResourceEnum(
__in HRESENUM hResEnum, _In_ HRESENUM hResEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_ENUM)(
__in HRESENUM hResEnum, _In_ HRESENUM hResEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceCloseEnum( ClusterResourceCloseEnum(
__in HRESENUM hResEnum _In_ HRESENUM hResEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CLOSE_ENUM)(
HRESENUM hResEnum HRESENUM hResEnum
); );
DWORD DWORD
WINAPI WINAPI
CreateClusterResourceType( CreateClusterResourceType(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in LPCWSTR lpszDisplayName, _In_ LPCWSTR lpszDisplayName,
__in LPCWSTR lpszResourceTypeDll, _In_ LPCWSTR lpszResourceTypeDll,
__in DWORD dwLooksAlivePollInterval, _In_ DWORD dwLooksAlivePollInterval,
__in DWORD dwIsAlivePollInterval _In_ DWORD dwIsAlivePollInterval
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE_TYPE)( (WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE_TYPE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in LPCWSTR lpszDisplayName, _In_ LPCWSTR lpszDisplayName,
__in LPCWSTR lpszResourceTypeDll, _In_ LPCWSTR lpszResourceTypeDll,
__in DWORD dwLooksAlivePollInterval, _In_ DWORD dwLooksAlivePollInterval,
__in DWORD dwIsAlivePollInterval _In_ DWORD dwIsAlivePollInterval
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterResourceType( DeleteClusterResourceType(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName _In_ LPCWSTR lpszResourceTypeName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE_TYPE)( (WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE_TYPE)(
HCLUSTER hCluster, HCLUSTER hCluster,
LPCWSTR lpszResourceTypeName LPCWSTR lpszResourceTypeName
); );
HRESTYPEENUM HRESTYPEENUM
WINAPI WINAPI
ClusterResourceTypeOpenEnum( ClusterResourceTypeOpenEnum(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HRESTYPEENUM typedef HRESTYPEENUM
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_OPEN_ENUM)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, _In_ LPCWSTR lpszResourceTypeName,
__in DWORD dwType _In_ DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeGetEnumCount( ClusterResourceTypeGetEnumCount(
__in HRESTYPEENUM hResTypeEnum _In_ HRESTYPEENUM hResTypeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_GET_ENUM_COUNT)(
__in HRESTYPEENUM hResTypeEnum _In_ HRESTYPEENUM hResTypeEnum
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeEnum( ClusterResourceTypeEnum(
__in HRESTYPEENUM hResTypeEnum, _In_ HRESTYPEENUM hResTypeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_ENUM)(
__in HRESTYPEENUM hResTypeEnum, _In_ HRESTYPEENUM hResTypeEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeCloseEnum( ClusterResourceTypeCloseEnum(
__in HRESTYPEENUM hResTypeEnum _In_ HRESTYPEENUM hResTypeEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CLOSE_ENUM)(
__in HRESTYPEENUM hResTypeEnum _In_ HRESTYPEENUM hResTypeEnum
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Network-related structures and types. // Network-related structures and types.
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
skipping to change at line 3742 skipping to change at line 4734
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the networks of a cluster. // Interfaces for managing the networks of a cluster.
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HNETWORK HNETWORK
WINAPI WINAPI
OpenClusterNetwork( OpenClusterNetwork(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNetworkName _In_ LPCWSTR lpszNetworkName
); );
typedef HNETWORK typedef HNETWORK
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NETWORK)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NETWORK)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNetworkName _In_ LPCWSTR lpszNetworkName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HNETWORK HNETWORK
WINAPI WINAPI
OpenClusterNetworkEx( OpenClusterNetworkEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszNetworkName, _In_opt_ LPCWSTR lpszNetworkName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt DWORD* lpdwGrantedAccess _Out_opt_ DWORD* lpdwGrantedAccess
); );
typedef HNETWORK typedef HNETWORK
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NETWORK_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NETWORK_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszNetworkName, _In_opt_ LPCWSTR lpszNetworkName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
BOOL BOOL
WINAPI WINAPI
CloseClusterNetwork( CloseClusterNetwork(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NETWORK)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_NETWORK)(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNetwork( GetClusterFromNetwork(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NETWORK)( (WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NETWORK)(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
HNETWORKENUM HNETWORKENUM
WINAPI WINAPI
ClusterNetworkOpenEnum( ClusterNetworkOpenEnum(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in DWORD dwType _In_ DWORD dwType
); );
typedef HNETWORKENUM typedef HNETWORKENUM
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_OPEN_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NETWORK_OPEN_ENUM)(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in DWORD dwType _In_ DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetworkGetEnumCount( ClusterNetworkGetEnumCount(
__in HNETWORKENUM hNetworkEnum _In_ HNETWORKENUM hNetworkEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_GET_ENUM_COUNT)( (WINAPI * PCLUSAPI_CLUSTER_NETWORK_GET_ENUM_COUNT)(
__in HNETWORKENUM hNetworkEnum _In_ HNETWORKENUM hNetworkEnum
); );
__success (return == ERROR_SUCCESS) _Success_ (return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNetworkEnum( ClusterNetworkEnum(
__in HNETWORKENUM hNetworkEnum, _In_ HNETWORKENUM hNetworkEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NETWORK_ENUM)(
__in HNETWORKENUM hNetworkEnum, _In_ HNETWORKENUM hNetworkEnum,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out LPDWORD lpdwType, _Out_ LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetworkCloseEnum( ClusterNetworkCloseEnum(
__in HNETWORKENUM hNetworkEnum _In_ HNETWORKENUM hNetworkEnum
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_CLOSE_ENUM)( (WINAPI * PCLUSAPI_CLUSTER_NETWORK_CLOSE_ENUM)(
__in HNETWORKENUM hNetworkEnum _In_ HNETWORKENUM hNetworkEnum
); );
CLUSTER_NETWORK_STATE CLUSTER_NETWORK_STATE
WINAPI WINAPI
GetClusterNetworkState( GetClusterNetworkState(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
typedef CLUSTER_NETWORK_STATE typedef CLUSTER_NETWORK_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_STATE)( (WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_STATE)(
__in HNETWORK hNetwork _In_ HNETWORK hNetwork
); );
DWORD DWORD
WINAPI WINAPI
SetClusterNetworkName( SetClusterNetworkName(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in LPCWSTR lpszName _In_ LPCWSTR lpszName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_NAME)( (WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_NAME)(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in LPCWSTR lpszName _In_ LPCWSTR lpszName
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNetworkId( GetClusterNetworkId(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_ID)( (WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_ID)(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId,
__inout LPDWORD lpcchName _Inout_ LPDWORD lpcchName
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetworkControl( ClusterNetworkControl(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_NETWORK_CONTROL)(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Network interface-related structures and types. // Network interface-related structures and types.
// //
typedef enum CLUSTER_NETINTERFACE_STATE { typedef enum CLUSTER_NETINTERFACE_STATE {
ClusterNetInterfaceStateUnknown = -1, ClusterNetInterfaceStateUnknown = -1,
skipping to change at line 3937 skipping to change at line 4929
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the network interfaces of a cluster. // Interfaces for managing the network interfaces of a cluster.
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HNETINTERFACE HNETINTERFACE
WINAPI WINAPI
OpenClusterNetInterface( OpenClusterNetInterface(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszInterfaceName _In_ LPCWSTR lpszInterfaceName
); );
typedef HNETINTERFACE typedef HNETINTERFACE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NET_INTERFACE)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NET_INTERFACE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszInterfaceName _In_ LPCWSTR lpszInterfaceName
); );
#if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2) #if (CLUSAPI_VERSION >= CLUSAPI_VERSION_SERVER2008R2)
HNETINTERFACE HNETINTERFACE
WINAPI WINAPI
OpenClusterNetInterfaceEx( OpenClusterNetInterfaceEx(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszInterfaceName, _In_opt_ LPCWSTR lpszInterfaceName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt DWORD* lpdwGrantedAccess _Out_opt_ DWORD* lpdwGrantedAccess
); );
typedef HNETINTERFACE typedef HNETINTERFACE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NETINTERFACE_EX)( (WINAPI * PCLUSAPI_OPEN_CLUSTER_NETINTERFACE_EX)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt LPCWSTR lpszNetInterfaceName, _In_opt_ LPCWSTR lpszNetInterfaceName,
__in DWORD dwDesiredAccess, _In_ DWORD dwDesiredAccess,
__out_opt LPDWORD lpdwGrantedAccess _Out_opt_ LPDWORD lpdwGrantedAccess
); );
#endif #endif
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNetInterface( GetClusterNetInterface(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNodeName, _In_ LPCWSTR lpszNodeName,
__in LPCWSTR lpszNetworkName, _In_ LPCWSTR lpszNetworkName,
__out_ecount_part(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR lpszI _Out_writes_to_(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR lpszInt
nterfaceName, erfaceName,
__inout LPDWORD lpcchInterfaceName _Inout_ LPDWORD lpcchInterfaceName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE)( (WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in LPCWSTR lpszNodeName, _In_ LPCWSTR lpszNodeName,
__in LPCWSTR lpszNetworkName, _In_ LPCWSTR lpszNetworkName,
__out_ecount_part_opt(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR l _Out_writes_to_opt_(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR lps
pszInterfaceName, zInterfaceName,
__inout LPDWORD lpcchInterfaceName _Inout_ LPDWORD lpcchInterfaceName
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterNetInterface( CloseClusterNetInterface(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
typedef BOOL typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NET_INTERFACE)( (WINAPI * PCLUSAPI_CLOSE_CLUSTER_NET_INTERFACE)(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNetInterface( GetClusterFromNetInterface(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NET_INTERFACE)( (WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NET_INTERFACE)(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
CLUSTER_NETINTERFACE_STATE CLUSTER_NETINTERFACE_STATE
WINAPI WINAPI
GetClusterNetInterfaceState( GetClusterNetInterfaceState(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
typedef CLUSTER_NETINTERFACE_STATE typedef CLUSTER_NETINTERFACE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_STATE)( (WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_STATE)(
__in HNETINTERFACE hNetInterface _In_ HNETINTERFACE hNetInterface
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetInterfaceControl( ClusterNetInterfaceControl(
__in HNETINTERFACE hNetInterface, _In_ HNETINTERFACE hNetInterface,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NET_INTERFACE_CONTROL)( (WINAPI * PCLUSAPI_CLUSTER_NET_INTERFACE_CONTROL)(
__in HNETINTERFACE hNetInterface, _In_ HNETINTERFACE hNetInterface,
__in_opt HNODE hHostNode, _In_opt_ HNODE hHostNode,
__in DWORD dwControlCode, _In_ DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, _In_ DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuff
__in DWORD nOutBufferSize, er,
__out_opt LPDWORD lpBytesReturned _In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster registry update and access routines // Cluster registry update and access routines
// //
#if ( !MIDL_PASS && !__midl ) #if ( !MIDL_PASS && !__midl )
HKEY HKEY
WINAPI WINAPI
GetClusterKey( GetClusterKey(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_KEY)(
HCLUSTER hCluster, HCLUSTER hCluster,
REGSAM samDesired REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterGroupKey( GetClusterGroupKey(
__in HGROUP hGroup, _In_ HGROUP hGroup,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_KEY)(
HGROUP hGroup, HGROUP hGroup,
REGSAM samDesired REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterResourceKey( GetClusterResourceKey(
__in HRESOURCE hResource, _In_ HRESOURCE hResource,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_KEY)(
HRESOURCE hResource, HRESOURCE hResource,
REGSAM samDesired REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNodeKey( GetClusterNodeKey(
__in HNODE hNode, _In_ HNODE hNode,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_NODE_KEY)(
HNODE hNode, HNODE hNode,
REGSAM samDesired REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNetworkKey( GetClusterNetworkKey(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_KEY)(
__in HNETWORK hNetwork, _In_ HNETWORK hNetwork,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNetInterfaceKey( GetClusterNetInterfaceKey(
__in HNETINTERFACE hNetInterface, _In_ HNETINTERFACE hNetInterface,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
typedef HKEY typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_KEY)( (WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_KEY)(
__in HNETINTERFACE hNetInterface, _In_ HNETINTERFACE hNetInterface,
__in REGSAM samDesired _In_ REGSAM samDesired
); );
LONG LONG
WINAPI WINAPI
ClusterRegCreateKey( ClusterRegCreateKey(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszSubKey, _In_ LPCWSTR lpszSubKey,
__in DWORD dwOptions, _In_ DWORD dwOptions,
__in REGSAM samDesired, _In_ REGSAM samDesired,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__out PHKEY phkResult, _Out_ PHKEY phkResult,
__out_opt LPDWORD lpdwDisposition _Out_opt_ LPDWORD lpdwDisposition
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_CREATE_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_CREATE_KEY)(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszSubKey, _In_ LPCWSTR lpszSubKey,
__in DWORD dwOptions, _In_ DWORD dwOptions,
__in REGSAM samDesired, _In_ REGSAM samDesired,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__out PHKEY phkResult, _Out_ PHKEY phkResult,
__out_opt LPDWORD lpdwDisposition _Out_opt_ LPDWORD lpdwDisposition
); );
LONG LONG
WINAPI WINAPI
ClusterRegOpenKey( ClusterRegOpenKey(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszSubKey, _In_ LPCWSTR lpszSubKey,
__in REGSAM samDesired, _In_ REGSAM samDesired,
__out PHKEY phkResult _Out_ PHKEY phkResult
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_OPEN_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_OPEN_KEY)(
HKEY hKey, HKEY hKey,
LPCWSTR lpszSubKey, LPCWSTR lpszSubKey,
REGSAM samDesired, REGSAM samDesired,
PHKEY phkResult PHKEY phkResult
); );
LONG LONG
WINAPI WINAPI
ClusterRegDeleteKey( ClusterRegDeleteKey(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszSubKey _In_ LPCWSTR lpszSubKey
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_KEY)(
HKEY hKey, HKEY hKey,
LPCWSTR lpszSubKey LPCWSTR lpszSubKey
); );
LONG LONG
WINAPI WINAPI
ClusterRegCloseKey( ClusterRegCloseKey(
__in HKEY hKey _In_ HKEY hKey
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_CLOSE_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_CLOSE_KEY)(
HKEY hKey HKEY hKey
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
LONG LONG
WINAPI WINAPI
ClusterRegEnumKey( ClusterRegEnumKey(
__in HKEY hKey, _In_ HKEY hKey,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName, _Inout_ LPDWORD lpcchName,
__out_opt PFILETIME lpftLastWriteTime _Out_opt_ PFILETIME lpftLastWriteTime
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_KEY)(
__in HKEY hKey, _In_ HKEY hKey,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, _Out_writes_to_(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName, _Inout_ LPDWORD lpcchName,
__out PFILETIME lpftLastWriteTime _Out_ PFILETIME lpftLastWriteTime
); );
DWORD DWORD
WINAPI WINAPI
ClusterRegSetValue( ClusterRegSetValue(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszValueName, _In_ LPCWSTR lpszValueName,
__in DWORD dwType, _In_ DWORD dwType,
__in CONST BYTE* lpData, _In_ CONST BYTE* lpData,
__in DWORD cbData _In_ DWORD cbData
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_SET_VALUE)( (WINAPI * PCLUSAPI_CLUSTER_REG_SET_VALUE)(
HKEY hKey, HKEY hKey,
LPCWSTR lpszValueName, LPCWSTR lpszValueName,
DWORD dwType, DWORD dwType,
CONST BYTE* lpData, CONST BYTE* lpData,
DWORD cbData DWORD cbData
); );
DWORD DWORD
WINAPI WINAPI
ClusterRegDeleteValue( ClusterRegDeleteValue(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszValueName _In_ LPCWSTR lpszValueName
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_VALUE)( (WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_VALUE)(
HKEY hKey, HKEY hKey,
LPCWSTR lpszValueName LPCWSTR lpszValueName
); );
LONG LONG
WINAPI WINAPI
ClusterRegQueryValue( ClusterRegQueryValue(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszValueName, _In_ LPCWSTR lpszValueName,
__out_opt LPDWORD lpdwValueType, _Out_opt_ LPDWORD lpdwValueType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData _Inout_opt_ LPDWORD lpcbData
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_VALUE)( (WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_VALUE)(
__in HKEY hKey, _In_ HKEY hKey,
__in LPCWSTR lpszValueName, _In_ LPCWSTR lpszValueName,
__out_opt LPDWORD lpdwValueType, _Out_opt_ LPDWORD lpdwValueType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData _Inout_opt_ LPDWORD lpcbData
); );
__success(return == ERROR_SUCCESS) _Success_(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterRegEnumValue( ClusterRegEnumValue(
__in HKEY hKey, _In_ HKEY hKey,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out_ecount_part(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName _Out_writes_to_(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName,
, _Inout_ LPDWORD lpcchValueName,
__inout LPDWORD lpcchValueName, _Out_opt_ LPDWORD lpdwType,
__out_opt LPDWORD lpdwType, _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) LPBYTE lpData,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, _Inout_opt_ LPDWORD lpcbData
__inout_opt LPDWORD lpcbData
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_VALUE)( (WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_VALUE)(
__in HKEY hKey, _In_ HKEY hKey,
__in DWORD dwIndex, _In_ DWORD dwIndex,
__out_ecount_part(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName _Out_writes_to_(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName,
, _Inout_ LPDWORD lpcchValueName,
__inout LPDWORD lpcchValueName, _Out_ LPDWORD lpdwType,
__out LPDWORD lpdwType, _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) LPBYTE lpData,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, _Inout_opt_ LPDWORD lpcbData
__inout_opt LPDWORD lpcbData
); );
LONG LONG
WINAPI WINAPI
ClusterRegQueryInfoKey( ClusterRegQueryInfoKey(
__in HKEY hKey, _In_ HKEY hKey,
__in LPDWORD lpcSubKeys, _In_ LPDWORD lpcSubKeys,
__in LPDWORD lpcchMaxSubKeyLen, _In_ LPDWORD lpcchMaxSubKeyLen,
__in LPDWORD lpcValues, _In_ LPDWORD lpcValues,
__in LPDWORD lpcchMaxValueNameLen, _In_ LPDWORD lpcchMaxValueNameLen,
__in LPDWORD lpcbMaxValueLen, _In_ LPDWORD lpcbMaxValueLen,
__in LPDWORD lpcbSecurityDescriptor, _In_ LPDWORD lpcbSecurityDescriptor,
__in PFILETIME lpftLastWriteTime _In_ PFILETIME lpftLastWriteTime
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_INFO_KEY)( (WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_INFO_KEY)(
HKEY hKey, HKEY hKey,
LPDWORD lpcSubKeys, LPDWORD lpcSubKeys,
LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxSubKeyLen,
LPDWORD lpcValues, LPDWORD lpcValues,
LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueNameLen,
LPDWORD lpcbMaxValueLen, LPDWORD lpcbMaxValueLen,
LPDWORD lpcbSecurityDescriptor, LPDWORD lpcbSecurityDescriptor,
PFILETIME lpftLastWriteTime PFILETIME lpftLastWriteTime
); );
LONG LONG
WINAPI WINAPI
ClusterRegGetKeySecurity ( ClusterRegGetKeySecurity (
__in HKEY hKey, _In_ HKEY hKey,
__in SECURITY_INFORMATION RequestedInformation, _In_ SECURITY_INFORMATION RequestedInformation,
__out_bcount_part(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSECURIT _Out_writes_bytes_to_(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSEC
Y_DESCRIPTOR pSecurityDescriptor, URITY_DESCRIPTOR pSecurityDescriptor,
__inout LPDWORD lpcbSecurityDescriptor _Inout_ LPDWORD lpcbSecurityDescriptor
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_GET_KEY_SECURITY)( (WINAPI * PCLUSAPI_CLUSTER_REG_GET_KEY_SECURITY)(
__in HKEY hKey, _In_ HKEY hKey,
__in SECURITY_INFORMATION RequestedInformation, _In_ SECURITY_INFORMATION RequestedInformation,
__out_bcount_part(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSECURIT _Out_writes_bytes_to_(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSEC
Y_DESCRIPTOR pSecurityDescriptor, URITY_DESCRIPTOR pSecurityDescriptor,
__inout LPDWORD lpcbSecurityDescriptor _Inout_ LPDWORD lpcbSecurityDescriptor
); );
LONG LONG
WINAPI WINAPI
ClusterRegSetKeySecurity( ClusterRegSetKeySecurity(
__in HKEY hKey, _In_ HKEY hKey,
__in SECURITY_INFORMATION SecurityInformation, _In_ SECURITY_INFORMATION SecurityInformation,
__in PSECURITY_DESCRIPTOR pSecurityDescriptor _In_ PSECURITY_DESCRIPTOR pSecurityDescriptor
); );
typedef LONG typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_SET_KEY_SECURITY)( (WINAPI * PCLUSAPI_CLUSTER_REG_SET_KEY_SECURITY)(
HKEY hKey, HKEY hKey,
SECURITY_INFORMATION SecurityInformation, SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor PSECURITY_DESCRIPTOR pSecurityDescriptor
); );
LONG
WINAPI
ClusterRegSyncDatabase(
_In_ HCLUSTER hCluster,
_In_ DWORD flags
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_SYNC_DATABASE)(
HCLUSTER hCluster,
DWORD flags
);
LONG WINAPI ClusterRegCreateBatch( LONG WINAPI ClusterRegCreateBatch(
__in_opt HKEY hKey, _In_opt_ HKEY hKey,
__out HREGBATCH* pHREGBATCH _Out_ HREGBATCH* pHREGBATCH
); );
typedef LONG typedef LONG
(WINAPI *PCLUSAPI_CLUSTER_REG_CREATE_BATCH)( (WINAPI *PCLUSAPI_CLUSTER_REG_CREATE_BATCH)(
__in_opt HKEY hKey, _In_opt_ HKEY hKey,
__out HREGBATCH* pHREGBATCH _Out_ HREGBATCH* pHREGBATCH
); );
LONG WINAPI ClusterRegBatchAddCommand( LONG WINAPI ClusterRegBatchAddCommand(
__in HREGBATCH hRegBatch, _In_ HREGBATCH hRegBatch,
__in CLUSTER_REG_COMMAND dwCommand, _In_ CLUSTER_REG_COMMAND dwCommand,
__in_opt LPCWSTR wzName, _In_opt_ LPCWSTR wzName,
__in DWORD dwOptions, _In_ DWORD dwOptions,
__in_bcount_opt(cbData) VOID CONST * lpData, _In_reads_bytes_opt_(cbData) VOID CONST * lpData,
__in DWORD cbData _In_ DWORD cbData
); );
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_BATCH_ADD_COMMAND)( (WINAPI *PCLUSTER_REG_BATCH_ADD_COMMAND)(
__in HREGBATCH hRegBatch, _In_ HREGBATCH hRegBatch,
__in CLUSTER_REG_COMMAND dwCommand, _In_ CLUSTER_REG_COMMAND dwCommand,
__in_opt LPWSTR wzName, _In_opt_ LPWSTR wzName,
__in DWORD dwOptions, _In_ DWORD dwOptions,
__in_bcount_opt(cbData) VOID CONST * lpData, _In_reads_bytes_opt_(cbData) VOID CONST * lpData,
__in DWORD cbData _In_ DWORD cbData
); );
LONG WINAPI ClusterRegCloseBatch( LONG WINAPI ClusterRegCloseBatch(
__in HREGBATCH hRegBatch, _In_ HREGBATCH hRegBatch,
__in BOOL bCommit, _In_ BOOL bCommit,
__out_opt INT * failedCommandNumber _Out_opt_ INT * failedCommandNumber
);
LONG WINAPI ClusterRegCloseBatchEx(
_In_ HREGBATCH hRegBatch,
_In_ DWORD flags,
_Out_opt_ INT * failedCommandNumber
); );
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_CLOSE_BATCH)( (WINAPI *PCLUSTER_REG_CLOSE_BATCH)(
__in HREGBATCH hRegBatch, _In_ HREGBATCH hRegBatch,
__in BOOL bCommit, _In_ BOOL bCommit,
__out_opt INT * failedCommandNumber _Out_opt_ INT * failedCommandNumber
); );
LONG WINAPI ClusterRegBatchReadCommand( LONG WINAPI ClusterRegBatchReadCommand(
__in HREGBATCHNOTIFICATION hBatchNotification, _In_ HREGBATCHNOTIFICATION hBatchNotification,
__out CLUSTER_BATCH_COMMAND * pBatchCommand); _Out_ CLUSTER_BATCH_COMMAND * pBatchCommand);
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_BATCH_READ_COMMAND)( (WINAPI *PCLUSTER_REG_BATCH_READ_COMMAND)(
__in HREGBATCHNOTIFICATION hBatchNotification, _In_ HREGBATCHNOTIFICATION hBatchNotification,
__out CLUSTER_BATCH_COMMAND * pBatchCommand); _Out_ CLUSTER_BATCH_COMMAND * pBatchCommand);
LONG WINAPI ClusterRegBatchCloseNotification( LONG WINAPI ClusterRegBatchCloseNotification(
__in HREGBATCHNOTIFICATION hBatchNotification); _In_ HREGBATCHNOTIFICATION hBatchNotification);
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_BATCH_CLOSE_NOTIFICATION)( (WINAPI *PCLUSTER_REG_BATCH_CLOSE_NOTIFICATION)(
__in HREGBATCHNOTIFICATION hBatchNotification); _In_ HREGBATCHNOTIFICATION hBatchNotification);
LONG WINAPI ClusterRegCreateBatchNotifyPort( LONG WINAPI ClusterRegCreateBatchNotifyPort(
__in HKEY hKey, _In_ HKEY hKey,
__out HREGBATCHPORT * phBatchNotifyPort); _Out_ HREGBATCHPORT * phBatchNotifyPort);
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_CREATE_BATCH_NOTIFY_PORT)( (WINAPI *PCLUSTER_REG_CREATE_BATCH_NOTIFY_PORT)(
__in HKEY hKey, _In_ HKEY hKey,
__out HREGBATCHPORT * phBatchNotifyPort); _Out_ HREGBATCHPORT * phBatchNotifyPort);
LONG WINAPI ClusterRegCloseBatchNotifyPort( LONG WINAPI ClusterRegCloseBatchNotifyPort(
__in HREGBATCHPORT hBatchNotifyPort); _In_ HREGBATCHPORT hBatchNotifyPort);
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_CLOSE_BATCH_NOTIFY_PORT)( (WINAPI *PCLUSTER_REG_CLOSE_BATCH_NOTIFY_PORT)(
__in HREGBATCHPORT hBatchNotifyPort); _In_ HREGBATCHPORT hBatchNotifyPort);
LONG WINAPI ClusterRegGetBatchNotification( LONG WINAPI ClusterRegGetBatchNotification(
__in HREGBATCHPORT hBatchNotify, _In_ HREGBATCHPORT hBatchNotify,
__out HREGBATCHNOTIFICATION * phBatchNotification); _Out_ HREGBATCHNOTIFICATION * phBatchNotification);
typedef LONG typedef LONG
(WINAPI *PCLUSTER_REG_GET_BATCH_NOTIFICATION)( (WINAPI *PCLUSTER_REG_GET_BATCH_NOTIFICATION)(
__in HREGBATCHPORT hBatchNotify, _In_ HREGBATCHPORT hBatchNotify,
__out HREGBATCHNOTIFICATION * phBatchNotification); _Out_ HREGBATCHNOTIFICATION * phBatchNotification);
LONG WINAPI ClusterRegCreateReadBatch(
_In_ HKEY hKey,
_Out_ HREGREADBATCH* phRegReadBatch);
typedef LONG
(WINAPI *PCLUSTER_REG_CREATE_READ_BATCH)(
_In_ HKEY hKey,
_Out_ HREGREADBATCH* phRegReadBatch);
LONG WINAPI ClusterRegReadBatchAddCommand(
_In_ HREGREADBATCH hRegReadBatch,
_In_ LPCWSTR wzSubkeyName,
_In_ LPCWSTR wzValueName);
typedef LONG
(WINAPI *PCLUSTER_REG_READ_BATCH_ADD_COMMAND)(
_In_ HREGREADBATCH hRegReadBatch,
_In_ LPCWSTR wzSubkeyName,
_In_ LPCWSTR wzValueName);
LONG WINAPI ClusterRegCloseReadBatch(
_In_ HREGREADBATCH hRegReadBatch,
_Out_ HREGREADBATCHREPLY * phRegReadBatchReply);
typedef LONG
(WINAPI *PCLUSTER_REG_CLOSE_READ_BATCH)(
_In_ HREGREADBATCH hRegReadBatch,
_Out_ HREGREADBATCHREPLY * phRegReadBatchReply);
LONG WINAPI ClusterRegReadBatchReplyNextCommand(
_In_ HREGREADBATCHREPLY hRegReadBatchReply,
_Out_ CLUSTER_READ_BATCH_COMMAND * pBatchCommand);
typedef LONG
(WINAPI *PCLUSTER_REG_READ_BATCH_REPLY_NEXT_COMMAND)(
_In_ HREGREADBATCHREPLY hRegReadBatchReply,
_Out_ CLUSTER_READ_BATCH_COMMAND * pBatchCommand);
LONG WINAPI ClusterRegCloseReadBatchReply(
_In_ HREGREADBATCHREPLY hRegReadBatchReply);
typedef LONG
(WINAPI *PCLUSTER_REG_CLOSE_READ_BATCH_REPLY)(
_In_ HREGREADBATCHREPLY hRegReadBatchReply);
// //
// Cluster Create, Add Node and Destroy Cluster APIs // Cluster Create, Add Node and Destroy Cluster APIs
// //
// //
// Phases that cluster setup operations through. // Phases that cluster setup operations through.
// Phase numbers may arrive in any order via the callback function. // Phase numbers may arrive in any order via the callback function.
// //
skipping to change at line 4483 skipping to change at line 5539
} CLUSTER_SETUP_PHASE; } CLUSTER_SETUP_PHASE;
// //
// used to delineate between phases // used to delineate between phases
// //
typedef enum _CLUSTER_SETUP_PHASE_TYPE { typedef enum _CLUSTER_SETUP_PHASE_TYPE {
ClusterSetupPhaseStart = 1, ClusterSetupPhaseStart = 1,
ClusterSetupPhaseContinue = 2, ClusterSetupPhaseContinue = 2,
ClusterSetupPhaseEnd = 3 ClusterSetupPhaseEnd = 3,
ClusterSetupPhaseReport = 4
} CLUSTER_SETUP_PHASE_TYPE; } CLUSTER_SETUP_PHASE_TYPE;
typedef enum _CLUSTER_SETUP_PHASE_SEVERITY { typedef enum _CLUSTER_SETUP_PHASE_SEVERITY {
ClusterSetupPhaseInformational = 1, ClusterSetupPhaseInformational = 1,
ClusterSetupPhaseWarning = 2, ClusterSetupPhaseWarning = 2,
ClusterSetupPhaseFatal = 3 ClusterSetupPhaseFatal = 3
} CLUSTER_SETUP_PHASE_SEVERITY; } CLUSTER_SETUP_PHASE_SEVERITY;
typedef BOOL typedef BOOL
(WINAPI *PCLUSTER_SETUP_PROGRESS_CALLBACK)( (WINAPI *PCLUSTER_SETUP_PROGRESS_CALLBACK)(
PVOID pvCallbackArg, PVOID pvCallbackArg,
CLUSTER_SETUP_PHASE eSetupPhase, CLUSTER_SETUP_PHASE eSetupPhase,
CLUSTER_SETUP_PHASE_TYPE ePhaseType, CLUSTER_SETUP_PHASE_TYPE ePhaseType,
CLUSTER_SETUP_PHASE_SEVERITY ePhaseSeverity, CLUSTER_SETUP_PHASE_SEVERITY ePhaseSeverity,
DWORD dwPercentComplete, DWORD dwPercentComplete,
__in_opt PCWSTR lpszObjectName, _In_opt_ PCWSTR lpszObjectName,
DWORD dwStatus ); DWORD dwStatus );
HCLUSTER HCLUSTER
WINAPI WINAPI
CreateCluster( CreateCluster(
__in PCREATE_CLUSTER_CONFIG pConfig, _In_ PCREATE_CLUSTER_CONFIG pConfig,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg _In_opt_ PVOID pvCallbackArg
); );
typedef HCLUSTER typedef HCLUSTER
(WINAPI * PCLUSAPI_CREATE_CLUSTER)( (WINAPI * PCLUSAPI_CREATE_CLUSTER)(
__in PCREATE_CLUSTER_CONFIG pConfig, _In_ PCREATE_CLUSTER_CONFIG pConfig,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg _In_opt_ PVOID pvCallbackArg
); );
HNODE HNODE
WINAPI WINAPI
AddClusterNode( AddClusterNode(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in PCWSTR lpszNodeName, _In_ PCWSTR lpszNodeName,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg _In_opt_ PVOID pvCallbackArg
); );
typedef HNODE typedef HNODE
(WINAPI * PCLUSAPI_ADD_CLUSTER_NODE)( (WINAPI * PCLUSAPI_ADD_CLUSTER_NODE)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in PCWSTR lpszNodeName, _In_ PCWSTR lpszNodeName,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg _In_opt_ PVOID pvCallbackArg
); );
DWORD DWORD
WINAPI WINAPI
DestroyCluster( DestroyCluster(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg, _In_opt_ PVOID pvCallbackArg,
__in BOOL fdeleteVirtualComputerObjects _In_ BOOL fdeleteVirtualComputerObjects
); );
typedef DWORD typedef DWORD
(WINAPI * PCLUSAPI_DESTROY_CLUSTER)( (WINAPI * PCLUSAPI_DESTROY_CLUSTER)(
__in HCLUSTER hCluster, _In_ HCLUSTER hCluster,
__in_opt PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback, _In_opt_ PCLUSTER_SETUP_PROGRESS_CALLBACK pfnProgressCallback,
__in_opt PVOID pvCallbackArg, _In_opt_ PVOID pvCallbackArg,
__in BOOL fdeleteVirtualComputerObjects _In_ BOOL fdeleteVirtualComputerObjects
); );
// //
// Standard Resource Type Names // Standard Resource Type Names, these are duplicated in resapi.w's CLUSTER_ROLE
struct. Be sure
// to update that struct when adding restype names.
// //
#define CLUS_RESTYPE_NAME_GENAPP L"Generic Application" #define CLUS_RESTYPE_NAME_GENAPP L"Generic Application"
#define CLUS_RESTYPE_NAME_GENSVC L"Generic Service" #define CLUS_RESTYPE_NAME_GENSVC L"Generic Service"
#define CLUS_RESTYPE_NAME_GENSCRIPT L"Generic Script" #define CLUS_RESTYPE_NAME_GENSCRIPT L"Generic Script"
#define CLUS_RESTYPE_NAME_IPADDR L"IP Address" #define CLUS_RESTYPE_NAME_IPADDR L"IP Address"
#define CLUS_RESTYPE_NAME_NETNAME L"Network Name" #define CLUS_RESTYPE_NAME_NETNAME L"Network Name"
#define CLUS_RESTYPE_NAME_FILESHR L"File Share" #define CLUS_RESTYPE_NAME_DNN L"Distributed Network Name"
#define CLUS_RESTYPE_NAME_PRTSPLR L"Print Spooler" #define CLUS_RESTYPE_NAME_FILESHR L"File Share"
#define CLUS_RESTYPE_NAME_IPV6_NATIVE L"IPv6 Address" #define CLUS_RESTYPE_NAME_PRTSPLR L"Print Spooler"
#define CLUS_RESTYPE_NAME_IPV6_TUNNEL L"IPv6 Tunnel Address" #define CLUS_RESTYPE_NAME_IPV6_NATIVE L"IPv6 Address"
#define CLUS_RESTYPE_NAME_VSSTASK L"Volume Shadow Copy Service Task" #define CLUS_RESTYPE_NAME_IPV6_TUNNEL L"IPv6 Tunnel Address"
#define CLUS_RESTYPE_NAME_WINS L"WINS Service" #define CLUS_RESTYPE_NAME_VSSTASK L"Volume Shadow Copy Service Tas
#define CLUS_RESTYPE_NAME_DHCP L"DHCP Service" k"
#define CLUS_RESTYPE_NAME_MSMQ L"Microsoft Message Queue Server" #define CLUS_RESTYPE_NAME_WINS L"WINS Service"
#define CLUS_RESTYPE_NAME_NEW_MSMQ L"MSMQ" #define CLUS_RESTYPE_NAME_DHCP L"DHCP Service"
#define CLUS_RESTYPE_NAME_MSMQ_TRIGGER L"MSMQTriggers" #define CLUS_RESTYPE_NAME_MSMQ L"Microsoft Message Queue Server
#define CLUS_RESTYPE_NAME_MSDTC L"Distributed Transaction Coordinato "
r" #define CLUS_RESTYPE_NAME_NEW_MSMQ L"MSMQ"
#define CLUS_RESTYPE_NAME_NFS L"NFS Share" #define CLUS_RESTYPE_NAME_MSMQ_TRIGGER L"MSMQTriggers"
#define CLUS_RESTYPE_NAME_ISNS L"Microsoft iSNS" #define CLUS_RESTYPE_NAME_MSDTC L"Distributed Transaction Coordi
#define CLUS_RESTYPE_NAME_HARDDISK L"Physical Disk" nator"
#define CLUS_RESTYPE_NAME_PHYS_DISK CLUS_RESTYPE_NAME_HARDDISK #define CLUS_RESTYPE_NAME_NFS L"NFS Share"
#define CLUS_RESTYPE_NAME_FSWITNESS L"File Share Witness" #define CLUS_RESTYPE_NAME_NETWORK_FILE_SYSTEM L"Network File System"
#define CLUS_RESTYPE_NAME_FILESERVER L"File Server" #define CLUS_RESTYPE_NAME_ISNS L"Microsoft iSNS"
#define CLUS_RESTYPE_NAME_DFS L"Distributed File System" #define CLUS_RESTYPE_NAME_HARDDISK L"Physical Disk"
#define CLUS_RESTYPE_NAME_DFSR L"DFS Replicated Folder" #define CLUS_RESTYPE_NAME_PHYS_DISK CLUS_RESTYPE_NAME_HARDDISK
#define CLUS_RESTYPE_NAME_VM L"Virtual Machine" #define CLUS_RESTYPE_NAME_FSWITNESS L"File Share Witness"
#define CLUS_RESTYPE_NAME_VM_CONFIG L"Virtual Machine Configuration" #define CLUS_RESTYPE_NAME_FILESERVER L"File Server"
#define CLUS_RESTYPE_NAME_SODAFILESERVER L"Scale Out File Server"
#define CLUS_RESTYPE_NAME_DFS L"Distributed File System"
#define CLUS_RESTYPE_NAME_DFSR L"DFS Replicated Folder"
#define CLUS_RESTYPE_NAME_VM L"Virtual Machine"
#define CLUS_RESTYPE_NAME_VM_CONFIG L"Virtual Machine Configuration"
#define CLUS_RESTYPE_NAME_ISCSITARGET L"iSCSI Target Server"
#define CLUS_RESTYPE_NAME_STORAGE_POOL L"Storage Pool"
#define CLUS_RESTYPE_NAME_TASKSCHEDULER L"Task Scheduler"
#define CLUS_RESTYPE_NAME_VMREPLICA_BROKER L"Virtual Machine Replication Br
oker"
#define CLUS_RESTYPE_NAME_NFS_V2 L"Network File System"
#define CLUS_RESTYPE_NAME_CAU L"ClusterAwareUpdatingResource"
#define CLUS_RESTYPE_NAME_NV_PROVIDER_ADDRESS L"Provider Address"
#define CLUS_RESTYPE_NAME_NAT L"Nat"
#define CLUS_RESTYPE_NAME_VIRTUAL_IPV4 L"Disjoint IPv4 Address"
#define CLUS_RESTYPE_NAME_VIRTUAL_IPV6 L"Disjoint IPv6 Address"
// //
// Cluster common property names // Cluster common property names
// //
#define CLUSREG_NAME_CLUS_DESC L"Description" #define CLUSREG_NAME_CLUS_DESC L"Description"
#define CLUSREG_NAME_CLUS_SD L"Security Descriptor" #define CLUSREG_NAME_CLUS_SD L"Security Descriptor"
#define CLUSREG_NAME_CLUS_DEFAULT_NETWORK_ROLE L"DefaultNetworkRole" #define CLUSREG_NAME_CLUS_DEFAULT_NETWORK_ROLE L"DefaultNetworkRole"
#define CLUSREG_NAME_QUORUM_ARBITRATION_TIMEOUT L"QuorumArbitrationTimeMax" #define CLUSREG_NAME_QUORUM_ARBITRATION_TIMEOUT L"QuorumArbitrationTimeMax"
#define CLUSTER_HANG_TIMEOUT_KEYNAME L"ClusSvcHangTimeout" #define CLUSTER_HANG_TIMEOUT_KEYNAME L"ClusSvcHangTimeout"
#define CLUSTER_HANG_RECOVERY_ACTION_KEYNAME L"HangRecoveryAction" #define CLUSTER_HANG_RECOVERY_ACTION_KEYNAME L"HangRecoveryAction"
#define CLUSTER_CSA_VSS_STATE L"BackupInProgress" #define CLUSTER_CSA_VSS_STATE L"BackupInProgress"
#define CLUSTER_REQUEST_REPLY_TIMEOUT L"RequestReplyTimeout" #define CLUSTER_REQUEST_REPLY_TIMEOUT L"RequestReplyTimeout"
#define CLUSTER_WITNESS_FAILED_RESTART_INTERVAL L"WitnessRestartInterval" #define CLUSTER_WITNESS_FAILED_RESTART_INTERVAL L"WitnessRestartInterval"
#define CLUSTER_WITNESS_DATABASE_WRITE_TIMEOUT L"WitnessDatabaseWriteTimeout" #define CLUSTER_WITNESS_DATABASE_WRITE_TIMEOUT L"WitnessDatabaseWriteTimeout
#define CLUSTER_ADD_EVICT_DELAY L"AddEvictDelay" "
#define CLUSREG_NAME_FIXQUORUM L"FixQuorum" #define CLUSTER_ADD_EVICT_DELAY L"AddEvictDelay"
#define CLUSREG_NAME_IGNORE_PERSISTENT_STATE L"IgnorePersistentStateOnStart #define CLUSREG_NAME_FIXQUORUM L"FixQuorum"
up" #define CLUSREG_NAME_PREVENTQUORUM L"PreventQuorum"
#define CLUSTER_SHARED_VOLUMES_ROOT L"SharedVolumesRoot" #define CLUSREG_NAME_IGNORE_PERSISTENT_STATE L"IgnorePersistentStateOnStar
#define ENABLE_CLUSTER_SHARED_VOLUMES L"EnableSharedVolumes" tup"
#define CLUSTER_CSV_COMPATIBLE_FILTERS L"SharedVolumeCompatibleFilter #define CLUSTER_SHARED_VOLUMES_ROOT L"SharedVolumesRoot"
s" #define ENABLE_CLUSTER_SHARED_VOLUMES L"EnableSharedVolumes"
#define CLUSTER_CSV_INCOMPATIBLE_FILTERS L"SharedVolumeIncompatibleFilt #define CLUSTER_SHARED_VOLUME_VSS_WRITER_OPERATION_TIMEOUT L"SharedVolumeVssWr
ers" iterOperationTimeout"
#define CLUSTER_GROUP_WAIT_DELAY L"ClusterGroupWaitDelay" #define USE_CLIENT_ACCESS_NETWORKS_FOR_CSV L"UseClientAccessNetworksForS
#define CLUSREG_NAME_SHUTDOWN_TIMEOUT_MINUTES L"ShutdownTimeoutInMinutes" haredVolumes"
#define CLUSTER_CSV_COMPATIBLE_FILTERS L"SharedVolumeCompatibleFilte
rs"
#define CLUSTER_CSV_INCOMPATIBLE_FILTERS L"SharedVolumeIncompatibleFil
ters"
#define CLUSTER_GROUP_WAIT_DELAY L"ClusterGroupWaitDelay"
#define MINIMUM_PREEMPTOR_PRIORITY L"MinimumPreemptorPriority"
#define MINIMUM_NEVER_PREEMPT_PRIORITY L"MinimumNeverPreemptPriority
"
#define CLUSTER_ENFORCED_ANTIAFFINITY L"ClusterEnforcedAntiaffinity
"
#define CLUSREG_NAME_SHUTDOWN_TIMEOUT_MINUTES L"ShutdownTimeoutInMinutes"
#define CLUSREG_NAME_CSV_MDS_SD L"SharedVolumeSecurityDescrip
tor"
#define CLUSREG_NAME_FAILOVER_MOVE_MIGRATION_TYPE L"FailoverMoveMigrationType"
#define CLUSREG_NAME_CSV_BLOCK_CACHE L"BlockCacheSize"
#define CLUSREG_NAME_ROUTE_HISTORY_LENGTH L"RouteHistoryLength"
#define CLUSREG_NAME_LAST_RECENT_EVENTS_RESET_TIME L"RecentEventsResetTime"
#define CLUSREG_NAME_DRAIN_ON_SHUTDOWN L"DrainOnShutdown"
#define CLUSREG_NAME_NETFT_IPSEC_ENABLED L"NetftIPSecEnabled"
#define CLUSREG_NAME_WITNESS_DYNAMIC_WEIGHT L"WitnessDynamicWeight"
#define CLUSREG_NAME_MESSAGE_BUFFER_LENGTH L"MessageBufferLength"
#define CLUSREG_NAME_DATABASE_READ_WRITE_MODE L"DatabaseReadWriteMode"
// //
// Properties and defaults for single and multi subnet delays and thresholds. // Properties and defaults for single and multi subnet delays and thresholds.
// //
#define CLUSREG_NAME_SAME_SUBNET_DELAY L"SameSubnetDelay" #define CLUSREG_NAME_SAME_SUBNET_DELAY L"SameSubnetDelay"
#define CLUSREG_NAME_CROSS_SUBNET_DELAY L"CrossSubnetDelay" #define CLUSREG_NAME_CROSS_SUBNET_DELAY L"CrossSubnetDelay"
#define CLUSREG_NAME_SAME_SUBNET_THRESHOLD L"SameSubnetThreshold" #define CLUSREG_NAME_SAME_SUBNET_THRESHOLD L"SameSubnetThreshold"
#define CLUSREG_NAME_PLUMB_ALL_CROSS_SUBNET_ROUTES L"PlumbAllCrossSubnetRoutes" #define CLUSREG_NAME_PLUMB_ALL_CROSS_SUBNET_ROUTES L"PlumbAllCrossSubnetRoutes"
#define CLUSREG_NAME_CROSS_SUBNET_THRESHOLD L"CrossSubnetThreshold" #define CLUSREG_NAME_CROSS_SUBNET_THRESHOLD L"CrossSubnetThreshold"
skipping to change at line 4631 skipping to change at line 5718
// //
#define CLUSREG_NAME_NODE_NAME L"NodeName" #define CLUSREG_NAME_NODE_NAME L"NodeName"
#define CLUSREG_NAME_NODE_HIGHEST_VERSION L"NodeHighestVersion" #define CLUSREG_NAME_NODE_HIGHEST_VERSION L"NodeHighestVersion"
#define CLUSREG_NAME_NODE_LOWEST_VERSION L"NodeLowestVersion" #define CLUSREG_NAME_NODE_LOWEST_VERSION L"NodeLowestVersion"
#define CLUSREG_NAME_NODE_DESC L"Description" #define CLUSREG_NAME_NODE_DESC L"Description"
#define CLUSREG_NAME_NODE_MAJOR_VERSION L"MajorVersion" #define CLUSREG_NAME_NODE_MAJOR_VERSION L"MajorVersion"
#define CLUSREG_NAME_NODE_MINOR_VERSION L"MinorVersion" #define CLUSREG_NAME_NODE_MINOR_VERSION L"MinorVersion"
#define CLUSREG_NAME_NODE_BUILD_NUMBER L"BuildNumber" #define CLUSREG_NAME_NODE_BUILD_NUMBER L"BuildNumber"
#define CLUSREG_NAME_NODE_CSDVERSION L"CSDVersion" #define CLUSREG_NAME_NODE_CSDVERSION L"CSDVersion"
#define CLUSREG_NAME_NODE_WEIGHT L"NodeWeight"
#define CLUSREG_NAME_NODE_DYNAMIC_WEIGHT L"DynamicWeight"
#define CLUSREG_NAME_NODE_IS_PRIMARY L"IsPrimary"
#define CLUSREG_NAME_NODE_DRAIN_STATUS L"NodeDrainStatus"
#define CLUSREG_NAME_NODE_DRAIN_TARGET L"NodeDrainTarget"
#define CLUSREG_NAME_NODE_NEEDS_PQ L"NeedsPreventQuorum"
// //
// Group common property names // Group common property names
// //
#define CLUSREG_NAME_GRP_NAME L"Name" #define CLUSREG_NAME_GRP_NAME L"Name"
#define CLUSREG_NAME_GRP_DESC L"Description" #define CLUSREG_NAME_GRP_TYPE L"GroupType"
#define CLUSREG_NAME_GRP_PERSISTENT_STATE L"PersistentState" #define CLUSREG_NAME_GRP_DESC L"Description"
#define CLUSREG_NAME_GRP_FAILBACK_TYPE L"AutoFailbackType" #define CLUSREG_NAME_GRP_PERSISTENT_STATE L"PersistentState"
#define CLUSREG_NAME_GRP_FAILBACK_WIN_START L"FailbackWindowStart" #define CLUSREG_NAME_GRP_FAILBACK_TYPE L"AutoFailbackType"
#define CLUSREG_NAME_GRP_FAILBACK_WIN_END L"FailbackWindowEnd" #define CLUSREG_NAME_GRP_FAILBACK_WIN_START L"FailbackWindowStart
#define CLUSREG_NAME_GRP_FAILOVER_THRESHOLD L"FailoverThreshold" "
#define CLUSREG_NAME_GRP_FAILOVER_PERIOD L"FailoverPeriod" #define CLUSREG_NAME_GRP_FAILBACK_WIN_END L"FailbackWindowEnd"
#define CLUSREG_NAME_GRP_PRIORITY L"Priority" #define CLUSREG_NAME_GRP_FAILOVER_THRESHOLD L"FailoverThreshold"
#define CLUSREG_NAME_GRP_DEFAULT_OWNER L"DefaultOwner" #define CLUSREG_NAME_GRP_FAILOVER_PERIOD L"FailoverPeriod"
#define CLUSREG_NAME_GRP_PRIORITY L"Priority"
#define CLUSREG_NAME_GRP_ANTI_AFFINITY_CLASS_NAME L"AntiAffinityClassNames" #define CLUSREG_NAME_GRP_DEFAULT_OWNER L"DefaultOwner"
#define CLUSREG_NAME_GRP_STATUS_INFORMATION L"StatusInformation"
#define CLUSREG_NAME_GRP_ANTI_AFFINITY_CLASS_NAME L"AntiAffinityClassNa
mes"
#define CLUSREG_NAME_GRP_START_DELAY L"GroupStartDelay"
// //
// Resource common property names // Resource common property names
// //
#define CLUSREG_NAME_RES_NAME L"Name" #define CLUSREG_NAME_RES_NAME L"Name"
#define CLUSREG_NAME_RES_TYPE L"Type" #define CLUSREG_NAME_RES_TYPE L"Type"
#define CLUSREG_NAME_RES_DESC L"Description" #define CLUSREG_NAME_RES_DESC L"Description"
#define CLUSREG_NAME_RES_SEPARATE_MONITOR L"SeparateMonitor" #define CLUSREG_NAME_RES_SEPARATE_MONITOR L"SeparateMonitor"
#define CLUSREG_NAME_RES_PERSISTENT_STATE L"PersistentState" #define CLUSREG_NAME_RES_PERSISTENT_STATE L"PersistentState"
#define CLUSREG_NAME_RES_LOOKS_ALIVE L"LooksAlivePollInterval" #define CLUSREG_NAME_RES_LOOKS_ALIVE L"LooksAlivePollInter
#define CLUSREG_NAME_RES_IS_ALIVE L"IsAlivePollInterval" val"
#define CLUSREG_NAME_RES_RESTART_ACTION L"RestartAction" #define CLUSREG_NAME_RES_IS_ALIVE L"IsAlivePollInterval
#define CLUSREG_NAME_RES_RESTART_THRESHOLD L"RestartThreshold" "
#define CLUSREG_NAME_RES_RESTART_PERIOD L"RestartPeriod" #define CLUSREG_NAME_RES_RESTART_ACTION L"RestartAction"
#define CLUSREG_NAME_RES_RESTART_DELAY L"RestartDelay" #define CLUSREG_NAME_RES_RESTART_THRESHOLD L"RestartThreshold"
#define CLUSREG_NAME_RES_RETRY_PERIOD_ON_FAILURE L"RetryPeriodOnFailure" #define CLUSREG_NAME_RES_RESTART_PERIOD L"RestartPeriod"
#define CLUSREG_NAME_RES_PENDING_TIMEOUT L"PendingTimeout" #define CLUSREG_NAME_RES_RESTART_DELAY L"RestartDelay"
#define CLUSREG_NAME_RES_DEADLOCK_TIMEOUT L"DeadlockTimeout" #define CLUSREG_NAME_RES_RETRY_PERIOD_ON_FAILURE L"RetryPeriodOnFailur
#define CLUSREG_NAME_RES_MONITOR_PID L"MonitorProcessId" e"
#define CLUSREG_NAME_RES_STATUS L"ResourceSpecificStatus" #define CLUSREG_NAME_RES_EMBEDDED_FAILURE_ACTION L"EmbeddedFailureActi
on"
#define CLUSREG_NAME_RES_PENDING_TIMEOUT L"PendingTimeout"
#define CLUSREG_NAME_RES_DEADLOCK_TIMEOUT L"DeadlockTimeout"
#define CLUSREG_NAME_RES_MONITOR_PID L"MonitorProcessId"
#define CLUSREG_NAME_RES_STATUS_INFORMATION L"StatusInformation"
#define CLUSREG_NAME_RES_LAST_OPERATION_STATUS_CODE L"LastOperationStatus
Code"
#define CLUSREG_NAME_RES_DATA1 L"ResourceSpecificDat
a1"
#define CLUSREG_NAME_RES_DATA2 L"ResourceSpecificDat
a2"
#define CLUSREG_NAME_RES_STATUS L"ResourceSpecificSta
tus"
// //
// Resource Type common property names // Resource Type common property names
// //
#define CLUSREG_NAME_RESTYPE_NAME L"Name" #define CLUSREG_NAME_RESTYPE_NAME L"Name"
#define CLUSREG_NAME_RESTYPE_DESC L"Description" #define CLUSREG_NAME_RESTYPE_DESC L"Description"
#define CLUSREG_NAME_RESTYPE_DLL_NAME L"DllName" #define CLUSREG_NAME_RESTYPE_DLL_NAME L"DllName"
#define CLUSREG_NAME_RESTYPE_ADMIN_EXTENSIONS L"AdminExtensions" #define CLUSREG_NAME_RESTYPE_ADMIN_EXTENSIONS L"AdminExtensions"
#define CLUSREG_NAME_RESTYPE_LOOKS_ALIVE CLUSREG_NAME_RES_LOOKS_ALIVE #define CLUSREG_NAME_RESTYPE_LOOKS_ALIVE CLUSREG_NAME_RES_LOOKS_ALIVE
skipping to change at line 4696 skipping to change at line 5796
#define CLUSREG_NAME_NET_NAME L"Name" #define CLUSREG_NAME_NET_NAME L"Name"
#define CLUSREG_NAME_NET_IPV6_ADDRESSES L"IPv6Addresses" #define CLUSREG_NAME_NET_IPV6_ADDRESSES L"IPv6Addresses"
#define CLUSREG_NAME_NET_IPV6_PREFIXLENGTHS L"IPv6PrefixLengths" #define CLUSREG_NAME_NET_IPV6_PREFIXLENGTHS L"IPv6PrefixLengths"
#define CLUSREG_NAME_NET_IPV4_ADDRESSES L"IPv4Addresses" #define CLUSREG_NAME_NET_IPV4_ADDRESSES L"IPv4Addresses"
#define CLUSREG_NAME_NET_IPV4_PREFIXLENGTHS L"IPv4PrefixLengths" #define CLUSREG_NAME_NET_IPV4_PREFIXLENGTHS L"IPv4PrefixLengths"
#define CLUSREG_NAME_NET_ADDRESS L"Address" #define CLUSREG_NAME_NET_ADDRESS L"Address"
#define CLUSREG_NAME_NET_ADDRESS_MASK L"AddressMask" #define CLUSREG_NAME_NET_ADDRESS_MASK L"AddressMask"
#define CLUSREG_NAME_NET_DESC L"Description" #define CLUSREG_NAME_NET_DESC L"Description"
#define CLUSREG_NAME_NET_ROLE L"Role" #define CLUSREG_NAME_NET_ROLE L"Role"
#define CLUSREG_NAME_NET_SPEED L"LinkSpeed"
#define CLUSREG_NAME_NET_RDMA_CAPABLE L"RdmaCapable"
#define CLUSREG_NAME_NET_RSS_CAPABLE L"RssCapable"
#define CLUSREG_NAME_NET_METRIC L"Metric" #define CLUSREG_NAME_NET_METRIC L"Metric"
#define CLUSREG_NAME_NET_AUTOMETRIC L"AutoMetric" #define CLUSREG_NAME_NET_AUTOMETRIC L"AutoMetric"
// //
// Network Interface common property names // Network Interface common property names
// //
#define CLUSREG_NAME_NETIFACE_NAME L"Name" #define CLUSREG_NAME_NETIFACE_NAME L"Name"
#define CLUSREG_NAME_NETIFACE_NODE L"Node" #define CLUSREG_NAME_NETIFACE_NODE L"Node"
#define CLUSREG_NAME_NETIFACE_NETWORK L"Network" #define CLUSREG_NAME_NETIFACE_NETWORK L"Network"
skipping to change at line 4719 skipping to change at line 5822
#define CLUSREG_NAME_NETIFACE_IPV6_ADDRESSES L"IPv6Addresses" #define CLUSREG_NAME_NETIFACE_IPV6_ADDRESSES L"IPv6Addresses"
#define CLUSREG_NAME_NETIFACE_IPV4_ADDRESSES L"IPv4Addresses" #define CLUSREG_NAME_NETIFACE_IPV4_ADDRESSES L"IPv4Addresses"
#define CLUSREG_NAME_NETIFACE_ADDRESS L"Address" #define CLUSREG_NAME_NETIFACE_ADDRESS L"Address"
#define CLUSREG_NAME_NETIFACE_DESC L"Description" #define CLUSREG_NAME_NETIFACE_DESC L"Description"
// //
// Resource private property names // Resource private property names
// //
// //
// Common to All Resources interested in using Cluster Awareness of Application
Memory Usage
//
#define CLUSREG_NAME_START_MEMORY L"StartMemory"
#define CLUSREG_NAME_VIRTUAL_NUMA_COUNT L"VirtualNumaCount"
//
// Physical Disk // Physical Disk
// //
#define CLUSREG_NAME_PHYSDISK_DISKIDTYPE L"DiskIdType" #define CLUSREG_NAME_PHYSDISK_DISKIDTYPE L"DiskIdType"
#define CLUSREG_NAME_PHYSDISK_DISKSIGNATURE L"DiskSignature" #define CLUSREG_NAME_PHYSDISK_DISKSIGNATURE L"DiskSignature"
#define CLUSREG_NAME_PHYSDISK_DISKIDGUID L"DiskIdGuid" #define CLUSREG_NAME_PHYSDISK_DISKIDGUID L"DiskIdGuid"
#define CLUSREG_NAME_PHYSDISK_DISKRUNCHKDSK L"DiskRunChkDsk" #define CLUSREG_NAME_PHYSDISK_DISKRUNCHKDSK L"DiskRunChkDsk"
#define CLUSREG_NAME_PHYSDISK_DISKUNIQUEIDS L"DiskUniqueIds" #define CLUSREG_NAME_PHYSDISK_DISKUNIQUEIDS L"DiskUniqueIds"
#define CLUSREG_NAME_PHYSDISK_DISKVOLUMEINFO L"DiskVolumeInfo" #define CLUSREG_NAME_PHYSDISK_DISKVOLUMEINFO L"DiskVolumeInfo"
#define CLUSREG_NAME_PHYSDISK_DISKARBTYPE L"DiskArbType" #define CLUSREG_NAME_PHYSDISK_DISKARBTYPE L"DiskArbType"
#define CLUSREG_NAME_PHYSDISK_DISKARBINTERVAL L"DiskArbInterval" #define CLUSREG_NAME_PHYSDISK_DISKARBINTERVAL L"DiskArbInterval"
#define CLUSREG_NAME_PHYSDISK_DISKPATH L"DiskPath" #define CLUSREG_NAME_PHYSDISK_DISKPATH L"DiskPath"
#define CLUSREG_NAME_PHYSDISK_DISKRELOAD L"DiskReload" #define CLUSREG_NAME_PHYSDISK_DISKRELOAD L"DiskReload"
#define CLUSREG_NAME_PHYSDISK_MAINTMODE L"MaintenanceMode" #define CLUSREG_NAME_PHYSDISK_MAINTMODE L"MaintenanceMode"
#define CLUSREG_NAME_PHYSDISK_DISKIODELAY L"MaxIoLatency" #define CLUSREG_NAME_PHYSDISK_DISKIODELAY L"MaxIoLatency"
#define CLUSREG_NAME_PHYSDISK_MIGRATEFIXUP L"MigrateDriveLetters" #define CLUSREG_NAME_PHYSDISK_MIGRATEFIXUP L"MigrateDriveLetters"
#define CLUSREG_NAME_PHYSDISK_CSVWRITETHROUGH L"CsvEnforceWriteThrough" #define CLUSREG_NAME_PHYSDISK_CSVWRITETHROUGH L"CsvEnforceWriteThrough"
#define CLUSREG_NAME_PHYSDISK_PNPUPDATE L"DiskPnpUpdate" #define CLUSREG_NAME_PHYSDISK_CSVBLOCKCACHE L"EnableBlockCache"
#define CLUSREG_NAME_PHYSDISK_SPACEIDGUID L"VirtualDiskId"
#define CLUSREG_NAME_STORAGESPACE_POOLIDGUID L"PoolId"
#define CLUSREG_NAME_PHYSDISK_CSVSNAPSHOTDIFFAREASIZE L"SnapshotDiffSize"
#define CLUSREG_NAME_PHYSDISK_CSVSNAPSHOTAGELIMIT L"SnapshotAgeLimit"
#define CLUSREG_NAME_STORAGESPACE_NAME L"VirtualDiskName"
#define CLUSREG_NAME_STORAGESPACE_DESCRIPTION L"VirtualDiskDescription
"
#define CLUSREG_NAME_STORAGESPACE_HEALTH L"VirtualDiskHealth"
#define CLUSREG_NAME_STORAGESPACE_STATE L"VirtualDiskState"
#define CLUSREG_NAME_STORAGESPACE_PROVISIONING L"VirtualDiskProvisionin
g"
#define CLUSREG_NAME_STORAGESPACE_RESILIENCYTYPE L"VirtualDiskResiliencyT
ype"
#define CLUSREG_NAME_STORAGESPACE_RESILIENCYCOLUMNS L"VirtualDiskResiliencyC
olumns"
#define CLUSREG_NAME_STORAGESPACE_RESILIENCYINTERLEAVE L"VirtualDiskResiliencyI
nterleave"
// //
// Generic Application // Generic Application
// //
#define CLUSREG_NAME_GENAPP_COMMAND_LINE L"CommandLine" #define CLUSREG_NAME_GENAPP_COMMAND_LINE L"CommandLine"
#define CLUSREG_NAME_GENAPP_CURRENT_DIRECTORY L"CurrentDirectory" #define CLUSREG_NAME_GENAPP_CURRENT_DIRECTORY L"CurrentDirectory"
#define CLUSREG_NAME_GENAPP_USE_NETWORK_NAME L"UseNetworkName" #define CLUSREG_NAME_GENAPP_USE_NETWORK_NAME L"UseNetworkName"
// //
skipping to change at line 4764 skipping to change at line 5886
// //
#define CLUSREG_NAME_GENSVC_SERVICE_NAME L"ServiceName" #define CLUSREG_NAME_GENSVC_SERVICE_NAME L"ServiceName"
#define CLUSREG_NAME_GENSVC_STARTUP_PARAMS L"StartupParameters" #define CLUSREG_NAME_GENSVC_STARTUP_PARAMS L"StartupParameters"
#define CLUSREG_NAME_GENSVC_USE_NETWORK_NAME L"UseNetworkName" #define CLUSREG_NAME_GENSVC_USE_NETWORK_NAME L"UseNetworkName"
// //
// IPv4 Address // IPv4 Address
// //
#define CLUSREG_NAME_IPADDR_NETWORK L"Network" #define CLUSREG_NAME_IPADDR_NETWORK L"Network"
#define CLUSREG_NAME_IPADDR_ADDRESS L"Address" #define CLUSREG_NAME_IPADDR_ADDRESS L"Address"
#define CLUSREG_NAME_IPADDR_SUBNET_MASK L"SubnetMask" #define CLUSREG_NAME_IPADDR_SUBNET_MASK L"SubnetMask"
#define CLUSREG_NAME_IPADDR_ENABLE_NETBIOS L"EnableNetBIOS" #define CLUSREG_NAME_IPADDR_ENABLE_NETBIOS L"EnableNetBIOS"
#define CLUSREG_NAME_IPADDR_OVERRIDE_ADDRMATCH L"OverrideAddressMatch" #define CLUSREG_NAME_IPADDR_OVERRIDE_ADDRMATCH L"OverrideAddressMatch"
#define CLUSREG_NAME_IPADDR_ENABLE_DHCP L"EnableDhcp" #define CLUSREG_NAME_IPADDR_ENABLE_DHCP L"EnableDhcp"
#define CLUSREG_NAME_IPADDR_LEASE_OBTAINED_TIME L"LeaseObtainedTime" #define CLUSREG_NAME_IPADDR_LEASE_OBTAINED_TIME L"LeaseObtainedTime"
#define CLUSREG_NAME_IPADDR_LEASE_TERMINATES_TIME L"LeaseExpiresTime" #define CLUSREG_NAME_IPADDR_LEASE_TERMINATES_TIME L"LeaseExpiresTime"
#define CLUSREG_NAME_IPADDR_T1 L"T1" #define CLUSREG_NAME_IPADDR_T1 L"T1"
#define CLUSREG_NAME_IPADDR_T2 L"T2" #define CLUSREG_NAME_IPADDR_T2 L"T2"
#define CLUSREG_NAME_IPADDR_DHCP_SERVER L"DhcpServer" #define CLUSREG_NAME_IPADDR_DHCP_SERVER L"DhcpServer"
#define CLUSREG_NAME_IPADDR_DHCP_ADDRESS L"DhcpAddress" #define CLUSREG_NAME_IPADDR_DHCP_ADDRESS L"DhcpAddress"
#define CLUSREG_NAME_IPADDR_DHCP_SUBNET_MASK L"DhcpSubnetMask" #define CLUSREG_NAME_IPADDR_DHCP_SUBNET_MASK L"DhcpSubnetMask"
#define CLUSREG_NAME_IPADDR_SHARED_NETNAME L"SharedNetname"
#define CLUSREG_NAME_IPADDR_PROBE_PORT L"ProbePort"
#define CLUSREG_NAME_IPADDR_PROBE_FAILURE_THRESHOLD L"ProbeFailureThreshold"
// //
// IPv6 Address // IPv6 Address
// //
#define CLUSREG_NAME_IPV6_NATIVE_NETWORK L"Network" #define CLUSREG_NAME_IPV6_NATIVE_NETWORK L"Network"
#define CLUSREG_NAME_IPV6_NATIVE_ADDRESS L"Address" #define CLUSREG_NAME_IPV6_NATIVE_ADDRESS L"Address"
#define CLUSREG_NAME_IPV6_NATIVE_PREFIX_LENGTH L"PrefixLength" #define CLUSREG_NAME_IPV6_NATIVE_PREFIX_LENGTH L"PrefixLength"
#define CLUSREG_NAME_IPV6_TUNNEL_ADDRESS L"Address" #define CLUSREG_NAME_IPV6_TUNNEL_ADDRESS L"Address"
skipping to change at line 4809 skipping to change at line 5934
#define CLUSREG_NAME_NETNAME_STATUS_DNS L"StatusDNS" #define CLUSREG_NAME_NETNAME_STATUS_DNS L"StatusDNS"
#define CLUSREG_NAME_NETNAME_STATUS_KERBEROS L"StatusKerberos" #define CLUSREG_NAME_NETNAME_STATUS_KERBEROS L"StatusKerberos"
#define CLUSREG_NAME_NETNAME_VCO_CONTAINER L"VcoContainer" #define CLUSREG_NAME_NETNAME_VCO_CONTAINER L"VcoContainer"
#define CLUSREG_NAME_NETNAME_LAST_DNS_UPDATE L"LastDNSUpdateTime" #define CLUSREG_NAME_NETNAME_LAST_DNS_UPDATE L"LastDNSUpdateTime"
#define CLUSREG_NAME_NETNAME_CONTAINERGUID L"CryptoContainerGUID" #define CLUSREG_NAME_NETNAME_CONTAINERGUID L"CryptoContainerGUID"
#define CLUSREG_NAME_NETNAME_HOST_TTL L"HostRecordTTL" #define CLUSREG_NAME_NETNAME_HOST_TTL L"HostRecordTTL"
#define CLUSREG_NAME_NETNAME_PUBLISH_PTR L"PublishPTRRecords" #define CLUSREG_NAME_NETNAME_PUBLISH_PTR L"PublishPTRRecords"
#define CLUSREG_NAME_NETNAME_REMOVEVCO_ONDELETE L"DeleteVcoOnResCleanup" #define CLUSREG_NAME_NETNAME_REMOVEVCO_ONDELETE L"DeleteVcoOnResCleanup"
#define CLUSREG_NAME_NETNAME_REGISTER_ALL_IP L"RegisterAllProvidersIP" #define CLUSREG_NAME_NETNAME_REGISTER_ALL_IP L"RegisterAllProvidersIP"
#define CLUSREG_KEYNAME_OBJECTGUIDS L"ObjectGUIDs" #define CLUSREG_KEYNAME_OBJECTGUIDS L"ObjectGUIDs"
#define CLUSREG_NAME_NETNAME_EXCLUDE_NETWORKS L"ExcludeNetworks"
#define CLUSREG_NAME_NETNAME_ALIASES L"Aliases"
#define CLUSREG_NAME_NETNAME_IN_USE_NETWORKS L"InUseNetworks"
#define CLUSREG_NAME_NETNAME_DNS_SUFFIX L"DnsSuffix"
#define CLUSREG_NAME_NETNAME_AD_AWARE L"ADAware"
// //
// Print Spooler // Print Spooler
// //
#define CLUSREG_NAME_PRTSPOOL_DEFAULT_SPOOL_DIR L"DefaultSpoolDirectory" #define CLUSREG_NAME_PRTSPOOL_DEFAULT_SPOOL_DIR L"DefaultSpoolDirectory"
#define CLUSREG_NAME_PRTSPOOL_TIMEOUT L"JobCompletionTimeout" #define CLUSREG_NAME_PRTSPOOL_TIMEOUT L"JobCompletionTimeout"
// //
// File Share // File Share
// //
#define CLUSREG_NAME_FILESHR_SERVER_NAME L"ServerName"
#define CLUSREG_NAME_FILESHR_SHARE_NAME L"ShareName" #define CLUSREG_NAME_FILESHR_SHARE_NAME L"ShareName"
#define CLUSREG_NAME_FILESHR_PATH L"Path" #define CLUSREG_NAME_FILESHR_PATH L"Path"
#define CLUSREG_NAME_FILESHR_REMARK L"Remark" #define CLUSREG_NAME_FILESHR_REMARK L"Remark"
#define CLUSREG_NAME_FILESHR_MAX_USERS L"MaxUsers" #define CLUSREG_NAME_FILESHR_MAX_USERS L"MaxUsers"
#define CLUSREG_NAME_FILESHR_SD L"Security Descriptor" #define CLUSREG_NAME_FILESHR_SD L"Security Descriptor"
#define CLUSREG_NAME_FILESHR_SHARE_SUBDIRS L"ShareSubDirs" #define CLUSREG_NAME_FILESHR_SHARE_SUBDIRS L"ShareSubDirs"
#define CLUSREG_NAME_FILESHR_HIDE_SUBDIR_SHARES L"HideSubDirShares" #define CLUSREG_NAME_FILESHR_HIDE_SUBDIR_SHARES L"HideSubDirShares"
#define CLUSREG_NAME_FILESHR_IS_DFS_ROOT L"IsDfsRoot" #define CLUSREG_NAME_FILESHR_IS_DFS_ROOT L"IsDfsRoot"
#define CLUSREG_NAME_FILESHR_SHARE_FLAGS L"ShareFlags" #define CLUSREG_NAME_FILESHR_SHARE_FLAGS L"ShareFlags"
#define CLUSREG_NAME_FILESHR_CA_TIMEOUT L"CATimeout"
// //
// DHCP Service // DHCP Service
// //
#define CLUSREG_NAME_DHCP_DATABASE_PATH L"DatabasePath" #define CLUSREG_NAME_DHCP_DATABASE_PATH L"DatabasePath"
#define CLUSREG_NAME_DHCP_BACKUP_PATH L"BackupPath" #define CLUSREG_NAME_DHCP_BACKUP_PATH L"BackupPath"
#define CLUSREG_NAME_LOG_FILE_PATH L"LogFilePath" #define CLUSREG_NAME_LOG_FILE_PATH L"LogFilePath"
// //
skipping to change at line 4861 skipping to change at line 5993
#define CLUSREG_NAME_VSSTASK_APPNAME L"ApplicationName" #define CLUSREG_NAME_VSSTASK_APPNAME L"ApplicationName"
#define CLUSREG_NAME_VSSTASK_APPPARAMS L"ApplicationParams" #define CLUSREG_NAME_VSSTASK_APPPARAMS L"ApplicationParams"
#define CLUSREG_NAME_VSSTASK_TRIGGERARRAY L"TriggerArray" #define CLUSREG_NAME_VSSTASK_TRIGGERARRAY L"TriggerArray"
// //
// File Share Quorum Witness Resource // File Share Quorum Witness Resource
// //
#define CLUSREG_NAME_FSWITNESS_SHARE_PATH L"SharePath" #define CLUSREG_NAME_FSWITNESS_SHARE_PATH L"SharePath"
#define CLUSREG_NAME_FSWITNESS_ARB_DELAY L"ArbitrationDelay" #define CLUSREG_NAME_FSWITNESS_ARB_DELAY L"ArbitrationDelay"
#define CLUSREG_NAME_FSWITNESS_IMPERSONATE_CNO L"ImpersonateCNO"
//
// Storage Pool
//
#define CLUSREG_NAME_STORAGESPACE_POOLNAME L"Name"
#define CLUSREG_NAME_STORAGESPACE_POOLDESC L"Description"
#define CLUSREG_NAME_STORAGESPACE_POOLDRIVEIDS L"DriveIds"
#define CLUSREG_NAME_STORAGESPACE_POOLHEALTH L"Health"
#define CLUSREG_NAME_STORAGESPACE_POOLSTATE L"State"
#define CLUSREG_NAME_STORAGESPACE_POOLTOTALCAPACITY L"TotalCapacity"
#define CLUSREG_NAME_STORAGESPACE_POOLCONSUMEDCAPACITY L"ConsumedCapacity"
#define CLUSREG_NAME_STORAGESPACE_POOLARBITRATE L"Arbitrate"
#define CLUSREG_NAME_STORAGESPACE_POOLREEVALTIMEOUT L"ReEvaluatePlacementTim
eout"
//
// VIP Address
//
#define CLUSREG_NAME_VIP_PREFIX_LENGTH L"PrefixLength"
#define CLUSREG_NAME_VIP_ADAPTER_NAME L"AdapterName"
#define CLUSREG_NAME_VIP_ADDRESS L"Address"
#define CLUSREG_NAME_VIP_VSID L"VSID"
#define CLUSREG_NAME_VIP_RDID L"RDID"
//
// Input structure for CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2 / C
LUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2
//
typedef struct _CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INPUT {
DWORD dwFlags;
GUID guidPoolFilter;
} CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INPUT, *PCLUSCTL_RESOURC
E_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_INPUT;
#define CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_FLAG_ADD_VOLUME_IN
FO 0x00000001
#define CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX2_FLAG_FILTER_BY_POO
L 0x00000002
#if _MSC_VER >= 1200 #if _MSC_VER >= 1200
#pragma warning(pop) // restore 4200/4201 #pragma warning(pop) // restore 4200/4201
#else #else
#pragma warning( default : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union #pragma warning( default : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union
#pragma warning( default : 4201 ) // nonstandard extension used : nameless struc t/union #pragma warning( default : 4201 ) // nonstandard extension used : nameless struc t/union
#endif #endif
#endif // MIDL_PASS #endif // MIDL_PASS
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
#define _CLUSTER_API_TYPES_ #define _CLUSTER_API_TYPES_
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
#endif // _CLUSTER_API_ #endif // _CLUSTER_API_
 End of changes. 367 change blocks. 
970 lines changed or deleted 2294 lines changed or added

This html diff was produced by rfcdiff 1.41.