int rts_error_csa(void *csa, int argcnt, ...)
{
va_list var;
VAR_START(var, argcnt);
return rts_error_va(csa, argcnt, var);
}
void gtm_putmsg_noflush_csa(void *csa, int argcnt, ...)
{
va_list var;
VAR_START(var, argcnt);
gtm_putmsg_list(csa, argcnt, var);
va_end(var);
}
void gtm_putmsg_csa(void *csa, int argcnt, ...)
{
va_list var;
VAR_START(var, argcnt);
gtm_putmsg_list(csa, argcnt, var);
va_end(var);
util_out_print("",TRUE);
}
int rts_error(int argcnt, ...)
{
va_list var;
sgmnt_addrs *csa;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
csa = CUSTOM_ERRORS_LOADED ? REG2CSA(gv_cur_region) : NULL;
VAR_START(var, argcnt);
return rts_error_va(csa, argcnt, var);
}
void gtm_putmsg_noflush(int argcnt, ...)
{
va_list var;
sgmnt_addrs *csa;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
csa = (ANTICIPATORY_FREEZE_AVAILABLE && jnlpool.jnlpool_ctl) ? REG2CSA(gv_cur_region) : NULL;
VAR_START(var, argcnt);
gtm_putmsg_list(csa, argcnt, var);
va_end(var);
}
void add_safe_timer_handler(int safetmr_cnt, ...)
{
int i;
va_list var;
timer_hndlr tmrhndlr;
VAR_START(var, safetmr_cnt);
for (i = 1; i <= safetmr_cnt; i++)
{
tmrhndlr = va_arg(var, timer_hndlr);
ADD_SAFE_HNDLR(tmrhndlr);
}
va_end(var);
}
void op_zmess(int4 errnum, ...)
{
va_list var;
int4 status, cnt, faocnt;
unsigned short m_len;
unsigned char faostat[4];
unsigned char msgbuff[MAX_MSG_SIZE + 1];
unsigned char buff[FAO_BUFFER_SPACE];
int4 fao[MAX_FAO_PARMS + 1];
$DESCRIPTOR(d_sp, msgbuff);
error_def(ERR_TPRETRY);
VAR_START(var, errnum);
va_count(cnt);
cnt--;
status = sys$getmsg(errnum, &m_len, &d_sp, 0, &faostat[0]);
if ((status & 1) && m_len)
{
buff[m_len] = 0;
memset(&fao[0], 0, SIZEOF(fao));
faocnt = (cnt ? faostat[1] : cnt);
faocnt = (faocnt > MAX_FAO_PARMS ? MAX_FAO_PARMS : faocnt);
if (faocnt)
faocnt = mval2fao(msgbuff, var, &fao[0], cnt, faocnt, buff, buff + SIZEOF(buff));
va_end(var);
if (faocnt != -1)
{
/* Currently there are a max of 20 fao parms (MAX_FAO_PARMS) allowed, hence passing upto fao_list[19].
* An assert is added to ensure this code is changed whenever the macro MAX_FAO_PARMS is changed.
* The # of arguments passed below should change accordingly.
*/
assert(MAX_FAO_PARMS == 20);
if (ERR_TPRETRY == errnum)
{ /* A TP restart is being signalled. Set t_fail_hist just like a TRESTART command would */
op_trestart_set_cdb_code();
}
rts_error(VARLSTCNT(MAX_FAO_PARMS + 2) errnum, faocnt, fao[0], fao[1], fao[2], fao[3], fao[4], fao[5],
fao[6], fao[7], fao[8], fao[9], fao[10], fao[11], fao[12], fao[13], fao[14], fao[15], fao[16],
fao[17], fao[18], fao[19]);
}
return;
} else
{
va_end(var);
rts_error(VARLSTCNT(1) status);
}
}
void op_zmess(int4 errnum, ...)
{
va_list var;
int4 status, cnt, faocnt;
unsigned short m_len;
unsigned char faostat[4];
unsigned char msgbuff[MAX_MSG_SIZE + 1];
unsigned char buff[FAO_BUFFER_SPACE];
int4 fao[MAX_FAO_PARMS];
$DESCRIPTOR(d_sp, msgbuff);
VAR_START(var, errnum);
va_count(cnt);
cnt--;
assert(34 == MAX_FAO_PARMS); /* Defined in fao_parm.h. */
status = sys$getmsg(errnum, &m_len, &d_sp, 0, &faostat[0]);
if ((status & 1) && m_len)
{
buff[m_len] = 0;
memset(&fao[0], 0, SIZEOF(fao));
faocnt = (cnt ? faostat[1] : cnt);
faocnt = (faocnt > MAX_FAO_PARMS ? MAX_FAO_PARMS : faocnt);
if (faocnt)
faocnt = mval2fao(msgbuff, var, &fao[0], cnt, faocnt, buff, buff + SIZEOF(buff));
va_end(var);
if (faocnt != -1)
{
if (ERR_TPRETRY == errnum)
{ /* A TP restart is being signalled. Set t_fail_hist just like a TRESTART command would */
op_trestart_set_cdb_code();
}
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(MAX_FAO_PARMS + 2) errnum, faocnt, fao[0], fao[1], fao[2], fao[3],
fao[4], fao[5], fao[6], fao[7], fao[8], fao[9], fao[10], fao[11], fao[12], fao[13], fao[14],
fao[15], fao[16], fao[17], fao[18], fao[19], fao[20], fao[21], fao[22], fao[23], fao[24], fao[25],
fao[26], fao[27], fao[28], fao[29], fao[30], fao[31], fao[32], fao[33]);
}
return;
} else
{
va_end(var);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) status);
}
}
void util_cm_print(clb_struct *lnk, int code, char *message, int flush, ...)
{
va_list var;
int4 status, i;
size_t msglen ;
VAR_START(var, flush);
if (outptr == outbuff)
{
*outptr++ = code;
}
if (message)
{
util_out_print(NULL, RESET); /* Clear any pending messages */
util_out_print_vaparm(message, NOFLUSH, var, MAXPOSINT4);
msglen = (size_t)((char *)util_outptr - (char *)util_outbuff);
memcpy(outptr, util_outbuff, msglen);
outptr += msglen;
}
va_end(last_va_list_ptr);
va_end(var);
switch (flush)
{
case NOFLUSH:
break;
case FLUSH :
*outptr++ = 0 ;
lnk->mbf = outbuff ;
lnk->cbl = outptr - outbuff ;
lnk->ast = 0 ;
status = cmi_write(lnk) ;
PROPER(code, status) ;
/* Note: fall into reset.. */
case RESET :
outptr = outbuff ;
break;
default :
break ;
}
return;
}
void op_zmess(unsigned int cnt, ...)
{
va_list var;
const err_ctl *ectl;
const err_msg *eptr;
UINTPTR_T fao[MAX_FAO_PARMS];
char buff[FAO_BUFFER_SPACE];
unsigned int errnum, j;
int faocnt;
error_def(ERR_TPRETRY);
VAR_START(var, cnt);
errnum = va_arg(var, int);
cnt--;
if (ectl = err_check(errnum))
{
assert((errnum & FACMASK(ectl->facnum)) && (MSGMASK(errnum, ectl->facnum) <= ectl->msg_cnt));
j = MSGMASK(errnum, ectl->facnum);
eptr = ectl->fst_msg + j - 1;
faocnt = eptr->parm_count;
faocnt = (faocnt > MAX_FAO_PARMS ? MAX_FAO_PARMS : faocnt);
faocnt = mval2fao(eptr->msg, var, &fao[0], cnt, faocnt, buff, buff + SIZEOF(buff));
va_end(var);
if (faocnt != -1)
{
if (ERR_TPRETRY == errnum)
{ /* A TP restart is being signalled. Set t_fail_hist just like a TRESTART command would */
op_trestart_set_cdb_code();
}
rts_error(VARLSTCNT(faocnt+2) errnum, faocnt, fao[0], fao[1], fao[2], fao[3], fao[4], fao[5], fao[6],
fao[7], fao[8], fao[9], fao[10], fao[11]);
}
} else
{
va_end(var);
rts_error(VARLSTCNT(1) errnum);
}
}
void dec_err(uint4 argcnt, ...)
{
va_list var;
uint4 i, j, count, err;
const err_ctl *ec;
const err_msg *em;
char msgbuff[2048];
mstr msgstr;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
util_out_print(0, RESET, 0); /* reset the buffer */
VAR_START(var, argcnt);
assert (argcnt >= 1);
err = va_arg(var, uint4);
ec = err_check(err);
em = NULL;
if (ec)
GET_MSG_INFO(err, ec, em);
msgstr.addr = msgbuff;
msgstr.len = SIZEOF(msgbuff);
gtm_getmsg(err, &msgstr);
if (!em)
util_out_print(msgstr.addr, FLUSH, 1, err);
else
{
argcnt--;
if (argcnt)
{
count = va_arg(var, int4);
assert (count <= argcnt);
} else
count = 0;
util_out_print_vaparm(msgstr.addr, FLUSH, var, count);
va_end(TREF(last_va_list_ptr));
}
va_end(var);
}
void sgtm_putmsg(char *out_str, ...)
{
va_list var;
int arg_count, dummy, fao_actual, fao_count, fao_list[MAX_FAO_PARMS + 1], i, msg_id;
char msg_buffer[1024];
mstr msg_string;
int util_outbufflen;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
VAR_START(var, out_str);
va_count(arg_count);
arg_count--;
assert(arg_count > 0);
util_out_print(NULL, RESET);
for (;;)
{
msg_id = va_arg(var, int);
--arg_count;
msg_string.addr = msg_buffer;
msg_string.len = SIZEOF(msg_buffer);
gtm_getmsg(msg_id, &msg_string);
if (arg_count > 0)
{
fao_actual = va_arg(var, int);
--arg_count;
fao_count = fao_actual;
if (fao_count > MAX_FAO_PARMS)
{
assert(FALSE);
fao_count = MAX_FAO_PARMS;
}
}
else
void op_fnzcall(mval *dst, ...)
{
va_list var;
mval *v;
int4 n_mvals; /* number of input parameters supplied in $ZCALL command */
int i;
mval *mvallist[256];
zctabrtn *zcrtn;
unsigned char *lastout;
error_def (ERR_ZCALLTABLE);
error_def (ERR_ZCRTENOTF);
error_def (ERR_ZCARGMSMTCH);
VAR_START(var, dst);
va_count(n_mvals);
v = va_arg(var, mval *);
MV_FORCE_STR(v);
zcrtn = zctab;
while (zcrtn < zctab_end)
{
if (!zcrtn->entry_length)
{
va_end(var);
rts_error(VARLSTCNT(1) ERR_ZCALLTABLE);
}
if (zcrtn->callnamelen == 0)
{
va_end(var);
rts_error(VARLSTCNT(1) ERR_ZCALLTABLE);
}
if ((zcrtn->callnamelen == v->str.len) &&
!memcmp (zcrtn->callname, v->str.addr, v->str.len))
break;
zcrtn = (zctabrtn *) ((char *) zcrtn + zcrtn->entry_length);
}
if (zcrtn == zctab_end)
{
va_end(var);
rts_error(VARLSTCNT(4) ERR_ZCRTENOTF, 2, v->str.len, v->str.addr);
}
n_mvals -= 2;
if (n_mvals > zcrtn->n_inputs)
{
va_end(var);
rts_error(VARLSTCNT(4) ERR_ZCARGMSMTCH, 2, n_mvals, zcrtn->n_inputs);
}
lastout = (unsigned char *) zcrtn
+ ROUND_UP(SIZEOF(zctabrtn) + zcrtn->callnamelen - 1 + SIZEOF(zctabret), SIZEOF(int4))
+ zcrtn->n_inputs * SIZEOF(zctabinput)
+ zcrtn->n_outputs * SIZEOF(zctaboutput);
if (ROUND_UP((int) lastout + 1, SIZEOF(int4)) != (unsigned char *) zcrtn + zcrtn->entry_length)
{
va_end(var);
rts_error(VARLSTCNT(1) ERR_ZCALLTABLE);
}
for (i = 0; i < n_mvals; ++i)
mvallist[i] = va_arg(var, mval *);
va_end(var);
zc_makespace (dst, 0, mvallist, &mvallist[n_mvals], zcrtn, *lastout);
return;
}
/*
* ---------------------------------------------------
* Job command main entry point
* ---------------------------------------------------
*/
int op_job(int4 argcnt, ...)
{
va_list var;
int4 i;
mval *label, *inp;
int4 offset;
mval *routine, *param_buf;
int4 timeout; /* timeout in seconds */
int4 msec_timeout; /* timeout in milliseconds */
boolean_t timed, single_attempt, non_exit_return;
unsigned char buff[128], *c;
int4 status, exit_stat, term_sig, stop_sig;
pid_t zjob_pid = 0; /* zjob_pid should exactly match in type with child_pid(ojstartchild.c) */
int pipe_fds[2], pipe_status;
# ifdef _BSD
union wait wait_stat;
# else
int4 wait_stat;
# endif
job_params_type job_params;
char combuf[128];
mstr command;
job_parm *jp;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
VAR_START(var, argcnt);
assert(argcnt >= 5);
label = va_arg(var, mval *);
offset = va_arg(var, int4);
routine = va_arg(var, mval *);
param_buf = va_arg(var, mval *);
timeout = va_arg(var, int4); /* in seconds */
argcnt -= 5;
/* initialize $zjob = 0, in case JOB fails */
dollar_zjob = 0;
MV_FORCE_DEFINED(label);
MV_FORCE_DEFINED(routine);
MV_FORCE_DEFINED(param_buf);
/* create a pipe to channel the PID of the jobbed off process(J) from middle level
* process(M) to the current process (P)
*/
OPEN_PIPE(pipe_fds, pipe_status);
if (-1 == pipe_status)
{
va_end(var);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(7) ERR_JOBFAIL, 0, ERR_TEXT, 2, LEN_AND_LIT("Error creating pipe"), errno);
}
jobcnt++;
command.addr = &combuf[0];
/* Setup job parameters by parsing param_buf and using label, offset, routine, & timeout). */
job_params.routine = routine->str;
job_params.label = label->str;
job_params.offset = offset;
ojparams(param_buf->str.addr, &job_params);
/*
* Verify that entryref to JOB command is not NULL.
*/
if (!job_params.routine.len)
{
va_end(var);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_JOBFAIL, 0, ERR_NULLENTRYREF, 0);
}
/* Clear the buffers */
flush_pio();
/* Start the timer */
ojtimeout = FALSE;
if (timeout < 0)
timeout = 0;
else if (TREF(tpnotacidtime) < timeout)
TPNOTACID_CHECK(JOBTIMESTR);
if (NO_M_TIMEOUT == timeout)
{
timed = FALSE;
msec_timeout = NO_M_TIMEOUT;
} else
{
timed = TRUE;
msec_timeout = timeout2msec(timeout);
if (msec_timeout > 0)
start_timer((TID)&tid, msec_timeout, job_timer_handler, 0, NULL);
}
if (argcnt)
{
jp = job_params.parms = (job_parm *)malloc(SIZEOF(job_parm) * argcnt);
i = argcnt;
for(;;)
{
inp = va_arg(var, mval *);
jp->parm = inp;
if (0 == --i)
break;
jp->next = jp + 1;
jp = jp->next;
}
jp->next = 0;
} else
