fis-gtm/sr_port/jobexam_process.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"

#include <sys/types.h>
#include <signal.h>
#include "gtm_unistd.h"
#include "gtm_string.h"
#include "gtm_stdio.h"

#include "error.h"
#include "io_params.h"
#include "op.h"
#include "io.h"
#include "rtnhdr.h"
#include "stack_frame.h"
#include "jobexam_process.h"
#ifdef UNIX
#  include "jobexam_signal_handler.h"
#endif
#include "send_msg.h"
#include "callg.h"
#include "zshow.h"
#include "util.h"
#include "mv_stent.h"

#define DEFAULT_DUMP_FILENAME "GTM_JOBEXAM.ZSHOW_DMP"
#define NOCONCEAL_OPTION "NO_CONCEAL"

static readonly mval empty_str_mval = DEFINE_MVAL_LITERAL(MV_STR, 0, 0, 0, 0, 0, 0);
static readonly mval no_conceal_op  = DEFINE_MVAL_LITERAL(MV_STR, 0, 0, SIZEOF(NOCONCEAL_OPTION) - 1,
							 NOCONCEAL_OPTION, 0, 0);
static unsigned char dumpable_error_dump_file_parms[2] = {iop_newversion, iop_eol};
static unsigned char dumpable_error_dump_file_noparms[1] = {iop_eol};
static unsigned int  jobexam_counter;

GBLREF uint4		process_id;
GBLREF io_pair		io_std_device, io_curr_device;
GBLREF mv_stent		*mv_chain;
GBLREF unsigned char    *msp, *stackwarn, *stacktop;
GBLREF char		*util_outptr, util_outbuff[OUT_BUFF_SIZE];
GBLREF boolean_t        created_core;
UNIX_ONLY(GBLREF sigset_t blockalrm;)
DEBUG_ONLY(GBLREF boolean_t ok_to_UNWIND_in_exit_handling;)

error_def(ERR_GTMASSERT);
error_def(ERR_GTMCHECK);
error_def(ERR_MEMORY);
error_def(ERR_VMSMEMORY);
error_def(ERR_OUTOFSPACE);
error_def(ERR_STACKOFLOW);
error_def(ERR_STACKCRIT);
error_def(ERR_JOBEXAMFAIL);
error_def(ERR_JOBEXAMDONE);

void jobexam_process(mval *dump_file_name, mval *dump_file_spec)
{
	mval			*input_dump_file_name;
	io_pair			dev_in_use;
	mv_stent		*new_mv_stent;
	boolean_t		saved_mv_stent;
	char			saved_util_outbuff[OUT_BUFF_SIZE];
	int			saved_util_outbuff_len;
#ifdef UNIX
	struct sigaction	new_action, prev_action;
	sigset_t		savemask;
#endif
	/* If the input file name is the result of an expression, it is likely being held in the
	   same temporary as the output file spec. We can tell if this is true by comparing the
	   address of the input and output mvals. If they are the same, make a copy of the input
	   filespec in a garbage collection safe mval prior to initializing the output mval
	   (which in this case would clear the input mval as well if it had not just been saved).
	*/
	if (dump_file_name == dump_file_spec)
	{	/* Make saved copy of input mval */
		PUSH_MV_STENT(MVST_MVAL);
		new_mv_stent = mv_chain;
		input_dump_file_name = &mv_chain->mv_st_cont.mvs_mval;
		*input_dump_file_name = *dump_file_name;
		saved_mv_stent = TRUE;
	} else
	{	/* Just use input mval as-is */
		input_dump_file_name = dump_file_name;
		saved_mv_stent = FALSE;
	}

#ifdef UNIX
	/* Block out timer calls that might trigger processing that could fail. We especially want to prevent
	   nesting of signal handlers since the longjump() function used by the UNWIND macro is undefined on
	   Tru64 when signal handlers are nested.
	*/
	sigprocmask(SIG_BLOCK, &blockalrm, &savemask);

	/* Setup new signal handler to just drive condition handler which will do the right thing */
	memset(&new_action, 0, SIZEOF(new_action));
	sigemptyset(&new_action.sa_mask);
	new_action.sa_flags = SA_SIGINFO;
#ifdef __sparc
	new_action.sa_handler = jobexam_signal_handler;
#else
	new_action.sa_sigaction = jobexam_signal_handler;
#endif
	sigaction(SIGBUS, &new_action, &prev_action);
	sigaction(SIGSEGV, &new_action, 0);
#endif
	*dump_file_spec = empty_str_mval;
	dev_in_use = io_curr_device;		/* Save current IO device */
	/* Save text in util_outbuff which can be detrimentally overwritten by ZSHOW */
	saved_util_outbuff_len = 0;
	if (NULL == util_outptr)
		util_outptr = util_outbuff;
	if (0 != (saved_util_outbuff_len = (int)(util_outptr - util_outbuff)))	/* Caution -- assignment */
	{
		assert(0 <= saved_util_outbuff_len);
		assert(saved_util_outbuff_len <= SIZEOF(saved_util_outbuff));
		memcpy(saved_util_outbuff, util_outbuff, saved_util_outbuff_len);
	}
	jobexam_dump(input_dump_file_name, dump_file_spec);
	/* If any errors occur in job_exam_dump, the condition handler will unwind the stack to this point and return.  */
	if (0 != saved_util_outbuff_len)
	{	/* Restore util_outbuff values */
		memcpy(util_outbuff, saved_util_outbuff, saved_util_outbuff_len);
		util_outptr = util_outbuff + saved_util_outbuff_len;
	}
	io_curr_device = dev_in_use;		/* Restore IO device */
	/* If we saved an mval on our stack, we need to pop it off. If there was an error while doing the
	 * jobexam dump, zshow may have left some other mv_stent entries on the stack. Pop them all off with
	 * just a regular POP_MV_STENT macro rather than unw_mv_ent() call because the mv_stent entries
	 * created in zshow_output reference automatic storage that cannot be referenced at this stack
	 * level without potential (C) stack corruption.
	 */
	if (saved_mv_stent)
	{
		if (mv_chain > new_mv_stent)
			/* This violates our assumptions that the mv_stent we pushed onto the stack should
			   still be there */
			GTMASSERT;
		while (mv_chain <= new_mv_stent)
		{
			POP_MV_STENT();
		}
	}
#ifdef UNIX
	/* Restore the signal handlers how they were */
	sigaction(SIGBUS, &prev_action, 0);
	sigaction(SIGSEGV, &prev_action, 0);
	/* Let the timers pop again.. */
	sigprocmask(SIG_SETMASK, &savemask, NULL);
#endif
}

/* This routine is broken out as another ep so we can do cleanup processing in jobexam_process if
   we trigger the condition handler and unwind.
*/
void jobexam_dump(mval *dump_filename_arg, mval *dump_file_spec)
{
	unsigned char		dump_file_name[50], *dump_file_name_ptr;
	mval			def_file_name, parms, zshowall;

	ESTABLISH(jobexam_dump_ch);

	++jobexam_counter;
	/* Setup default filename/type to use for the parse. Append processid and a counter. */
	MEMCPY_LIT(dump_file_name, DEFAULT_DUMP_FILENAME);
	dump_file_name_ptr = dump_file_name + SIZEOF(DEFAULT_DUMP_FILENAME) - 1;
	*dump_file_name_ptr++ = '_';
	dump_file_name_ptr = i2asc(dump_file_name_ptr, process_id);
	*dump_file_name_ptr++ = '_';
	dump_file_name_ptr = i2asc(dump_file_name_ptr, jobexam_counter);
	def_file_name.mvtype = MV_STR;
	def_file_name.str.addr = (char *)dump_file_name;
	def_file_name.str.len = INTCAST(dump_file_name_ptr - dump_file_name);
	/* Call $ZPARSE processing to fill in any blanks, expand concealed logicals, etc. It is the callers
	   responsibility to make sure garbage collection knows about the value in the returned filespec.
	*/
	op_fnzparse(dump_filename_arg, &empty_str_mval, &def_file_name, &empty_str_mval, &no_conceal_op, dump_file_spec);
	/* Parms of file to be created (newversion) */
	parms.mvtype = MV_STR;
	parms.str.addr = (char *)dumpable_error_dump_file_parms;
	parms.str.len = SIZEOF(dumpable_error_dump_file_parms);
	/* Open, use, and zshow into new file, then close and reset current io device */
	op_open(dump_file_spec, &parms, 0, 0);
	op_use(dump_file_spec, &parms);
	zshowall.mvtype = MV_STR;
	zshowall.str.addr = "*";
	zshowall.str.len = 1;
	op_zshow(&zshowall, ZSHOW_DEVICE, NULL);
	parms.str.addr = (char *)dumpable_error_dump_file_noparms;
	parms.str.len = SIZEOF(dumpable_error_dump_file_noparms);
	op_close(dump_file_spec, &parms);
	/* Notify operator dump was taken */
	send_msg(VARLSTCNT(5) ERR_JOBEXAMDONE, 3, process_id, dump_file_spec->str.len, dump_file_spec->str.addr);
	REVERT;
}

CONDITION_HANDLER(jobexam_dump_ch)
{
	boolean_t	save_created_core;

	START_CH;

	/* Operation:
	   1) Flush out message we came here because of to operator console
	   2) Put out our message stating that we screwed up
	   3) Unwind the errant frames so we can return to the user without screwing
	      up the task that got interrupted to do this examine.
	*/
#if defined(DEBUG) && defined(UNIX)
	if (DUMPABLE)
	{	/* For debug UNIX issues, let's make a core if we would have made one in open code */
		save_created_core = created_core;
		gtm_fork_n_core();
		created_core = save_created_core;
	}
#endif
	UNIX_ONLY(util_out_print(0, OPER));
	VMS_ONLY(sig->chf$l_sig_args -= 2);
	VMS_ONLY(callg(send_msg, &sig->chf$l_sig_args));
	send_msg(VARLSTCNT(3) ERR_JOBEXAMFAIL, 1, process_id);

	/* Stop the errors here and return to caller */
	UNIX_ONLY(util_out_print("", RESET));	/* Prevent rts_error from flushing this error later */
	DEBUG_ONLY(ok_to_UNWIND_in_exit_handling = TRUE);
	UNWIND(NULL, NULL);
}