fis-gtm/sr_port/deferred_events.c

/****************************************************************
 *								*
 *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
 *								*
 *	This source code contains the intellectual property	*
 *	of its copyright holder(s), and is made available	*
 *	under a license.  If you do not know the terms of	*
 *	the license, please stop and do not read further.	*
 *								*
 ****************************************************************/

#include "mdef.h"

#ifdef VMS
#include "efn.h"
#include <ssdef.h>
#endif

#include "xfer_enum.h"
#include "tp_timeout.h"
#include "deferred_events.h"
#include "outofband.h"
#include "interlock.h"
#include "lockconst.h"
#include "add_inter.h"
#include "op.h"
#include "iott_wrterr.h"

#ifdef DEBUG_DEFERRED
#include "gtm_stdio.h"
#endif

#include "fix_xfer_entry.h"

/* =============================================================================
 * EXTERNAL VARIABLES
 * =============================================================================
 */

/* The transfer table */
GBLREF xfer_entry_t     xfer_table[];

/* M Profiling active */
GBLREF	boolean_t	is_tracing_on;

/* Marks sensitive database operations */
GBLREF volatile int4	fast_lock_count;

#if defined(VMS)
GBLREF volatile short   num_deferred;
#else
GBLREF volatile int4    num_deferred;
#endif
GBLREF volatile int4	ctrap_action_is, outofband;

/* =============================================================================
 * FILE-SCOPE VARIABLES
 * =============================================================================
 */

/* ------------------------------------------------------------------
 * Declared volatile because accesses occur both in main thread
 * and (possibly multiple) interrupts levels.
 * ------------------------------------------------------------------
 */

/* Holds count of events logged of each type.
 * Cleared when table is reset.
 * Location zero (== no_event) is not used.
 */

/* INCR_CNT on VMS doesn't return the post-incremented value as is the
 * case in Unix. But we don't need an interlocked add in VMS since we
 * should be in an AST and AST's can't be nested (we assert to that effect
 * in xfer_set_handlers). The macro INCR_CNT_SP accomplishes this task for us.
 */

#if defined(UNIX)
volatile int4 			xfer_table_events[DEFERRED_EVENTS];
#define	INCR_CNT_SP(X,Y)	INCR_CNT(X,Y)
#elif defined(VMS)
volatile short 			xfer_table_events[DEFERRED_EVENTS];
#define INCR_CNT_SP(X,Y)	(++*X)
#else
# error "Unsupported Platform"
#endif
GBLREF  global_latch_t		defer_latch;

/* -------------------------------------------------------
 * Act only on first recieved.
 * -------------------------------------------------------
 */
GBLDEF	volatile int4	first_event = no_event;

error_def(ERR_DEFEREVENT);

/* =============================================================================
 * EXPORTED FUNCTIONS
 * =============================================================================
 */
/* ------------------------------------------------------------------
 * *** INTERRUPT HANDLER ***
 * Sets up transfer table changes needed for:
 *   - Synchronous handling of asynchronous events.
 *   - Single-stepping and breakpoints
 * Note:
 *   - Call here from a routine specific to each event type.
 *   - Pass in a single value to pass on to xfer_table set function
 *     for that type. Calling routine should record any other event
 *     info, if needed, in volatile global variables.
 *   - If this is first event logged, will call back to the function
 *     provided and pass along parameter.
 * Future:
 *   - mdb_condition_handler does not call here -- should change it.
 *   - Ditto for routines related to zbreak and zstep.
 *   - Should put handler prototypes in a header file & include it here,
 *     if can use with some way to ensure type checking.
 *   - A higher-level interface (e.g. change sets) might be better.
 * ------------------------------------------------------------------
 */
boolean_t xfer_set_handlers(int4  event_type, void (*set_fn)(int4 param), int4 param_val)
{
	boolean_t 	is_first_event = FALSE;

	/* ------------------------------------------------------------
	 * Keep track of what event types have come in.
	 * - Get and set value atomically in case of concurrent
	 *   events and/or resetting while setting.
	 * ------------------------------------------------------------------
	 * Use interlocked operations to prevent races between set and reset,
	 * and to avoid missing overlapping sets.
	 * On HP:
	 *    OK only if there's no a risk a conflicting operation is
	 *    in progress  (can deadlock).
	 * On all platforms:
	 *    Don't want I/O from a sensitive area.
	 * Avoid both by testing fast_lock_count, and doing interlocks and
	 * I/O only if it is non-zero. Can't be resetting then, so worst
	 * risk is missing an event when there's already one happening.
	 * ------------------------------------------------------------------
	 */

	VMS_ONLY(assert(lib$ast_in_prog()));
	if (fast_lock_count == 0)
	{
#ifdef DEBUG_DEFERRED
		(void) FPRINTF(stderr,
			       "\nBefore interlocked operations:  "
			       "xfer_table_events[%d]=%d, "
			       "first_event=%s, "
			       "num_deferred=%d\n",
			       event_type,
			       xfer_table_events[event_type],
			       (is_first_event?"TRUE":"FALSE"),
			       num_deferred);
#endif
		if (1 == INCR_CNT_SP(&xfer_table_events[event_type], &defer_latch))
		{
			/* Concurrent events can collide here, too */
			is_first_event =  (1 == INCR_CNT_SP(&num_deferred, &defer_latch));
		}

#ifdef DEBUG_DEFERRED
		(void) FPRINTF(stderr,
			       "\nAfter interlocked operations:   "
			       "xfer_table_events[%d]=%d, "
			       "first_event=%s, "
			       "num_deferred=%d\n",
			       event_type,xfer_table_events[event_type],
			       (is_first_event?"TRUE":"FALSE"),
			       num_deferred);
#endif
	} else if (1 == ++xfer_table_events[event_type])
		is_first_event = (1 == ++num_deferred);
	if (is_first_event)
	{
		first_event = event_type;

#ifdef DEBUG_DEFERRED
		if (0 != fast_lock_count)
		{
			(void) FPRINTF(stderr,
				       "Setting xfer_table for event type %d.\n",
				       event_type);
		}
#endif
		/* -------------------------------------------------------
		 * If table changed, it was not synchronized.
		 * (Assumes these entries are all that would be changed)
		 * Note asserts bypassed for Itanium due to nature of the
		 * fixed up addresses making direct comparisions non-trivial.
		 * --------------------------------------------------------
		 */
#ifndef __ia64
		 assert((xfer_table[xf_linefetch] == op_linefetch) ||
			(xfer_table[xf_linefetch] == op_zstepfetch) ||
			(xfer_table[xf_linefetch] == op_zst_fet_over) ||
			(xfer_table[xf_linefetch] == op_mproflinefetch));
		 assert((xfer_table[xf_linestart] == op_linestart) ||
			(xfer_table[xf_linestart] == op_zstepstart) ||
			(xfer_table[xf_linestart] == op_zst_st_over) ||
			(xfer_table[xf_linestart] == op_mproflinestart));
		 assert((xfer_table[xf_zbfetch] == op_zbfetch) ||
		 	(xfer_table[xf_zbfetch] == op_zstzb_fet_over) ||
			(xfer_table[xf_zbfetch] == op_zstzbfetch));
		 assert((xfer_table[xf_zbstart] == op_zbstart) ||
			(xfer_table[xf_zbstart] == op_zstzb_st_over) ||
			(xfer_table[xf_zbstart] == op_zstzbstart));
		 assert((xfer_table[xf_forchk1] == op_forchk1) ||
			(xfer_table[xf_forchk1] == op_mprofforchk1));
		 assert((xfer_table[xf_forloop] == op_forloop));
		 assert(xfer_table[xf_ret] == opp_ret ||
			xfer_table[xf_ret] == opp_zst_over_ret ||
			xfer_table[xf_ret] == opp_zstepret);
		 assert(xfer_table[xf_retarg] == op_retarg ||
			xfer_table[xf_retarg] == opp_zst_over_retarg ||
			xfer_table[xf_retarg] == opp_zstepretarg);
#endif /* !ia64 */
		/* -----------------------------------------------
		 * Now call the specified set function to swap in
		 * the desired handlers (and set flags or whatever).
		 * -----------------------------------------------
		 */
		set_fn(param_val);
	}
#ifdef DEBUG_DEFERRED
	else if (0 != fast_lock_count)
	{
		(void) FPRINTF(stderr,
			       "\n---Multiple deferred events---\n"
			       "Event type %d occurred while type %d was pending\n",
			       event_type,
			       first_event);
	}
#endif
 	assert(no_event != first_event);
	return is_first_event;
}

/* ------------------------------------------------------------------
 * Reset the transfer table only if current event type
 * - Needed for abort before action, e.g., a tp timeout
 *   that happened just before commit was too late to be aborted and
 *   so must be cleared. In a case like this, reset should happen
 *   only if the event type attempting the clear is the type
 *   that caused the change.
 * - Other resets should be unconditional, in case there are
 *   unidentified control paths (e.g. exit paths) that cause
 *   resets when they did not set.
 * ------------------------------------------------------------------
 */
boolean_t xfer_reset_if_setter(int4 event_type)
{
	if (event_type == first_event)
	{
		/* Still have to synchronize the same way... */
		if (TRUE == xfer_reset_handlers(event_type))
		{ 	/* *********************************
			 * Check for and activate any
			 * other pending events before
			 * returning success:
			 * *********************************
			 */
		  	/* (Not implemented) */
			return TRUE;
		} else
		{ 	/* ---------------------------------
			 * Would require interleaved resets
			 * to get here, e.g. due to
			 * rts_error from interrupt level.
			 * ---------------------------------
			 */
			assert(FALSE);
			return FALSE;
		}
	} else
		return FALSE;
}

/* ------------------------------------------------------------------
 * Reset transfer table to normal settings.
 *
 * - Intent: Put back all state that was or could have been changed
 *   due to prior deferral(s).
 *    - Would be easier to implement this assumption if this routine
 *      were changed to delegate responsibility as does the
 *      corresponding set routine.
 * - Note that all events are reenabled before user's handler
 *   would be executed (assuming one is appropriate for this event
 *   and has been specified)
 *    => It's possible to have handler-in-handler execution.
 *    => If no handler executed, would lose other deferred events due
 *       to reset of all pending.
 * - If M profiling is active, some entries should be set to the
 *       op_mprof* routines.
 * - Return value indicates whether reset type matches set type.
 *   If it does not, this indicates an "abnormal" path.
 *    - Should still reset the table in this case.
 *    - BUT: Consider also calling a reset routine for all setters
 *      that have been logged, to allow them to reset themselves,
 *      (for example, to reset TP timer & flags, or anything else
 *      that could cause unintended effects if left set after
 *      deferred events have been cleared).
 * - May need to update behavior to ensure it doesn't miss a
 *   critical event between registration of first event
 *   and clearing of all events. This seems problematic only if
 *   the following are true:
 *    - Two events are deferred at one time (call them A and B).
 *    - An M exception handler (ZTRAP or device) is required to
 *      execute due to B and perform action X.
 *    - Either no handler executes due to A, or the handler that
 *      does execute does not perform action X in response to B
 *      (this includes the possibility of performing X but not
 *       as needed by B, e.g. perhaps it should happen for both
 *       A and B but only happens for A).
 *   Seems like most or all of these can be addressed by carefully
 *   specifying coding requirements on M handlers.
 * ------------------------------------------------------------------
 */
boolean_t xfer_reset_handlers(int4 event_type)
{
	int4		e_type;
	boolean_t	reset_type_is_set_type;
	int4		status;
	int 		e, ei, e_tot=0;


	/* ------------------------------------------------------------------
	 * Note: If reset routine can preempt path from handler to
	 * set routine (e.g. clearing event before acting on it),
	 * these assertions can fail.
	 * Should not happen in current design.
	 * ------------------------------------------------------------------
	 */
	assert(0 < num_deferred);
	assert(0 < xfer_table_events[event_type]);

	if (is_tracing_on)
	{
		FIX_XFER_ENTRY(xf_linefetch, op_mproflinefetch);
		FIX_XFER_ENTRY(xf_linestart, op_mproflinestart);
		FIX_XFER_ENTRY(xf_forchk1, op_mprofforchk1);
	} else
	{
		FIX_XFER_ENTRY(xf_linefetch, op_linefetch);
		FIX_XFER_ENTRY(xf_linestart, op_linestart);
		FIX_XFER_ENTRY(xf_forchk1, op_forchk1);
	}
	FIX_XFER_ENTRY(xf_forloop, op_forloop);
	FIX_XFER_ENTRY(xf_zbfetch, op_zbfetch);
	FIX_XFER_ENTRY(xf_zbstart, op_zbstart);
	FIX_XFER_ENTRY(xf_ret, opp_ret);
	FIX_XFER_ENTRY(xf_retarg, op_retarg);

#ifdef DEBUG_DEFERRED
	(void) FPRINTF(stderr,"Reset xfer_table for event type %d.\n",event_type);
#endif

	reset_type_is_set_type =  (event_type == first_event);

#ifdef DEBUG
	if (!reset_type_is_set_type)
	{
 		rts_error(VARLSTCNT(4) ERR_DEFEREVENT,
 				 2,
 				 event_type,
 				 first_event);
	}
#endif

#ifdef DEBUG_DEFERRED
/*--------------------------------------------=---------------------------------
 * Note: concurrent modification of array elements means events that occur
 * during this section will cause inconsistent totals.
 *-----------------------------------------------------------------------------
 */
	for (ei=no_event; ei<DEFERRED_EVENTS; ei++)
	{
		e_tot += xfer_table_events[ei];
	}
	if (e_tot >1)
	{
		(void) FPRINTF(stderr,"Event Log:\n");
		for (ei=no_event; ei<DEFERRED_EVENTS; ei++)
		{
			(void) FPRINTF(stderr,
				       "  Event type %d: count was %d.\n",
				       ei,
				       xfer_table_events[ei]);
		}
	}
#endif

	/* -------------------------------------------------------------------------
	 * Kluge(?): set all locations to nonzero value to
	 * prevent interleaving with reset activities.
	 *
	 * Would be better to aswp with 0:
	 * - Won't lose any new events that way.
	 * -------------------------------------------------------------------------
	 */
	for (e_type = 1; DEFERRED_EVENTS > e_type; e_type++)
	{
		xfer_table_events[e_type] = 1;
	}

	/* -------------------------------------------------------------------------
	 * Reset external event modules that need it.
	 * (Should do this in a more modular fashion.)
	 * None
	 * -------------------------------------------------------------------------
	 */

	/* --------------------------------------------
	 * Reset private variables.
	 * --------------------------------------------
	 */
	first_event = no_event;
	num_deferred = 0;
	ctrap_action_is = 0;
	outofband = 0;
	VMS_ONLY(
		status = sys$clref(efn_outofband);
		assert(SS$_WASSET == status);
		if ((SS$_WASSET != status) && (SS$_WASCLR != status))
			GTMASSERT;
	)
	/* ******************************************************************
	 * There is a race here:
	 * If a new event interrupts after previous line and before
	 * corresponding assignment in next loop, it will be missed.
	 * For most events, we're going to an M handler anyway, so it won't
	 * matter (assuming the handler would handle all pending events).
	 * But if not going to an M handler (e.g. if resetting zbreak/zstep),
	 * could miss another event.
	 *
	 * Better (to avoid missing any events):
	 *      aswp xfer_table_events elements (as described above), and
	 * check here if still zero. If not, must have missed that event
	 * since aswp, possibly before num_deferred was reset => never set
	 * xfer_table => should do that now.
	 *      If more than one is nonzero, choose first arbitrarily
	 * unless first_event is now set -- unless it is, we've lost track of
	 * which event was first.
	 * ******************************************************************
	 */
	/* Clear to allow new events to be reset only after we're all done. */
	for (e_type = 1; DEFERRED_EVENTS > e_type; e_type++)
	{
		xfer_table_events[e_type] = FALSE;
	}
	return reset_type_is_set_type;
}

/* ------------------------------------------------------------------
 * Perform action corresponding to the first async event that
 * was logged.
 * ------------------------------------------------------------------
 */
void async_action(bool lnfetch_or_start)
{
	/* Double-check that we should be here: */
	assert(0 < num_deferred);

	switch(first_event)
	{
	case (outofband_event):
		if (0 == outofband)
		{	/* This function can be invoked only by a op_*intrrpt* transfer table function. Those transfer table
			 * functions should be active only for a short duration between the occurrence of an outofband event
			 * and the handling of it at a logical boundary (next M-line). We dont expect to be running with
			 * those transfer table functions for more than one M-line. If "outofband" is set to 0, the call to
			 * "outofband_action" below will do nothing and we will end up running with the op_*intrrpt* transfer
			 * table functions indefinitely. In this case M-FOR loops are known to return incorrect results which
			 * might lead to application integrity issues. It is therefore considered safer to GTMASSERT as we
			 * will at least have the core for analysis.
			 */
			GTMASSERT;
		}
		outofband_action(lnfetch_or_start);
		break;
	case (tt_write_error_event):
		UNIX_ONLY(
			xfer_reset_if_setter(tt_write_error_event);
			iott_wrterr();
		)
		/* VMS tt error processing is done in op_*intrrpt */
		break;
	case (network_error_event):
		/* -------------------------------------------------------
		 * Network error not implemented here yet. Need to move
		 * from mdb_condition_handler after review.
		 * -------------------------------------------------------
		 */
	case (zstp_or_zbrk_event):
		/* -------------------------------------------------------
		 * ZStep/Zbreak events not implemented here yet. Need to
		 * move here after review.
		 * -------------------------------------------------------
		 */
	default:
		GTMASSERT;	/* see above GTMASSERT for comment as to why this is needed */
	}
}


/* ------------------------------------------------------------------
 * Indicate whether an xfer_table change is pending.
 * Only works for changes made using routines in this module
 * (need to rework others, too).
 *
 * Might not be needed.
 * ------------------------------------------------------------------
 */
boolean_t xfer_table_changed(void)
{
	return (0 != num_deferred);
}