#ifndef _WRGPOS_H_ #define _WRGPOS_H_ #ifdef __TANDEM #pragma columns 79 #pragma page "wrgpos.h - T9050 - OS-dependent external decs for Regroup Module" #endif /* @@@ START COPYRIGHT @@@ ** Tandem Confidential: Need to Know only ** Copyright (c) 1995, Tandem Computers Incorporated ** Protected as an unpublished work. ** All Rights Reserved. ** ** The computer program listings, specifications, and documentation ** herein are the property of Tandem Computers Incorporated and shall ** not be reproduced, copied, disclosed, or used in whole or in part ** for any reason without the prior express written permission of ** Tandem Computers Incorporated. ** ** @@@ END COPYRIGHT @@@ **/ /*--------------------------------------------------------------------------- * This file (wrgpos.h) contains OS-specific declarations used by * srgpos.c. *---------------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /*-----------------------------------NSK section-----------------------------*/ #ifdef NSK #include #include #define QUEUESEND _send_queued_() /* Regroup tracing macro */ /* In NSK, regroup uses the trace buffer and macro provided by the * message system. Regroup puts TR_NODATA for the trace type. */ #define RGP_TRACE( str, parm1, parm2, parm3, parm4 ) \ TRACE_L1 ( str, TR_NODATA, parm1, parm2, parm3, parm4 ) /* Regroup counters */ /* In NSK, regroup uses the counter buffer and macro provided by the * message system. */ #define RGP_INCREMENT_COUNTER TCount /* Macros to lock and unlock the regroup data structure to prevent * access by interrupt handlers or other processors (in SMP nodes). */ /* On NSK with uniprocessor nodes, these macros must mask off the * interrupt handlers that can access the regroup structure, namely, * the IPC and timer interrupts. * * To avoid complexities due to nesting of MUTEXes, the regroup locks * are defined to be no-ops. The NSK caller of all regroup routines * (except the inquiry routines rgp_estimate_memory, rgp_sequence_number * and rgp_is_perturbed) must ensure that IPC and timer interrupts are * disabled before calling the regroup routine. */ #define RGP_LOCK /* null; NSK must ensure that timer and IPC interrupts are disabled before calling regroup routines. */ #define RGP_UNLOCK /* null; NSK must ensure that timer and IPC interrupts are disabled before calling regroup routines. */ #ifdef __TANDEM #pragma fieldalign shared8 OS_specific_rgp_control #endif /* __TANDEM */ typedef struct OS_specific_rgp_control { uint32 filler; /* no special fields needed for NSK */ } OS_specific_rgp_control_t; #endif /* NSK */ /*-----------------------------end of NSK section----------------------------*/ /*-----------------------------------LCU section-----------------------------*/ #ifdef LCU #include #define LCU_RGP_PORT 0 /* pick up from appropriate file */ #define HZ 100 /* pick up from appropriate file */ #define plstr 0 /* pick up from appropriate file */ #define TO_PERIODIC 0 /* pick up from appropriate file */ #define CE_PANIC 3 /* pick up from appropriate file */ #define LCU_RGP_FLAGS (LCUF_SENDMSG || LCUF_NOSLEEP) /* msg alloc flags */ extern void rgp_msgsys_work(lcumsg_t *lcumsgp, int status); #define QUEUESEND rgp_msgsys_work(NULL, 0) /* Regroup tracing macro */ #define RGP_TRACE( str, parm1, parm2, parm3, parm4 ) /* empty for now */ /* Regroup counters */ typedef struct { uint32 QueuedIAmAlive; uint32 RcvdLocalIAmAlive; uint32 RcvdRemoteIAmAlive; uint32 RcvdRegroup; } rgp_counter_t; #define RGP_INCREMENT_COUNTER( field ) rgp->OS_specific_control.counter.field++ /* Regroup locks */ typedef struct rgp_lock { uint32 var1; uint32 var2; } rgp_lock_t; /* Macros to lock and unlock the regroup data structure to prevent * access by interrupt handlers or other processors (in SMP nodes) */ #define RGP_LOCK /* null for now; need to be filled in */ #define RGP_UNLOCK /* null for now; need to be filled in */ typedef struct { rgp_lock_t rgp_lock; /* to serialize access */ rgp_counter_t counter; /* to count events */ lcumsg_t *lcumsg_regroup_p; /* pointer to regroup status message */ lcumsg_t *lcumsg_iamalive_p; /* pointer to iamalive message */ lcumsg_t *lcumsg_poison_p; /* pointer to poison message */ sysnum_t my_sysnum; /* local system number */ } OS_specific_rgp_control_t; #endif /* LCU */ /*-----------------------------end of LCU section----------------------------*/ /*----------------------------------UNIX section-----------------------------*/ #ifdef UNIX extern void rgp_msgsys_work(void); #define QUEUESEND rgp_msgsys_work(); #include #include #include #include #include #include #include #include #include #include #include extern int errno; #define MSG_FLAGS 0 /* flags for message send/receive */ #define RGP_PORT_BASE 5757 /* for use with sockets */ typedef struct { int event; union { node_t node; rgpinfo_t rgpinfo; } data; /* depends on the event */ rgp_unseq_pkt_t unseq_pkt; } rgp_msgbuf; #define BUFLEN sizeof(rgp_msgbuf) /* Additional events created for testing regroup using process-level * simulation. */ #define RGP_EVT_START 10 #define RGP_EVT_ADD_NODE 11 #define RGP_EVT_MONITOR_NODE 12 #define RGP_EVT_REMOVE_NODE 13 #define RGP_EVT_GETRGPINFO 14 #define RGP_EVT_SETRGPINFO 15 #define RGP_EVT_HALT 16 #define RGP_EVT_FREEZE 17 #define RGP_EVT_THAW 18 #define RGP_EVT_STOP_SENDING 19 #define RGP_EVT_RESUME_SENDING 20 #define RGP_EVT_STOP_RECEIVING 21 #define RGP_EVT_RESUME_RECEIVING 22 #define RGP_EVT_SEND_POISON 23 #define RGP_EVT_STOP_TIMER_POPS 24 #define RGP_EVT_RESUME_TIMER_POPS 25 #define RGP_EVT_RELOAD 26 #define RGP_EVT_FIRST_EVENT 1 #define RGP_EVT_FIRST_DEBUG_EVENT 10 #define RGP_EVT_LAST_EVENT 26 /* Regroup tracing macro */ #define RGP_TRACE( str, parm1, parm2, parm3, parm4 ) \ do \ { \ printf("Node %3d: %16s: 0x%8X, 0x%8X, 0x%8X, 0x%8X.\n", \ EXT_NODE(rgp->mynode), str, parm1, parm2, parm3, parm4); \ fflush(stdout); \ } while (0) /* Regroup counters */ typedef struct { uint32 QueuedIAmAlive; uint32 RcvdLocalIAmAlive; uint32 RcvdRemoteIAmAlive; uint32 RcvdRegroup; } rgp_counter_t; #define RGP_INCREMENT_COUNTER( field ) rgp->OS_specific_control.counter.field++ /* Macros to lock and unlock the regroup data structure to prevent * access by interrupt handlers or other processors (in SMP nodes) */ #define RGP_LOCK /* null; all access done from one thread */ #define RGP_UNLOCK /* null; all access done from one thread */ /* This struct keeps some debugging info. */ typedef struct rgpdebug { uint32 frozen : 1; /* node is frozen; ignore all events except the thaw command */ uint32 reload_in_progress : 1; /* reload in progess; if set, refuse new reload command */ uint32 unused : 30; cluster_t stop_sending; /* stop sending to these nodes */ cluster_t stop_receiving; /* stop receiving from these nodes */ } rgp_debug_t; typedef struct { rgp_counter_t counter; /* to count events */ rgp_debug_t debug; /* for debugging purposes */ } OS_specific_rgp_control_t; /* Variables and routines provided by the srgpsvr.c driver program */ extern unsigned int alarm_period; extern void alarm_handler(void); extern void (*alarm_callback)(); extern void rgp_send(node_t node, void *data, int datasize); extern void rgp_msgsys_work(); #endif /* UNIX */ /*----------------------------end of UNIX section----------------------------*/ /*----------------------------------NT section-----------------------------*/ #ifdef NT extern void rgp_msgsys_work(void); #define QUEUESEND rgp_msgsys_work(); #if !defined (TDM_DEBUG) #define LOG_CURRENT_MODULE LOG_MODULE_MM #include #include #else //TDM_DEBUG #define _WIN32_WINNT 0x0400 #include #include extern int errno; #endif #include #include #include #include #include #include #include #include #undef small // otherwise we have to change a bunch of our code typedef struct { int event; union { node_t node; rgpinfo_t rgpinfo; } data; /* depends on the event */ rgp_unseq_pkt_t unseq_pkt; } rgp_msgbuf; #define BUFLEN sizeof(rgp_msgbuf) /* Additional events created for testing regroup using process-level * simulation. */ #define RGP_EVT_START 10 #define RGP_EVT_ADD_NODE 11 #define RGP_EVT_MONITOR_NODE 12 #define RGP_EVT_REMOVE_NODE 13 #define RGP_EVT_GETRGPINFO 14 #define RGP_EVT_SETRGPINFO 15 #define RGP_EVT_HALT 16 #define RGP_EVT_FREEZE 17 #define RGP_EVT_THAW 18 #define RGP_EVT_STOP_SENDING 19 #define RGP_EVT_RESUME_SENDING 20 #define RGP_EVT_STOP_RECEIVING 21 #define RGP_EVT_RESUME_RECEIVING 22 #define RGP_EVT_SEND_POISON 23 #define RGP_EVT_STOP_TIMER_POPS 24 #define RGP_EVT_RESUME_TIMER_POPS 25 #define RGP_EVT_RELOAD 26 #define RGP_EVT_TRACING 27 #define RGP_EVT_INFO 28 // MM events #define MM_EVT_EJECT 29 #define MM_EVT_LEAVE 30 #define MM_EVT_INSERT_TESTPOINTS 31 #define RGP_EVT_FIRST_EVENT 1 #define RGP_EVT_FIRST_DEBUG_EVENT 10 #define RGP_EVT_LAST_EVENT 31 /* internal timeout for acknowledged messages */ #define RGP_ACKMSG_TIMEOUT 500 // 0.5 seconds /* Regroup tracing macro */ #if defined (TDM_DEBUG) #define RGP_TRACE( str, parm1, parm2, parm3, parm4 ) \ if ( rgp->OS_specific_control.debug.doing_tracing ) \ do \ { \ printf("Node %3d: %16hs: 0x%8X, 0x%8X, 0x%8X, 0x%8X.\n", \ EXT_NODE(rgp->mynode), str, parm1, parm2, parm3, parm4); \ fflush(stdout); \ } while (0) #else // WOLFPACK #define RGP_TRACE( str, parm1, parm2, parm3, parm4 ) \ ClRtlLogPrint(LOG_NOISE, \ "[RGP] Node %1!d!: %2!16hs!: 0x%3!x!, 0x%4!x!, 0x%5!x!, 0x%6!x!.\n", \ EXT_NODE(rgp->mynode), str, parm1, parm2, parm3, parm4) #endif /* Regroup counters */ typedef struct { uint32 QueuedIAmAlive; uint32 RcvdLocalIAmAlive; uint32 RcvdRemoteIAmAlive; uint32 RcvdRegroup; } rgp_counter_t; #define RGP_INCREMENT_COUNTER( field ) rgp->OS_specific_control.counter.field++ /* Macros to lock and unlock the regroup data structure to prevent * access from other concurrent threads. */ #define RGP_LOCK EnterCriticalSection( &rgp->OS_specific_control.RgpCriticalSection ); #define RGP_UNLOCK LeaveCriticalSection( &rgp->OS_specific_control.RgpCriticalSection ); #if defined(TDM_DEBUG) typedef union { struct { uint32 joinfailADD : 1; uint32 joinfailMON : 1; uint32 description3 : 1; uint32 description4 : 1; uint32 description5 : 1; uint32 description6 : 1; uint32 description7 : 1; uint32 description8 : 1; uint32 description9 : 1; uint32 description10 : 1; uint32 description11 : 1; uint32 description12 : 1; uint32 description13 : 1; uint32 description14 : 1; uint32 description15 : 1; uint32 description16 : 1; uint32 morebits : 16; } TestPointBits; uint32 TestPointWord; }TestPointInfo; /* This struct keeps some debugging info. */ typedef struct rgpdebug { uint32 frozen : 1; /* node is frozen; ignore all events except the thaw command */ uint32 reload_in_progress : 1; /* reload in progess; if set, refuse new reload command */ uint32 timer_frozen : 1; /* timer pops are ignored */ uint32 doing_tracing : 1; /* whether or not RGP_TRACE is a nop */ uint32 unused : 28; cluster_t stop_sending; /* stop sending to these nodes */ cluster_t stop_receiving; /* stop receiving from these nodes */ TestPointInfo MyTestPoints; /* Controls test points for error/other insertion */ } rgp_debug_t; #endif // TDM_DEBUG typedef struct { rgp_counter_t counter; /* to count events */ HANDLE TimerThread; /* HANDLE of HeartBeat timer thread */ DWORD TimerThreadId;/* Thread ID of HeartBeat timer thread */ HANDLE TimerSignal; /* Event used to change HB rate and cause Terminate */ HANDLE RGPTimer; /* Regroup Timer - Used by timer thread */ CRITICAL_SECTION RgpCriticalSection; /* CriticalSection object for regroup activities */ ULONG EventEpoch; /* used to detect stale events from clusnet */ MMNodeChange UpDownCallback; /*Callback to announce node up and node down event*/ MMQuorumSelect QuorumCallback; /*Callback to check if Quorum disk accessible - split brain avoidance */ MMHoldAllIO HoldIOCallback; /*Callback to suspend all IO and message activity during early regroup */ MMResumeAllIO ResumeIOCallback; /*Callback to resume all IO and message activity after PRUNING stage */ MMMsgCleanup1 MsgCleanup1Callback; /*Callback for Phase1 Message system cleanup from down node */ MMMsgCleanup2 MsgCleanup2Callback; /*Callback for Phase2 Message system cleanup to down node */ MMHalt HaltCallback; /*Callback to announce internal error or Poison packet or cluster ejection */ MMJoinFailed JoinFailedCallback; /*Callback to announce failure to join cluster. Retry required */ MMNodesDown NodesDownCallback; /* Callback to announce failure of one or more nodes.*/ cluster_t CPUUPMASK; /* Bitmask of UP Nodes for consistent Info api */ cluster_t NeedsNodeDownCallback; /* node(s) went down, need to do UpDown callback */ cluster_t Banished; /* mask of banished nodes */ HANDLE Stabilized; /* event which is set when the regroup is not active */ BOOL ArbitrationInProgress; /* it is set to True while regroup waits for arbitate callback to return */ DWORD ArbitratingNode; /* MM_INVALID_NODE or the arbitrating node (last regroup)*/ DWORD ApproxArbitrationWinner; /* Like ArbitratingNode, but spans multiple regroups */ BOOL ShuttingDown; /* indicate that a node is shutting done */ cluster_t MulticastReachable; /* indicate which nodes can be reachable via mcast */ #if defined( TDM_DEBUG ) rgp_debug_t debug; /* for debugging purposes */ #endif } OS_specific_rgp_control_t; extern DWORD QuorumOwner; /* updated by SetQuorumOwner and successful arbitrator*/ /* this variable can be set by the first node coming up before Mm is initialized */ /* Variables and routines provided by the srgpsvr.c driver program */ extern unsigned int alarm_period; //extern void alarm_handler(void); //extern void (*alarm_callback)(); extern void rgp_send(node_t node, void *data, int datasize); extern void rgp_msgsys_work(); #endif /* NT */ /*----------------------------end of NT section----------------------------*/ #ifdef __cplusplus } #endif /* __cplusplus */ #if 0 History of changes to this file: ------------------------------------------------------------------------- 1995, December 13 F40:KSK0610 /*F40:KSK06102.1*/ This file is part of the portable Regroup Module used in the NonStop Kernel (NSK) and Loosely Coupled UNIX (LCU) operating systems. There are 10 files in the module - jrgp.h, jrgpos.h, wrgp.h, wrgpos.h, srgpif.c, srgpos.c, srgpsm.c, srgputl.c, srgpcli.c and srgpsvr.c. The last two are simulation files to test the Regroup Module on a UNIX workstation in user mode with processes simulating processor nodes and UDP datagrams used to send unacknowledged datagrams. This file was first submitted for release into NSK on 12/13/95. ------------------------------------------------------------------------------ #endif /* 0 - change descriptions */ #endif /* _WRGPOS_H_ defined */