/*
**++
** ROUTINE: sp_wrtattn_ast
**
** FUNCTIONAL DESCRIPTION:
**
** Write-attention AST routine for the subprocess output
** mailbox.
**
** RETURNS: cond_value, longword (unsigned), write only, by value
**
** PROTOTYPE:
**
** sp_wrtattn_ast(SPHANDLE ctx) (at AST level)
**
** IMPLICIT INPUTS: None.
**
** IMPLICIT OUTPUTS: None.
**
** COMPLETION CODES:
** SS$_NORMAL: normal successful completion
** Other status values from the user-provided rcvast routine are
** possible.
**
** SIDE EFFECTS: None.
**
**--
*/
static unsigned int sp_wrtattn_ast (SPHANDLE ctx) {
unsigned int status, efstate;
status = (ctx->rcvast)(ctx->astprm);
if (sys$readef(ctx->termefn, &efstate) == SS$_WASCLR)
sys$qiow(0, ctx->outchn, IO$_SETMODE|IO$M_WRTATTN, 0, 0, 0,
sp_wrtattn_ast, ctx, 0, 0, 0, 0);
return status;
}
/*
**++
** ROUTINE: sp_receive
**
** FUNCTIONAL DESCRIPTION:
**
** Get some output from the subprocess, if any. Uses IO$M_NOW modifier
** so that if there isn't anything available, we return an error status
** rather than blocking until something comes up.
**
** RETURNS: cond_value, longword (unsigned), write only, by value
**
** PROTOTYPE:
**
** sp_receive(SPHANDLE *ctxpp, struct dsc$descriptor *rcvstr,
** int *rcvlen)
**
** IMPLICIT INPUTS: None.
**
** IMPLICIT OUTPUTS: None.
**
** COMPLETION CODES:
** SS$_NORMAL: normal successful completion
** SS$_NONEXPR: subprocess doesn't exist any more
**
** SIDE EFFECTS: None.
**
**--
*/
unsigned int sp_receive (SPHANDLE *ctxpp, void *rcvstr, int *rcvlen) {
SPHANDLE ctx;
unsigned int status, efstate;
ctx = *ctxpp;
if (sys$readef(ctx->termefn, &efstate) != SS$_WASCLR) return SS$_NONEXPR;
status = sys$qiow(0, ctx->outchn, IO$_READVBLK|IO$M_NOW, ctx->iosb,
0, 0, ctx->bufptr, ctx->bufsiz, 0, 0, 0, 0);
if (OK(status)) status = ctx->iosb[0];
if (OK(status)) {
str$copy_r(rcvstr, &ctx->iosb[1], ctx->bufptr);
if (rcvlen) *rcvlen = ctx->iosb[1];
}
return status;
} /* sp_receive */
/*
**++
** ROUTINE: sp_send
**
** FUNCTIONAL DESCRIPTION:
**
** Queue up some data to be sent to the subprocess.
**
** RETURNS: cond_value, longword (unsigned), write only, by value
**
** PROTOTYPE:
**
** sp_send(SPHANDLE *ctxpp, struct dsc$descriptor *cmdstr);
**
** IMPLICIT INPUTS: None.
**
** IMPLICIT OUTPUTS: None.
**
** COMPLETION CODES:
** SS$_NORMAL: Normal successful completion.
**
** SIDE EFFECTS: None.
**
**--
*/
unsigned int sp_send (SPHANDLE *ctxpp, void *cmdstr) {
SPHANDLE ctx;
struct SPD *spd;
unsigned int status, efstate;
unsigned short cmdlen;
char *cmdadr;
ctx = *ctxpp;
if (sys$readef(ctx->termefn, &efstate) != SS$_WASCLR) return SS$_NONEXPR;
status = lib$analyze_sdesc(cmdstr, &cmdlen, &cmdadr);
if (!OK(status)) return status;
spd = get_spd(cmdlen);
if (spd == 0) return SS$_INSFMEM;
memcpy(spd->buf, cmdadr, cmdlen);
status = sys$setast(0);
queue_insert(spd, ctx->sendque.tail);
if (status == SS$_WASSET) sys$setast(1);
sys$dclast(try_to_send, ctx, 0);
return SS$_NORMAL;
} /* sp_send */
/*
* ------------------------------------------
* Hang the process for a specified time.
*
* Goes to sleep for a positive value.
* Any caught signal will terminate the sleep
* following the execution of that signal's catching routine.
*
* The actual hang duration should be NO LESS than the specified
* duration for specified durations greater than .001 seconds.
* Certain applications depend on this assumption.
*
* Arguments:
* num - time to sleep
*
* Return:
* none
* ------------------------------------------
*/
void op_hang(mval* num)
{
int ms;
double tmp;
mv_stent *mv_zintcmd;
ABS_TIME cur_time, end_time;
# ifdef VMS
uint4 time[2];
int4 efn_mask, status;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
ms = 0;
MV_FORCE_NUM(num);
if (num->mvtype & MV_INT)
{
if (0 < num->m[1])
{
assert(MV_BIAS >= 1000); /* if formats change overflow may need attention */
ms = num->m[1] * (1000 / MV_BIAS);
}
} else if (0 == num->sgn) /* if sign is not 0 it means num is negative */
{
tmp = mval2double(num) * (double)1000;
ms = ((double)MAXPOSINT4 >= tmp) ? (int)tmp : (int)MAXPOSINT4;
}
if (ms)
{
if (TREF(tpnotacidtime) * 1000 < ms)
TPNOTACID_CHECK(HANGSTR);
# if defined(DEBUG) && defined(UNIX)
if (WBTEST_ENABLED(WBTEST_DEFERRED_TIMERS) && (3 > gtm_white_box_test_case_count) && (123000 == ms))
{
DEFER_INTERRUPTS(INTRPT_NO_TIMER_EVENTS);
DBGFPF((stderr, "OP_HANG: will sleep for 20 seconds\n"));
LONG_SLEEP(20);
DBGFPF((stderr, "OP_HANG: done sleeping\n"));
ENABLE_INTERRUPTS(INTRPT_NO_TIMER_EVENTS);
return;
}
if (WBTEST_ENABLED(WBTEST_BREAKMPC)&& (0 == gtm_white_box_test_case_count) && (999 == ms))
{
frame_pointer->old_frame_pointer->mpc = (unsigned char *)GTM64_ONLY(0xdeadbeef12345678)
NON_GTM64_ONLY(0xdead1234);
return;
}
if (WBTEST_ENABLED(WBTEST_UTIL_OUT_BUFFER_PROTECTION) && (0 == gtm_white_box_test_case_count) && (999 == ms))
{ /* Upon seeing a .999s hang this white-box test launches a timer that pops with a period of
* UTIL_OUT_SYSLOG_INTERVAL and prints a long message via util_out_ptr.
*/
start_timer((TID)&util_out_syslog_dump, UTIL_OUT_SYSLOG_INTERVAL, util_out_syslog_dump, 0, NULL);
return;
}
# endif
sys_get_curr_time(&cur_time);
mv_zintcmd = find_mvstent_cmd(ZINTCMD_HANG, restart_pc, restart_ctxt, FALSE);
if (!mv_zintcmd)
add_int_to_abs_time(&cur_time, ms, &end_time);
else
{
end_time = mv_zintcmd->mv_st_cont.mvs_zintcmd.end_or_remain;
cur_time = sub_abs_time(&end_time, &cur_time); /* get remaing time to sleep */
if (0 <= cur_time.at_sec)
ms = (int4)(cur_time.at_sec * 1000 + cur_time.at_usec / 1000);
else
ms = 0; /* all done */
/* restore/pop previous zintcmd_active[ZINTCMD_HANG] hints */
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last = mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_prior;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last
= mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_ctxt_prior;
TAREF1(zintcmd_active, ZINTCMD_HANG).count--;
assert(0 <= TAREF1(zintcmd_active, ZINTCMD_HANG).count);
if (mv_chain == mv_zintcmd)
POP_MV_STENT(); /* just pop if top of stack */
else
{ /* flag as not active */
mv_zintcmd->mv_st_cont.mvs_zintcmd.command = ZINTCMD_NOOP;
mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_check = NULL;
}
if (0 == ms)
return; /* done HANGing */
}
# ifdef UNIX
if (ms < 10)
SLEEP_USEC(ms * 1000, TRUE); /* Finish the sleep if it is less than 10ms. */
else
hiber_start(ms);
# elif defined(VMS)
time[0] = -time_low_ms(ms);
time[1] = -time_high_ms(ms) - 1;
efn_mask = (1 << efn_outofband | 1 << efn_timer);
if (SS$_NORMAL != (status = sys$setimr(efn_timer, &time, NULL, &time, 0)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$setimr"), CALLFROM, status);
if (SS$_NORMAL != (status = sys$wflor(efn_outofband, efn_mask)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$wflor"), CALLFROM, status);
if (outofband)
{
if (SS$_WASCLR == (status = sys$readef(efn_timer, &efn_mask)))
{
if (SS$_NORMAL != (status = sys$cantim(&time, 0)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$cantim"),
CALLFROM, status);
} else
assertpro(SS$_WASSET == status);
}
# endif
} else
rel_quant();
if (outofband)
{
PUSH_MV_STENT(MVST_ZINTCMD);
mv_chain->mv_st_cont.mvs_zintcmd.end_or_remain = end_time;
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_check = restart_ctxt;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_check = restart_pc;
/* save current information from zintcmd_active */
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_prior = TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_prior = TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last = restart_pc;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last = restart_ctxt;
TAREF1(zintcmd_active, ZINTCMD_HANG).count++;
mv_chain->mv_st_cont.mvs_zintcmd.command = ZINTCMD_HANG;
outofband_action(FALSE);
}
return;
}
