/* Set ^#t(<gbl>,"#TRHASH",hash_code,nnn)=<gbl>_$c(0)_trigindx where gv_currkey is ^#t(<gbl>).
* Note: This routine has code very similar to that in "add_trigger_hash_entry". There is just
* not enough commonality to justify merging the two.
*/
STATICFNDEF void gvtr_set_hashtrhash(char *trigvn, int trigvn_len, uint4 hash_code, int trigindx)
{
uint4 curend;
mval mv_indx, *mv_indx_ptr;
mval mv_hash;
int hash_indx, num_len;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
char *ptr;
char indx_str[MAX_DIGITS_IN_INT];
uint4 len;
int4 result;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
curend = gv_currkey->end; /* note down gv_currkey->end before changing it so we can restore it before function returns */
assert(KEY_DELIMITER == gv_currkey->base[curend]);
assert(gv_target->gd_csa == cs_addrs);
/* Set ^#t(<gvn>,"#TRHASH",kill_hash_code,i). To do that, first determine the
* highest i such that ^#t(<gvn>,"#TRHASH",kill_hash_code,i) exists. Set
* ^#t(<gvn>,"#TRHASH",kill_hash_code,i+1)=kill_hash_code in that case.
*/
MV_FORCE_UMVAL(&mv_hash, hash_code);
BUILD_HASHT_SUB_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, "", 0);
op_zprevious(&mv_indx);
mv_indx_ptr = &mv_indx;
hash_indx = (0 == mv_indx.str.len) ? 1 : (mval2i(mv_indx_ptr) + 1);
i2mval(mv_indx_ptr, hash_indx);
MV_FORCE_STR(mv_indx_ptr);
/* Prepare the value of the SET */
num_len = 0;
I2A(indx_str, num_len, trigindx);
assert(MAX_MIDENT_LEN >= trigvn_len);
memcpy(name_and_index, trigvn, trigvn_len);
ptr = name_and_index + trigvn_len;
*ptr++ = '\0';
memcpy(ptr, indx_str, num_len);
len = trigvn_len + 1 + num_len;
/* Do the SET */
SET_TRIGGER_GLOBAL_SUB_SUB_MSUB_MSUB_STR(trigvn, trigvn_len,
LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, mv_indx, name_and_index, len, result);
assert(PUT_SUCCESS == result);
gv_currkey->end = curend; /* reset gv_currkey->end to what it was at function entry */
gv_currkey->base[curend] = KEY_DELIMITER; /* restore terminator for entire key so key is well-formed */
return;
}
void op_fngetjpi(mint jpid, mval *keyword, mval *ret)
{
out_struct out_quad;
int4 out_long, jpi_code, pid;
short index, length, slot, last_slot, out_len;
uint4 status;
char upcase[MAX_KEY_LEN];
$DESCRIPTOR(out_string, "");
error_def(ERR_BADJPIPARAM);
assert (stringpool.free >= stringpool.base);
assert (stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(MAX_JPI_STRLEN);
MV_FORCE_STR(keyword);
if (keyword->str.len == 0)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, 4, "Null");
if (keyword->str.len > MAX_KEY_LEN)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr );
lower_to_upper((uchar_ptr_t)upcase, (uchar_ptr_t)keyword->str.addr, keyword->str.len);
if ((index = upcase[0] - 'A') < MIN_INDEX || index > MAX_INDEX)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr );
/* Before checking if it is a VMS JPI attribute, check if it is GT.M specific "ISPROCALIVE" attribute */
if ((keyword->str.len == STR_LIT_LEN("ISPROCALIVE")) && !memcmp(upcase, "ISPROCALIVE", keyword->str.len))
{
out_long = (0 != jpid) ? is_proc_alive(jpid, 0) : 1;
i2mval(ret, out_long);
return;
}
/* Check if it is a VMS JPI attribute */
slot = jpi_index_table[ index ].index;
last_slot = jpi_index_table[ index ].len;
jpi_code = 0;
/* future enhancement:
* (i) since keywords are sorted, we can exit the for loop if 0 < memcmp.
* (ii) also, the current comparison relies on kwd->str.len which means a C would imply CPUTIM instead of CSTIME
* or CUTIME this ambiguity should probably be removed by asking for an exact match of the full keyword
*/
for ( ; slot < last_slot ; slot++ )
{
if (jpi_param_table[ slot ].len == keyword->str.len
&& !(memcmp(jpi_param_table[ slot ].name, upcase, keyword->str.len)))
{
jpi_code = jpi_param_table[ slot ].item_code;
break;
}
}
if (!jpi_code)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, keyword->str.len, keyword->str.addr);
assert (jpid >= 0);
switch( jpi_code )
{
/* **** This is a fall through for all codes that require a string returned **** */
case JPI$_ACCOUNT:
case JPI$_AUTHPRIV:
case JPI$_CLINAME:
case JPI$_CURPRIV:
case JPI$_IMAGNAME:
case JPI$_IMAGPRIV:
case JPI$_PRCNAM:
case JPI$_PROCPRIV:
case JPI$_TABLENAME:
case JPI$_TERMINAL:
case JPI$_USERNAME:
out_string.dsc$a_pointer = stringpool.free;
out_string.dsc$w_length = MAX_JPI_STRLEN;
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,0
,&out_string
,&out_len )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status ); /* need a more specific GTM error message here and below */
}
ret->str.addr = stringpool.free;
ret->str.len = out_len;
ret->mvtype = MV_STR;
stringpool.free += out_len;
assert (stringpool.top >= stringpool.free);
assert (stringpool.free >= stringpool.base);
return;
case JPI$_LOGINTIM:
{ int4 days;
int4 seconds;
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,&out_quad
,0
,0 )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
if ((status = lib$day( &days
,&out_quad
,&seconds)) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
days += DAYS;
seconds /= CENTISECONDS;
ret->str.addr = stringpool.free;
stringpool.free = i2s(&days);
*stringpool.free++ = ',';
stringpool.free = i2s(&seconds);
ret->str.len = (char *) stringpool.free - ret->str.addr;
ret->mvtype = MV_STR;
return;
}
default:
if ((status = lib$getjpi( &jpi_code
,&jpid
,0
,&out_long
,0
,0 )) != SS$_NORMAL)
{ rts_error(VARLSTCNT(1) status );
}
i2mval(ret, out_long) ;
return;
}
}
/* Upgrade ^#t global in "reg" region */
void trigger_upgrade(gd_region *reg)
{
boolean_t est_first_pass, do_upgrade, is_defined;
boolean_t was_null = FALSE, is_null = FALSE;
int seq_num, trig_seq_num;
int currlabel;
mval tmpmval, xecuteimval, *gvname, *tmpmv, *tmpmv2;
int4 result, tmpint4;
uint4 curend, gvname_prev, xecute_curend;
uint4 hash_code, kill_hash_code;
int count, i, xecutei, tncount;
char *trigname, *trigindex, *ptr;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
char trigvn[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT], nullbyte[1];
uint4 trigname_len, name_index_len;
int ilen;
sgmnt_addrs *csa;
jnl_private_control *jpc;
uint4 sts;
int close_res;
hash128_state_t hash_state, kill_hash_state;
uint4 hash_totlen, kill_hash_totlen;
int trig_protected_mval_push_count;
# ifdef DEBUG
int save_dollar_tlevel;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(gv_cur_region == reg);
assert(!dollar_tlevel); /* caller should have ensured this. this is needed as otherwise things get complicated. */
assert(!is_replicator); /* caller should have ensured this. this is needed so we dont bump jnl_seqno (if replicating) */
csa = &FILE_INFO(reg)->s_addrs;
assert(csa->hdr->hasht_upgrade_needed);
/* If before-image journaling is turned on in this region (does not matter if replication is turned on or not),
* once this transaction is done, we need to switch to new journal file and cut the back link because
* otherwise it is possible for backward journal recovery (or rollback) or source server to encounter
* the journal records generated in this ^#t-upgrade-transaction in which case they dont know to handle
* it properly (e.g. rollback or backward recovery does not know to restore csa->hdr->hasht_upgrade_needed
* if it rolls back this transaction). To achieve this, we set hold_onto_crit to TRUE and do the jnl link
* cut AFTER the transaction commits but before anyone else can sneak in to do any more updates.
* Since most often we expect databases to be journaled, we do this hold_onto_crit even for the non-journaled case.
*/
grab_crit(reg);
csa->hold_onto_crit = TRUE;
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
assert(!donot_INVOKE_MUMTSTART);
DEBUG_ONLY(donot_INVOKE_MUMTSTART = TRUE);
op_tstart(IMPLICIT_TSTART, TRUE, &literal_batch, 0); /* 0 ==> save no locals but RESTART OK */
ESTABLISH_NORET(trigger_upgrade_ch, est_first_pass);
/* On a TP restart anywhere down below, this line is where the restart resumes execution from */
assert(donot_INVOKE_MUMTSTART); /* Make sure still set for every try/retry of TP transaction */
change_reg(); /* TP_CHANGE_REG wont work as we need to set sgm_info_ptr */
assert(NULL != cs_addrs);
assert(csa == cs_addrs);
SET_GVTARGET_TO_HASHT_GBL(csa); /* sets up gv_target */
assert(NULL != gv_target);
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED; /* Needed to do every retry in case restart was due to an online rollback.
* This also sets up gv_currkey */
/* Do actual upgrade of ^#t global.
*
* Below is a sample layout of the label 2 ^#t global
* -------------------------------------------------------
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("#TRHASH",89771515,1)="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("#TRHASH",106937755,1)="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("a",1,"BHASH")="106937755"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="89771515"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="1"
* ^#t("a","#LABEL")="2"
*
* Below is a sample layout of the label 3 ^#t global
* -------------------------------------------------------
* ^#t("#LABEL")="3" (present only after upgrade, not regular trigger load)
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in CURRENT region)
* ^#t("a",1,"BHASH")="71945627"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="71945627"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="2"
* ^#t("a","#LABEL")="3"
* ^#t("a","#TRHASH",71945627,1)="a"_$C(0)_"1"
*
* Key aspects of the format change
* ----------------------------------
* 1) New ^#t("#LABEL")="3" to indicate the format of the ^#t global. This is in addition to
* ^#t("a","#LABEL") etc. which is already there. This way we have a #LABEL for not just the installed
* triggers but also for the name information stored in the #TNAME nodes.
* 2) In the BHASH and LHASH fields. The hash computation is different so there are more chances of BHASH and LHASH
* matching in which case we store only one #TRHASH entry (instead of two). So thre is fewer ^#t records in the new
* format in most cases.
* 3) ^#t("a","#LABEL") bumps from 2 to 3. Similarly ^#t("a","#CYCLE") bumps by one (to make sure triggers for this
* global get re-read if and when we implement an -ONLINE upgrade).
* 4) DEFAULT used to have ^#t("#TNAME",...) nodes corresponding to triggers across ALL regions in the gbldir and
* other regions used to have NO ^#t("#TNAME",...) nodes whereas after the upgrade every region have
* ^#t("#TNAME",...) nodes corresponding to triggers installed in that region. So it is safer to kill ^#t("#TNAME")
* nodes and add them as needed.
* 5) #TRHASH has moved from ^#t() to ^#t(<gbl>). So it is safer to kill ^#t("#TRHASH") nodes and add them as needed.
*
* Below is a sample layout of the label 4 ^#t global
* -------------------------------------------------------
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in CURRENT region)
* ^#t("a",1,"BHASH")="71945627"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="71945627"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="2"
* ^#t("a","#LABEL")="4"
* ^#t("a","#TRHASH",71945627,1)="a"_$C(0)_"1"
*
* Key aspects of the format change
* ----------------------------------
* 1) Removed ^#t("#LABEL") as it is redundant information and trigger load does not include it
* 2) Multiline triggers were incorrectly processed resulting in incorrect BHASH and LHASH values. Upgrade fixes this
* 3) ^#t("a","#LABEL") bumps from 3 to 4. Similarly ^#t("a","#CYCLE") bumps by one (to make sure
* triggers for this global get re-read if and when we implement an -ONLINE upgrade).
*/
tmpmv = &tmpmval; /* At all points maintain this relationship. The two are used interchangeably below */
if (gv_target->root)
do_upgrade = TRUE;
/* The below logic assumes ^#t global does not have any integrity errors */
assert(do_upgrade); /* caller should have not invoked us otherwise */
if (do_upgrade)
{ /* kill ^#t("#TRHASH"), ^#t("#TNAME") and ^#t("#LABEL") first. Regenerate each again as we process ^#t(<gbl>,...) */
csa->incr_db_trigger_cycle = TRUE; /* so that we increment csd->db_trigger_cycle at commit time.
* this forces concurrent processes to read upgraded triggers.
*/
if (JNL_WRITE_LOGICAL_RECS(csa))
{ /* Note that the ^#t upgrade is a physical layout change. But it has no logical change (i.e. users
* see the same MUPIP TRIGGER -SELECT output as before). So write only a dummy LGTRIG journal
* record for this operation. Hence write a string that starts with a trigger comment character ";".
*/
assert(!gv_cur_region->read_only);
jnl_format(JNL_LGTRIG, NULL, (mval *)&literal_trigjnlrec, 0);
}
/* KILL ^#t("#LABEL") unconditionally */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* KILL ^#t("#TNAME") unconditionally and regenerate */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* KILL ^#t("#TRHASH") unconditionally and regenerate */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* Loop through all global names for which ^#t(<gvn>) exists. The only first-level subscripts of ^#t starting
* with # are #TNAME and #TRHASH in collation order. So after #TRHASH we expect to find subscripts that are
* global names. Hence the HASHTRHASH code is placed AFTER the HASHTNAME code above.
*/
TREF(gd_targ_gvnh_reg) = NULL; /* needed so op_gvorder below goes through gvcst_order (i.e. focuses only
* on the current region) and NOT through gvcst_spr_order (which does not
* apply anyways in the case of ^#t).
*/
nullbyte[0] = '\0';
trig_protected_mval_push_count = 0;
INCR_AND_PUSH_MV_STENT(gvname); /* Protect gvname from garbage collection */
do
{
op_gvorder(gvname);
if (0 == gvname->str.len)
break;
assert(ARRAYSIZE(trigvn) > gvname->str.len);
memcpy(&trigvn[0], gvname->str.addr, gvname->str.len);
gvname->str.addr = &trigvn[0]; /* point away from stringpool to avoid stp_gcol issues */
/* Save gv_currkey->prev so it is restored before next call to op_gvorder (which cares about this field).
* gv_currkey->prev gets tampered with in the for loop below (e.g. BUILD_HASHT_SUB_CURRKEY macro).
* No need to do this for gv_currkey->end since the body of the for loop takes care of restoring it.
*/
gvname_prev = gv_currkey->prev;
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
/* Increment ^#t(<gvn>,"#CYCLE") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashcycle, tmpmv);
assert(is_defined);
tmpint4 = mval2i(tmpmv);
tmpint4++;
i2mval(tmpmv, tmpint4);
gvtr_set_hasht_gblsubs((mval *)&literal_hashcycle, tmpmv);
/* Read ^#t(<gvn>,"#COUNT") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashcount, tmpmv);
if (is_defined)
{
tmpint4 = mval2i(tmpmv);
count = tmpint4;
/* Get ^#t(<gvn>,"#LABEL"), error out for invalid values. Upgrade disallowed for label 1 triggers */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashlabel, tmpmv);
assert(is_defined);
currlabel = mval2i(tmpmv);
if ((V19_HASHT_GBL_LABEL_INT >= currlabel) || (HASHT_GBL_CURLABEL_INT <= currlabel))
rts_error_csa(CSA_ARG(csa) VARLSTCNT(8) ERR_TRIGUPBADLABEL, 6, currlabel,
HASHT_GBL_CURLABEL_INT, gvname->str.len, gvname->str.addr,
REG_LEN_STR(reg));
/* Set ^#t(<gvn>,"#LABEL")=HASHT_GBL_CURLABEL */
gvtr_set_hasht_gblsubs((mval *)&literal_hashlabel, (mval *)&literal_curlabel);
} else
count = 0;
/* Kill ^#t(<gvn>,"#TRHASH") unconditionally and regenerate */
gvtr_kill_hasht_gblsubs((mval *)&literal_hashtrhash, TRUE);
/* At this point, gv_currkey is ^#t(<gvn>) */
for (i = 1; i <= count; i++)
{
/* At this point, gv_currkey is ^#t(<gvn>) */
curend = gv_currkey->end; /* note gv_currkey->end before changing it so we can restore it later */
assert(KEY_DELIMITER == gv_currkey->base[curend]);
assert(gv_target->gd_csa == cs_addrs);
i2mval(tmpmv, i);
COPY_SUBS_TO_GVCURRKEY(tmpmv, gv_cur_region, gv_currkey, was_null, is_null);
/* At this point, gv_currkey is ^#t(<gvn>,i) */
/* Compute new LHASH and BHASH hash values.
* LHASH uses : GVSUBS, XECUTE
* BHASH uses : GVSUBS, DELIM, ZDELIM, PIECES, XECUTE
* So reach each of these pieces and compute hash along the way.
*/
STR_PHASH_INIT(hash_state, hash_totlen);
STR_PHASH_PROCESS(hash_state, hash_totlen, gvname->str.addr, gvname->str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
/* Read in ^#t(<gvn>,i,"GVSUBS") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_gvsubs, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Copy over SET hash state (2-tuple <state,totlen>) to KILL hash state before adding
* the PIECES, DELIM, ZDELIM portions (those are only part of the SET hash).
*/
kill_hash_state = hash_state;
kill_hash_totlen = hash_totlen;
/* Read in ^#t(<gvn>,i,"PIECES") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_pieces, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"DELIM") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_delim, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"ZDELIM") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_zdelim, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"XECUTE").
* Note: The XECUTE portion of the trigger definition is used in SET and KILL hash.
* But since we have started maintaining "hash_state" and "kill_hash_state" separately
* (due to PIECES, DELIM, ZDELIM) we need to update the hash for both using same input string.
*/
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_xecute, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(kill_hash_state, kill_hash_totlen, tmpmval.str.addr, tmpmval.str.len);
} else
{ /* Multi-record XECUTE string */
/* At this point, gv_currkey is ^#t(<gvn>,i) */
xecute_curend = gv_currkey->end; /* note gv_currkey->end so we can restore it later */
assert(KEY_DELIMITER == gv_currkey->base[xecute_curend]);
tmpmv2 = (mval *)&literal_xecute;
COPY_SUBS_TO_GVCURRKEY(tmpmv2, gv_cur_region, gv_currkey, was_null, is_null);
xecutei = 1;
do
{
i2mval(&xecuteimval, xecutei);
is_defined = gvtr_get_hasht_gblsubs(&xecuteimval, tmpmv);
if (!is_defined)
break;
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(kill_hash_state, kill_hash_totlen,
tmpmval.str.addr, tmpmval.str.len);
xecutei++;
} while (TRUE);
/* Restore gv_currkey to ^#t(<gvn>,i) */
gv_currkey->end = xecute_curend;
gv_currkey->base[xecute_curend] = KEY_DELIMITER;
}
STR_PHASH_RESULT(hash_state, hash_totlen, hash_code);
STR_PHASH_RESULT(kill_hash_state, kill_hash_totlen, kill_hash_code);
/* Set ^#t(<gvn>,i,"LHASH") */
MV_FORCE_UMVAL(tmpmv, kill_hash_code);
gvtr_set_hasht_gblsubs((mval *)&literal_lhash, tmpmv);
/* Set ^#t(<gvn>,i,"BHASH") */
MV_FORCE_UMVAL(tmpmv, hash_code);
gvtr_set_hasht_gblsubs((mval *)&literal_bhash, tmpmv);
/* Read in ^#t(<gvn>,i,"TRIGNAME") to determine if #SEQNUM/#TNCOUNT needs to be maintained */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_trigname, tmpmv);
assert(is_defined);
assert('#' == tmpmval.str.addr[tmpmval.str.len - 1]);
tmpmval.str.len--;
if ((tmpmval.str.len <= ARRAYSIZE(name_and_index)) &&
(NULL != (ptr = memchr(tmpmval.str.addr, '#', tmpmval.str.len))))
{ /* Auto-generated name. Need to maintain #SEQNUM/#TNCOUNT */
/* Take copy of trigger name into non-stringpool location to avoid stp_gcol issues */
trigname_len = ptr - tmpmval.str.addr;
ptr++;
name_index_len = (tmpmval.str.addr + tmpmval.str.len) - ptr;
assert(ARRAYSIZE(name_and_index) >= (trigname_len + 1 + name_index_len));
trigname = &name_and_index[0];
trigindex = ptr;
memcpy(trigname, tmpmval.str.addr, tmpmval.str.len);
A2I(ptr, ptr + name_index_len, trig_seq_num);
/* At this point, gv_currkey is ^#t(<gvn>,i) */
/* $get(^#t("#TNAME",<trigger name>,"#SEQNUM")) */
BUILD_HASHT_SUB_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHSEQNUM, STR_LIT_LEN(LITERAL_HASHSEQNUM));
seq_num = gvcst_get(tmpmv) ? mval2i(tmpmv) : 0;
if (trig_seq_num > seq_num)
{ /* Set ^#t("#TNAME",<trigger name>,"#SEQNUM") = trig_seq_num */
SET_TRIGGER_GLOBAL_SUB_SUB_SUB_STR(LITERAL_HASHTNAME,
STR_LIT_LEN(LITERAL_HASHTNAME), trigname, trigname_len,
LITERAL_HASHSEQNUM, STR_LIT_LEN(LITERAL_HASHSEQNUM),
trigindex, name_index_len, result);
assert(PUT_SUCCESS == result);
}
/* set ^#t("#TNAME",<trigger name>,"#TNCOUNT")++ */
BUILD_HASHT_SUB_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHTNCOUNT, STR_LIT_LEN(LITERAL_HASHTNCOUNT));
tncount = gvcst_get(tmpmv) ? mval2i(tmpmv) + 1 : 1;
i2mval(tmpmv, tncount);
SET_TRIGGER_GLOBAL_SUB_SUB_SUB_MVAL(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHTNCOUNT, STR_LIT_LEN(LITERAL_HASHTNCOUNT),
tmpmval, result);
trigname_len += 1 + name_index_len; /* in preparation for ^#t("#TNAME") set below */
assert(PUT_SUCCESS == result);
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
} else
{
/* Take copy of trigger name into non-stringpool location to avoid stp_gcol issues */
trigname = &name_and_index[0]; /* in preparation for ^#t("#TNAME") set below */
trigname_len = MIN(tmpmval.str.len, ARRAYSIZE(name_and_index));
assert(ARRAYSIZE(name_and_index) >= trigname_len);
memcpy(trigname, tmpmval.str.addr, trigname_len);
/* Restore gv_currkey to what it was at beginning of for loop iteration */
gv_currkey->end = curend;
gv_currkey->base[curend] = KEY_DELIMITER;
}
/* At this point, gv_currkey is ^#t(<gvn>) */
if (kill_hash_code != hash_code)
gvtr_set_hashtrhash(gvname->str.addr, gvname->str.len, kill_hash_code, i);
/* Set ^#t(<gvn>,"#TRHASH",hash_code,i) */
gvtr_set_hashtrhash(gvname->str.addr, gvname->str.len, hash_code, i);
/* Set ^#t("#TNAME",<trigname>)=<gvn>_$c(0)_<trigindx> */
/* The upgrade assumes that the region does not contain two triggers with the same name.
* V62000 and before could potentially have this out of design case. Once implemented
* the trigger integrity check will warn users of this edge case */
ptr = &trigvn[gvname->str.len];
*ptr++ = '\0';
ilen = 0;
I2A(ptr, ilen, i);
ptr += ilen;
assert(ptr <= ARRAYTOP(trigvn));
SET_TRIGGER_GLOBAL_SUB_SUB_STR(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, trigvn, ptr - gvname->str.addr, result);
assert(PUT_SUCCESS == result);
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
}
/* At this point, gv_currkey is ^#t(<gvn>) i.e. gv_currkey->end is correct but gv_currkey->prev
* might have been tampered with. Restore it to proper value first.
*/
gv_currkey->prev = gvname_prev;
gvname->mvtype = 0; /* can now be garbage collected in the next iteration */
} while (TRUE);
}
op_tcommit();
REVERT; /* remove our condition handler */
DEBUG_ONLY(donot_INVOKE_MUMTSTART = FALSE;)
if (csa->hold_onto_crit)
int4 trigger_delete(char *trigvn, int trigvn_len, mval *trigger_count, int index)
{
int count;
mval *mv_cnt_ptr;
mval mv_val;
mval *mv_val_ptr;
int num_len;
char *ptr1;
int4 result;
int4 retval;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
stringkey kill_hash, set_hash;
int sub_indx;
char tmp_trig_str[MAX_BUFF_SIZE];
int4 trig_len;
char trig_name[MAX_TRIGNAME_LEN];
int trig_name_len;
int tmp_len;
char *tt_val[NUM_SUBS];
uint4 tt_val_len[NUM_SUBS];
mval trigger_value;
mval trigger_index;
mval xecute_index;
uint4 xecute_idx;
uint4 used_trigvn_len;
mval val;
char val_str[MAX_DIGITS_IN_INT + 1];
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
mv_val_ptr = &mv_val;
MV_FORCE_MVAL(&trigger_index, index);
count = MV_FORCE_INT(trigger_count);
/* build up array of values - needed for comparison in hash stuff */
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
for (sub_indx = 0; sub_indx < NUM_SUBS; sub_indx++)
{
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
trig_len = gvcst_get(&trigger_value) ? trigger_value.str.len : 0;
if (0 == trig_len)
{
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
if (TRIGNAME_SUB == sub_indx)
{
trig_name_len = trig_len;
assert(MAX_TRIGNAME_LEN >= trig_len);
memcpy(trig_name, trigger_value.str.addr, trig_name_len);
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
return VAL_TOO_LONG;
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
/* Get trigger name, set hash value, and kill hash values from trigger before we delete it.
* The values will be used in clean ups associated with the deletion
*/
/* $get(^#t(GVN,trigger_index,"LHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (gvcst_get(mv_val_ptr))
kill_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
else {
util_out_print_gtmio("The LHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
kill_hash.hash_code = 0;
}
/* $get(^#t(GVN,trigger_index,"BHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (gvcst_get(mv_val_ptr))
set_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
else {
util_out_print_gtmio("The BHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
set_hash.hash_code = 0;
}
/* kill ^#t(GVN,trigger_index) */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, trigger_index);
gvcst_kill(TRUE);
assert(0 == gvcst_data());
if (1 == count)
{ /* This is the last trigger for "trigvn" - clean up trigger name, remove #LABEL and #COUNT */
assert(1 == index);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
gvcst_kill(TRUE);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
gvcst_kill(TRUE);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, 0);
} else
{
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
if (index != count)
{ /* Shift the last trigger (index is #COUNT value) to the just deleted trigger's index.
* This way count is always accurate and can still be used as the index for new triggers.
* Note - there is no dependence on the trigger order, or this technique wouldn't work.
*/
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
for (sub_indx = 0; sub_indx < NUM_TOTAL_SUBS; sub_indx++)
{
/* $get(^#t(GVN,trigger_count,sub_indx) */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
if (gvcst_get(&trigger_value))
{
trig_len = trigger_value.str.len;
/* set ^#t(GVN,trigger_index,sub_indx)=^#t(GVN,trigger_count,sub_indx) */
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), trigger_value, result);
assert(PUT_SUCCESS == result);
} else if (XECUTE_SUB == sub_indx)
{ /* multi line trigger broken up because it exceeds record size */
for (xecute_idx = 0; ; xecute_idx++)
{
i2mval(&xecute_index, xecute_idx);
BUILD_HASHT_SUB_MSUB_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index);
if (!gvcst_get(&trigger_value))
break;
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MSUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index,
trigger_value, result);
assert(PUT_SUCCESS == result);
}
assert (xecute_idx >= 2); /* multi-line trigger, indices 0, 1 and 2 MUST be defined */
} else
{
/* in PRO this is a nasty case that will result in an access violation
* because data that should be present is not. In the next go around
* with trigger installation this case should be handled better */
assert(!((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) ||
(CHSET_SUB == sub_indx))); /* these should not be zero length */
trig_len = 0;
}
if (NUM_SUBS > sub_indx)
{
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
if (0 < trig_len)
{
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
}
}
/* $get(^#t(GVN,trigger_count,"LHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
kill_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
/* $get(^#t(GVN,trigger_count,"BHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
set_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
/* update hash values from above */
if (VAL_TOO_LONG == (retval = update_trigger_hash_value(trigvn, trigvn_len, tt_val, tt_val_len,
&set_hash, &kill_hash, count, index)))
return VAL_TOO_LONG;
/* fix the value ^#t("#TNAME",^#t(GVN,index,"#TRIGNAME")) to point to the correct "index" */
if (VAL_TOO_LONG == (retval = update_trigger_name_value(trigvn_len, tt_val[TRIGNAME_SUB],
tt_val_len[TRIGNAME_SUB], index)))
return VAL_TOO_LONG;
/* kill ^#t(GVN,COUNT) which was just shifted to trigger_index */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count);
gvcst_kill(TRUE);
}
/* Update #COUNT */
count--;
MV_FORCE_MVAL(trigger_count, count);
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT), *trigger_count,
result);
assert(PUT_SUCCESS == result); /* Size of count can only get shorter or stay the same */
}
trigger_incr_cycle(trigvn, trigvn_len);
return PUT_SUCCESS;
}
int4 trigger_delete(char *trigvn, int trigvn_len, mval *trigger_count, int index)
{
int count;
mval mv_val;
mval *mv_val_ptr;
char *ptr1;
int4 result;
int4 retval;
stringkey kill_hash, set_hash;
int sub_indx;
char tmp_trig_str[MAX_BUFF_SIZE];
int4 trig_len;
char trig_name[MAX_TRIGNAME_LEN];
int trig_name_len;
int tmp_len;
char *tt_val[NUM_SUBS];
uint4 tt_val_len[NUM_SUBS];
mval trigger_value;
mval trigger_index;
mval xecute_index;
uint4 xecute_idx;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!gv_cur_region->read_only); /* caller should have already checked this */
assert(cs_addrs->hasht_tree == gv_target); /* should have been set up by caller */
assert(gv_target->root); /* should have been ensured by caller */
mv_val_ptr = &mv_val;
MV_FORCE_UMVAL(&trigger_index, index);
count = MV_FORCE_UINT(trigger_count);
/* build up array of values - needed for comparison in hash stuff */
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
/* Assert that BHASH and LHASH are not part of NUM_SUBS calculation (confirms the -2 done in the #define of NUM_SUBS) */
assert(BHASH_SUB == NUM_SUBS);
assert(LHASH_SUB == (NUM_SUBS + 1));
for (sub_indx = 0; sub_indx < NUM_SUBS; sub_indx++)
{
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
trig_len = gvcst_get(&trigger_value) ? trigger_value.str.len : 0;
if (0 == trig_len)
{
if (((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) || (CHSET_SUB == sub_indx)))
{ /* CMD, NAME and CHSET cannot be zero length */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD, 6, trigvn_len, trigvn,
trigvn_len, trigvn, STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
if (TRIGNAME_SUB == sub_indx)
{
trig_name_len = MIN(trig_len, MAX_TRIGNAME_LEN);
assert(MAX_TRIGNAME_LEN >= trig_len);
memcpy(trig_name, trigger_value.str.addr, trig_name_len);
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
return VAL_TOO_LONG;
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
/* Get trigger name, set hash value, and kill hash values from trigger before we delete it.
* The values will be used in clean ups associated with the deletion
*/
/* $get(^#t(GVN,trigger_index,"LHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (gvcst_get(mv_val_ptr))
kill_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
else
{
util_out_print_gtmio("The LHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
kill_hash.hash_code = 0;
}
/* $get(^#t(GVN,trigger_index,"BHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (gvcst_get(mv_val_ptr))
set_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
else
{
util_out_print_gtmio("The BHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
set_hash.hash_code = 0;
}
/* kill ^#t(GVN,trigger_index) */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, trigger_index);
gvcst_kill(TRUE);
assert(0 == gvcst_data());
if (1 == count)
{ /* This is the last trigger for "trigvn" - clean up trigger name, remove #LABEL and #COUNT */
assert(1 == index);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
gvcst_kill(TRUE);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
gvcst_kill(TRUE);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
} else
{
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
if (index != count)
{ /* Shift the last trigger (index is #COUNT value) to the just deleted trigger's index.
* This way count is always accurate and can still be used as the index for new triggers.
* Note - there is no dependence on the trigger order, or this technique wouldn't work.
*/
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
for (sub_indx = 0; sub_indx < NUM_TOTAL_SUBS; sub_indx++)
{
/* $get(^#t(GVN,trigger_count,sub_indx) */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
if (gvcst_get(&trigger_value))
{
trig_len = trigger_value.str.len;
/* set ^#t(GVN,trigger_index,sub_indx)=^#t(GVN,trigger_count,sub_indx) */
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), trigger_value, result);
assert(PUT_SUCCESS == result);
} else if (XECUTE_SUB == sub_indx)
{ /* multi line trigger broken up because it exceeds record size */
for (xecute_idx = 0; ; xecute_idx++)
{
i2mval(&xecute_index, xecute_idx);
BUILD_HASHT_SUB_MSUB_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index);
if (!gvcst_get(&trigger_value))
break;
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MSUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index,
trigger_value, result);
assert(PUT_SUCCESS == result);
}
assert (xecute_idx >= 2); /* multi-line trigger, indices 0, 1 and 2 MUST be defined */
} else
{
if (((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) ||
(CHSET_SUB == sub_indx)))
{ /* CMD, NAME and CHSET cannot be zero length */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD,
6, trigvn_len, trigvn, trigvn_len, trigvn,
STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
/* OPTIONS, PIECES and DELIM can be zero */
trig_len = 0;
}
if (NUM_SUBS > sub_indx)
{
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
{ /* Exceeding the temporary buffer is impossible, restart*/
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD,
6, trigvn_len, trigvn, trigvn_len, trigvn,
STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
}
/* $get(^#t(GVN,trigger_count,"LHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
kill_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
/* $get(^#t(GVN,trigger_count,"BHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
set_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
/* update hash values from above */
if (VAL_TOO_LONG == (retval = update_trigger_hash_value(trigvn, trigvn_len, tt_val, tt_val_len,
&set_hash, &kill_hash, count, index)))
return VAL_TOO_LONG;
/* fix the value ^#t("#TNAME",^#t(GVN,index,"#TRIGNAME")) to point to the correct "index" */
if (VAL_TOO_LONG == (retval = update_trigger_name_value(tt_val[TRIGNAME_SUB],
tt_val_len[TRIGNAME_SUB], index)))
return VAL_TOO_LONG;
/* kill ^#t(GVN,COUNT) which was just shifted to trigger_index */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count);
gvcst_kill(TRUE);
}
/* Update #COUNT */
count--;
MV_FORCE_UMVAL(trigger_count, count);
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT), *trigger_count,
result);
assert(PUT_SUCCESS == result); /* Size of count can only get shorter or stay the same */
}
return PUT_SUCCESS;
}
void op_fngetjpi(mint jpid, mval *kwd, mval *ret)
{
error_def (ERR_BADJPIPARAM);
struct tms proc_times;
int4 info ;
int keywd_indx;
char upcase[MAX_KEY_LEN];
assert (stringpool.free >= stringpool.base);
assert (stringpool.top >= stringpool.free);
if (stringpool.top - stringpool.free < MAX_STR)
stp_gcol(MAX_STR);
MV_FORCE_STR(kwd);
if (kwd->str.len == 0)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, 4, "Null");
if (MAX_KEY < kwd->str.len)
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, kwd->str.len, kwd->str.addr);
lower_to_upper((uchar_ptr_t)upcase, (uchar_ptr_t)kwd->str.addr, (int)kwd->str.len);
keywd_indx = kw_cputim ;
/* future enhancement:
* (i) since keywords are sorted, we can exit the while loop if 0 < memcmp.
* (ii) also, the current comparison relies on kwd->str.len which means a C would imply CPUTIM instead of CSTIME
* or CUTIME this ambiguity should probably be removed by asking for an exact match of the full keyword
*/
while ((0 != memcmp(upcase, key[keywd_indx], kwd->str.len)) && keywd_indx < MAX_KEY)
keywd_indx++;
if( keywd_indx == MAX_KEY )
{
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, kwd->str.len, kwd->str.addr);
}
if ((kw_isprocalive != keywd_indx) && ((unsigned int)-1 == times(&proc_times)))
{
rts_error(VARLSTCNT(1) errno); /* need a more specific GTM error message in addition to errno */
return;
}
switch (keywd_indx)
{
case kw_cputim:
info = proc_times.tms_utime + proc_times.tms_stime + proc_times.tms_cutime + proc_times.tms_cstime;
break;
case kw_cstime:
info = proc_times.tms_cstime;
break;
case kw_cutime:
info = proc_times.tms_cutime;
break;
case kw_isprocalive:
info = (0 != jpid) ? is_proc_alive(jpid, 0) : 1;
break;
case kw_stime:
info = proc_times.tms_stime;
break;
case kw_utime:
info = proc_times.tms_utime;
break;
case kw_end:
default:
rts_error(VARLSTCNT(4) ERR_BADJPIPARAM, 2, kwd->str.len, kwd->str.addr);
return;
}
if (kw_isprocalive != keywd_indx)
info = (int4)((info * 100) / sysconf(_SC_CLK_TCK)); /* Convert to standard 100 ticks per second */
i2mval(ret, info);
}
void op_fngetdvi(mval *device, mval *keyword, mval *ret)
{
itmlist_struct item_list;
short out_len, iosb[4];
uint4 status;
char index, slot, last_slot;
int4 item_code, out_value;
unsigned char buff[MAX_KEY_LENGTH], *upper_case;
bool want_secondary;
$DESCRIPTOR(device_name,"");
error_def(ERR_DVIKEYBAD);
error_def(ERR_INVSTRLEN);
MV_FORCE_STR(device);
MV_FORCE_STR(keyword);
if (MAX_DEV_LENGTH < device->str.len)
rts_error(VARLSTCNT(1) SS$_IVLOGNAM);
if (keyword->str.len > MAX_KEY_LENGTH)
rts_error(VARLSTCNT(4) ERR_INVSTRLEN, 2, keyword->str.len, MAX_KEY_LENGTH);
if (!keyword->str.len)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, 4, "NULL");
}
lower_to_upper(&buff[0], keyword->str.addr, keyword->str.len);
upper_case = buff;
if ( device->str.len == 0 || (device->str.len == 1 && *device->str.addr == '0'))
{ device_name.dsc$a_pointer = "SYS$INPUT";
device_name.dsc$w_length = SIZEOF("SYS$INPUT")-1;
}
else
{ device_name.dsc$a_pointer = device->str.addr;
device_name.dsc$w_length = device->str.len;
}
item_list.bufflen = VAL_LENGTH;
item_list.itmcode = SPL_CODE;
item_list.buffaddr = &out_value;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) status ) ;
}
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) iosb[0] );
}
if (out_value != NULL)
{ want_secondary = TRUE;
}
else
{ want_secondary = FALSE;
}
if ((index = *upper_case - 'A') < MIN_INDEX || index > MAX_INDEX)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, keyword->str.len, keyword->str.addr);
}
item_code = 0;
if ( dvi_index[ index ].len)
{
slot = dvi_index[ index ].index;
last_slot = dvi_index[ index ].len;
for ( ; slot < last_slot ; slot++ )
{ if (keyword->str.len == dvi_table[ slot ].len &&
!memcmp(dvi_table[ slot ].name, upper_case, keyword->str.len))
{ item_code = dvi_table[ slot ].item_code;
break;
}
}
}
if (!item_code)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, keyword->str.len, keyword->str.addr);
}
switch( item_code )
{
/* **** the following item codes require a string be returned **** */
case DVI$_ALLDEVNAM:
case DVI$_DEVLOCKNAM:
case DVI$_DEVNAM:
case DVI$_FULLDEVNAM:
case DVI$_LOGVOLNAM:
case DVI$_NEXTDEVNAM:
case DVI$_ROOTDEVNAM:
case DVI$_TT_ACCPORNAM:
case DVI$_TT_PHYDEVNAM:
case DVI$_VOLNAM:
if (want_secondary)
{
if (!((item_code == DVI$_DEVNAM) && (keyword->str.len == 9)))
{ item_code |= DVI$C_SECONDARY;
}
}
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(MAX_DVI_STRLEN);
item_list.bufflen = MAX_DVI_STRLEN;
item_list.itmcode = item_code;
item_list.buffaddr = stringpool.free;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) status );
}
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) iosb[0] ) ;
}
ret->str.addr = stringpool.free;
ret->str.len = out_len;
ret->mvtype = MV_STR;
stringpool.free += out_len;
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
return;
default:
if (want_secondary)
item_code |= DVI$C_SECONDARY;
item_list.itmcode = item_code;
item_list.bufflen = VAL_LENGTH;
item_list.buffaddr = &out_value;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
rts_error(VARLSTCNT(1) status );
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
rts_error(VARLSTCNT(1) iosb[0] );
if (want_secondary)
item_code = item_code - 1;
switch(item_code)
{ case DVI$_LOCKID:
case DVI$_ACPPID:
case DVI$_OWNUIC:
if (out_value)
{ assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(HEX_LEN);
i2hex(out_value, stringpool.free, HEX_LEN);
ret->str.addr = stringpool.free;
ret->str.len = HEX_LEN;
stringpool.free += HEX_LEN;
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
}
else
{ ret->str.addr = "";
ret->str.len = 0;
}
ret->mvtype = MV_STR;
break;
case DVI$_ACPTYPE:
switch(out_value)
{
case 0: ret->str.addr = "ILLEGAL";
ret->str.len = 7;
break;
case 1: ret->str.addr = "F11V1";
ret->str.len = 5;
break;
case 2: ret->str.addr = "F11V2";
ret->str.len = 5;
break;
case 3: ret->str.addr = "MTA";
ret->str.len = 3;
break;
case 4: ret->str.addr = "NET";
ret->str.len = 3;
break;
case 5: ret->str.addr = "REM";
ret->str.len = 3;
}
ret->mvtype = MV_STR;
break;
default:
i2mval(ret,out_value) ;
}
return;
}
}
void op_svget(int varnum, mval *v)
{
io_log_name *tl;
int count;
gtm_uint64_t ucount;
char *c1, *c2;
mval *mvp;
# ifdef UNIX
d_rm_struct *d_rm;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
# if defined(UNIX) && defined(DEBUG)
if (gtm_white_box_test_case_enabled && (WBTEST_HUGE_ALLOC == gtm_white_box_test_case_number))
{
if (1 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xffff;
else if (2 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
else if (3 == gtm_white_box_test_case_count)
{
# ifdef GTM64
if (8 == SIZEOF(size_t))
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta
= totalUsed = totalUsedGta = 0xfffffffffffffff;
else
# endif
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
} else
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed
= totalUsedGta = GTM64_ONLY(SIZEOF(size_t)) NON_GTM64_ONLY(SIZEOF(size_t) > 4 ? 4 : SIZEOF(size_t));
}
# endif
switch (varnum)
{
case SV_HOROLOG:
op_horolog(v);
break;
case SV_ZGBLDIR:
v->mvtype = MV_STR;
v->str = dollar_zgbldir.str;
break;
case SV_PRINCIPAL:
tl = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name;
v->str.addr = tl->dollar_io;
v->str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_ZIO:
v->mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
v->str.addr = io_curr_device.in->trans_name->dollar_io;
v->str.len = io_curr_device.in->trans_name->len;
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
break;
case SV_JOB:
*v = dollar_job;
break;
case SV_REFERENCE:
get_reference(v);
break;
case SV_SYSTEM:
*v = dollar_system;
break;
case SV_STORAGE:
/* double2mval(v, getstorage()); Causes issues with unaligned stack on x86_64 - remove until fixed */
i2mval(v, getstorage());
break;
case SV_TLEVEL:
count = (int)dollar_tlevel;
MV_FORCE_MVAL(v, count);
break;
case SV_TRESTART:
MV_FORCE_MVAL(v, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
break;
case SV_X:
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(v, count);
break;
case SV_Y:
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(v, count);
break;
case SV_ZA:
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(v, count);
break;
case SV_ZB:
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + SIZEOF(io_curr_device.in->dollar.zb);
ENSURE_STP_FREE_SPACE(SIZEOF(io_curr_device.in->dollar.zb));
v->mvtype = MV_STR;
v->str.addr = (char *)stringpool.free;
while (c1 < c2 && *c1)
*stringpool.free++ = *c1++;
v->str.len = INTCAST((char *)stringpool.free - v->str.addr);
break;
case SV_ZC: /****THESE ARE DUMMY VALUES ONLY!!!!!!!!!!!!!!!!!****/
MV_FORCE_MVAL(v, 0);
break;
case SV_ZCMDLINE:
get_command_line(v, TRUE); /* TRUE to indicate we want $ZCMDLINE
(i.e. processed not actual command line) */
break;
case SV_ZEOF:
# ifdef UNIX
if (rm == io_curr_device.in->type)
{
d_rm = (d_rm_struct *)io_curr_device.in->dev_sp;
if (RM_READ != d_rm->lastop)
{
*v = literal_zero;
break;
}
}
# endif
*v = io_curr_device.in->dollar.zeof ? literal_one : literal_zero;
break;
case SV_ZQUIT:
*v = dollar_zquit_anyway ? literal_one : literal_zero;
break;
case SV_IO:
v->str.addr = io_curr_device.in->name->dollar_io;
v->str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_PROMPT:
v->mvtype = MV_STR;
v->str.addr = (TREF(gtmprompt)).addr;
v->str.len = (TREF(gtmprompt)).len;
s2pool(&v->str);
break;
case SV_ZCOMPILE:
v->mvtype = MV_STR;
v->str = TREF(dollar_zcompile);
s2pool(&(v->str));
break;
case SV_ZDIR:
setzdir(NULL, v);
if (v->str.len != dollar_zdir.str.len || 0 != memcmp(v->str.addr, dollar_zdir.str.addr, v->str.len))
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, v->str.len, v->str.addr,
dollar_zdir.str.len, dollar_zdir.str.addr);
SKIP_DEVICE_IF_NOT_NEEDED(v);
s2pool(&(v->str));
break;
case SV_ZSTEP:
*v = dollar_zstep;
break;
case SV_ZMODE:
*v = TREF(dollar_zmode);
break;
case SV_ZMAXTPTIME:
i2mval(v, TREF(dollar_zmaxtptime));
break;
case SV_ZPOS:
getzposition(v);
break;
case SV_ZPROC:
getzprocess();
*v = dollar_zproc;
break;
case SV_ZLEVEL:
count = dollar_zlevel();
MV_FORCE_MVAL(v, count);
break;
case SV_ZROUTINES:
if (!TREF(zro_root))
zro_init();
v->mvtype = MV_STR;
v->str = TREF(dollar_zroutines);
s2pool(&(v->str));
break;
case SV_ZSOURCE:
v->mvtype = MV_STR;
v->str = dollar_zsource.str;
break;
case SV_ZSTATUS:
*v = dollar_zstatus;
s2pool(&(v->str));
break;
case SV_ZTRAP:
v->mvtype = MV_STR;
v->str = dollar_ztrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_DEVICE:
get_dlr_device(v);
break;
case SV_KEY:
get_dlr_key(v);
break;
case SV_ZVERSION:
v->mvtype = MV_STR;
v->str.addr = (char *)gtm_release_name;
v->str.len = gtm_release_name_len;
break;
case SV_ZSYSTEM:
MV_FORCE_MVAL(v, dollar_zsystem);
break;
case SV_ZCSTATUS:
/* Maintain the external $ZCSTATUS == 1 for SUCCESS on UNIX while internal good is 0 */
MV_FORCE_MVAL(v, UNIX_ONLY((0 == TREF(dollar_zcstatus)) ? 1 : ) TREF(dollar_zcstatus));
break;
case SV_ZEDITOR:
MV_FORCE_MVAL(v, dollar_zeditor);
break;
case SV_QUIT:
MV_FORCE_MVAL(v, dollar_quit());
break;
case SV_ECODE:
ecode_get(-1, v);
break;
case SV_ESTACK:
count = (dollar_zlevel() - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(v, count);
break;
case SV_ETRAP:
v->mvtype = MV_STR;
v->str = dollar_etrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_STACK:
count = (dollar_zlevel() - 1);
MV_FORCE_MVAL(v, count);
break;
case SV_ZERROR:
v->mvtype = MV_STR;
v->str = dollar_zerror.str;
s2pool(&(v->str));
break;
case SV_ZYERROR:
v->mvtype = MV_STR;
v->str = dollar_zyerror.str;
s2pool(&(v->str));
break;
case SV_ZINTERRUPT:
v->mvtype = MV_STR;
v->str = dollar_zinterrupt.str;
s2pool(&(v->str));
break;
case SV_ZININTERRUPT:
MV_FORCE_MVAL(v, dollar_zininterrupt);
break;
case SV_ZJOB:
MV_FORCE_UMVAL(v, dollar_zjob);
break;
case SV_ZDATE_FORM:
MV_FORCE_MVAL(v, TREF(zdate_form));
break;
case SV_ZTEXIT:
*v = dollar_ztexit;
break;
case SV_ZALLOCSTOR:
ucount = (gtm_uint64_t)totalAlloc + (gtm_uint64_t)totalAllocGta;
ui82mval(v, ucount);
break;
case SV_ZREALSTOR:
ucount = (gtm_uint64_t)totalRmalloc + (gtm_uint64_t)totalRallocGta;
ui82mval(v, ucount);
break;
case SV_ZUSEDSTOR:
ucount = (gtm_uint64_t)totalUsed + (gtm_uint64_t)totalUsedGta;
ui82mval(v, ucount);
break;
case SV_ZCHSET:
v->mvtype = MV_STR;
v->str = dollar_zchset;
break;
case SV_ZPATNUMERIC:
v->mvtype = MV_STR;
v->str = dollar_zpatnumeric;
break;
case SV_ZTNAME:
case SV_ZTCODE: /* deprecated */
# ifdef GTM_TRIGGER
if (NULL == dollar_ztname)
memcpy(v, &literal_null, SIZEOF(mval));
else
{
v->mvtype = MV_STR;
v->str.addr = dollar_ztname->addr;
v->str.len = dollar_ztname->len;
}
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDATA:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztdata || MV_DEFINED(dollar_ztdata));
if (NULL != dollar_ztdata)
MV_FORCE_STR(dollar_ztdata);
memcpy(v, (NULL != dollar_ztdata) ? dollar_ztdata : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDELIM:
# ifdef GTM_TRIGGER
assert(!dollar_ztdelim || MV_DEFINED(dollar_ztdelim));
if (NULL == dollar_ztdelim || !(MV_STR & dollar_ztdelim->mvtype) || (0 == dollar_ztdelim->str.len))
memcpy(v, &literal_null, SIZEOF(mval));
else
memcpy(v, dollar_ztdelim, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTOLDVAL:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztoldval || MV_DEFINED(dollar_ztoldval));
if (NULL != dollar_ztoldval)
MV_FORCE_STR(dollar_ztoldval);
memcpy(v, (NULL != dollar_ztoldval) ? dollar_ztoldval : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTRIGGEROP:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but assert it's a string */
assert(!dollar_ztriggerop || (MV_STR & dollar_ztriggerop->mvtype));
memcpy(v, (NULL != dollar_ztriggerop) ? dollar_ztriggerop : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTUPDATE:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but if there were no delims involved, the value will be undefined, and
* we return a "literal_null".
*/
memcpy(v, ((NULL != dollar_ztupdate && (MV_STR & dollar_ztupdate->mvtype)) ? dollar_ztupdate
: &literal_null), SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTVALUE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(!dollar_ztvalue || MV_DEFINED(dollar_ztvalue));
if (NULL != dollar_ztvalue)
MV_FORCE_STR(dollar_ztvalue);
memcpy(v, (NULL != dollar_ztvalue) ? dollar_ztvalue : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTWORMHOLE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
mvp = &dollar_ztwormhole;
if (MV_DEFINED(mvp))
{
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
} else
memcpy(v, &literal_null, SIZEOF(mval));
ztwormhole_used = TRUE;
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTSLATE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(MV_DEFINED((&dollar_ztslate)));
mvp = &dollar_ztslate;
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTLEVEL:
# ifdef GTM_TRIGGER
MV_FORCE_MVAL(v, gtm_trigger_depth);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZONLNRLBK:
# ifdef UNIX
count = TREF(dollar_zonlnrlbk);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZCLOSE:
# ifdef UNIX
count = TREF(dollar_zclose);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZKEY:
get_dlr_zkey(v);
break;
default:
assertpro(FALSE);
}
}
void zshow_svn(zshow_out *output)
{
mstr x;
mval var, zdir;
io_log_name *tl;
stack_frame *fp;
int count, save_dollar_zlevel;
char *c1, *c2;
char zdir_error[3 * GTM_MAX_DIR_LEN + 128]; /* PATH_MAX + "->" + GTM-W-ZDIROUTOFSYNC, <text of ZDIROUTOFSYNC> */
error_def(ERR_ZDIROUTOFSYNC);
/* SV_DEVICE */
get_dlr_device(&var);
ZS_VAR_EQU(&x, device_text);
mval_write(output, &var, TRUE);
/* SV_ECODE */
ecode_get(-1, &var);
ZS_VAR_EQU(&x, ecode_text);
mval_write(output, &var, TRUE);
/* SV_ESTACK */
save_dollar_zlevel = dollar_zlevel();
count = (save_dollar_zlevel - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, estack_text);
mval_write(output, &var, TRUE);
/* SV_ETRAP */
var.mvtype = MV_STR;
var.str = dollar_etrap.str;
ZS_VAR_EQU(&x, etrap_text);
mval_write(output, &var, TRUE);
/* SV_HOROLOG */
op_horolog(&var);
ZS_VAR_EQU(&x, horolog_text);
mval_write(output, &var, TRUE);
/* SV_IO */
var.str.addr = io_curr_device.in->name->dollar_io;
var.str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, io_text);
mval_write(output, &var, TRUE);
/* SV_JOB */
ZS_VAR_EQU(&x, job_text);
mval_write(output, &dollar_job, TRUE);
/* SV_KEY */
get_dlr_key(&var);
ZS_VAR_EQU(&x, key_text);
mval_write(output, &var, TRUE);
/* SV_PRINCIPAL */
if (dollar_principal)
tl = dollar_principal;
else
tl = io_root_log_name->iod->trans_name;
var.str.addr = tl->dollar_io;
var.str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, principal_text);
mval_write(output, &var, TRUE);
/* SV_QUIT */
count = ((NULL == get_ret_targ()) ? 0 : 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, quit_text);
mval_write(output, &var, TRUE);
/* SV_REFERENCE */
get_reference(&var);
ZS_VAR_EQU(&x, reference_text);
mval_write(output, &var, TRUE);
/* SV_STACK */
count = (save_dollar_zlevel - 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, stack_text);
mval_write(output, &var, TRUE);
/* SV_STORAGE */
i2mval(&var, getstorage());
ZS_VAR_EQU(&x, storage_text);
mval_write(output, &var, TRUE);
/* SV_SYSTEM */
var.mvtype = MV_STR;
var.str = dollar_system.str;
ZS_VAR_EQU(&x, system_text);
mval_write(output, &var, TRUE);
/* SV_TEST */
i2mval(&var, (int)op_dt_get());
ZS_VAR_EQU(&x, test_text);
mval_write(output, &var, TRUE);
/* SV_TLEVEL */
count = (int)dollar_tlevel;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, tlevel_text);
mval_write(output, &var, TRUE);
/* SV_TRESTART */
MV_FORCE_MVAL(&var, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
ZS_VAR_EQU(&x, trestart_text);
mval_write(output, &var, TRUE);
/* SV_X */
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, x_text);
mval_write(output, &var, TRUE);
/* SV_Y */
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, y_text);
mval_write(output, &var, TRUE);
/* SV_ZA */
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, za_text);
mval_write(output, &var, TRUE);
/* SV_ZB */
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + sizeof(io_curr_device.in->dollar.zb);
var.mvtype = MV_STR;
var.str.addr = (char *)io_curr_device.in->dollar.zb;
while (c1 < c2 && *c1)
c1++;
var.str.len = (char *)c1 - var.str.addr;
ZS_VAR_EQU(&x, zb_text);
mval_write(output, &var, TRUE);
/* SV_ZCMDLINE */
get_command_line(&var, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */
ZS_VAR_EQU(&x, zcmdline_text);
mval_write(output, &var, TRUE);
/* SV_ZCOMPILE */
var.mvtype = MV_STR;
var.str = dollar_zcompile;
ZS_VAR_EQU(&x, zcompile_text);
mval_write(output, &var, TRUE);
/* SV_ZCSTATUS */
MV_FORCE_MVAL(&var, dollar_zcstatus);
ZS_VAR_EQU(&x, zcstatus_text);
mval_write(output, &var, TRUE);
/* SV_ZDATEFORM */
MV_FORCE_MVAL(&var, zdate_form);
ZS_VAR_EQU(&x, zdate_form_text);
mval_write(output, &var, TRUE);
/* SV_ZDIR */
ZS_VAR_EQU(&x, zdirectory_text);
setzdir(NULL, &zdir);
if (zdir.str.len != dollar_zdir.str.len || 0 != memcmp(zdir.str.addr, dollar_zdir.str.addr, zdir.str.len))
{
memcpy(zdir_error, zdir.str.addr, zdir.str.len);
memcpy(&zdir_error[zdir.str.len], arrow_text, STR_LIT_LEN(arrow_text));
sgtm_putmsg(&zdir_error[zdir.str.len + STR_LIT_LEN(arrow_text)], VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4,
zdir.str.len, zdir.str.addr, dollar_zdir.str.len, dollar_zdir.str.addr);
zdir.str.addr = zdir_error;
zdir.str.len = strlen(zdir_error) - 1; /* eliminate trailing '\n' */
}
SKIP_DEVICE_IF_NOT_NEEDED(&zdir);
mval_write(output, &zdir, TRUE);
/* SV_ZEDITOR */
MV_FORCE_MVAL(&var, dollar_zeditor);
ZS_VAR_EQU(&x, zeditor_text);
mval_write(output, &var, TRUE);
/* SV_ZEOF */
ZS_VAR_EQU(&x, zeof_text);
mval_write(output, io_curr_device.in->dollar.zeof ? (mval *)&literal_one : (mval *)&literal_zero, TRUE);
/* SV_ZERROR */
var.mvtype = MV_STR;
var.str = dollar_zerror.str;
ZS_VAR_EQU(&x, zerror_text);
mval_write(output, &var, TRUE);
/* SV_ZGBLDIR */
ZS_VAR_EQU(&x, zgbldir_text);
mval_write(output, &dollar_zgbldir, TRUE);
/* SV_ZININTERRUPT */
MV_FORCE_MVAL(&var, dollar_zininterrupt);
ZS_VAR_EQU(&x, zininterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZINTERRUPT */
var.mvtype = MV_STR;
var.str = dollar_zinterrupt.str;
ZS_VAR_EQU(&x, zinterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZIO */
var.mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
var.str.addr = io_curr_device.in->trans_name->dollar_io;
var.str.len = io_curr_device.in->trans_name->len;
if (*var.str.addr == ESC)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
ZS_VAR_EQU(&x, zio_text);
mval_write(output, &var, TRUE);
/* SV_ZJOB */
MV_FORCE_ULONG_MVAL(&var, dollar_zjob);
ZS_VAR_EQU(&x, zjob_text);
mval_write(output, &var, TRUE);
/* SV_ZLEVEL */
MV_FORCE_MVAL(&var, save_dollar_zlevel);
ZS_VAR_EQU(&x, zlevel_text);
mval_write(output, &var, TRUE);
/* SV_ZMAXTPTIME */
MV_FORCE_MVAL(&var, dollar_zmaxtptime);
ZS_VAR_EQU(&x, zmaxtptime_text);
mval_write(output, &var, TRUE);
/* SV_ZMODE */
ZS_VAR_EQU(&x, zmode_text);
mval_write(output, &dollar_zmode, TRUE);
/* SV_ZPOS */
getzposition(&var);
ZS_VAR_EQU(&x, zpos_text);
mval_write(output, &var, TRUE);
/* SV_ZPROC */
ZS_VAR_EQU(&x, zproc_text);
mval_write(output, &dollar_zproc, TRUE);
/* SV_PROMPT */
var.mvtype = MV_STR;
var.str.addr = gtmprompt.addr;
var.str.len = gtmprompt.len;
ZS_VAR_EQU(&x, zprompt_text);
mval_write(output, &var, TRUE);
/* SV_ZROUTINES */
if (!zro_root)
zro_init();
var.mvtype = MV_STR;
var.str = dollar_zroutines;
ZS_VAR_EQU(&x, zroutines_text);
mval_write(output, &var, TRUE);
/* SV_ZSOURCE */
var.mvtype = MV_STR;
var.str = dollar_zsource;
ZS_VAR_EQU(&x, zsource_text);
mval_write(output, &var, TRUE);
/* SV_ZSTATUS */
ZS_VAR_EQU(&x, zstatus_text);
mval_write(output, &dollar_zstatus, TRUE);
/* SV_ZSTEP */
ZS_VAR_EQU(&x, zstep_text);
mval_write(output, &dollar_zstep, TRUE);
/* SV_ZSYSTEM */
MV_FORCE_MVAL(&var, dollar_zsystem);
ZS_VAR_EQU(&x, zsystem_text);
mval_write(output, &var, TRUE);
/* SV_ZTEXIT */
var.mvtype = MV_STR;
var.str = dollar_ztexit.str;
ZS_VAR_EQU(&x, ztexit_text);
mval_write(output, &var, TRUE);
/* SV_ZTRAP */
var.mvtype = MV_STR;
var.str = dollar_ztrap.str;
ZS_VAR_EQU(&x, ztrap_text);
mval_write(output, &var, TRUE);
/* SV_ZVERSION */
var.mvtype = MV_STR;
var.str.addr = (char *)>m_release_name[0];
var.str.len = gtm_release_name_len;
ZS_VAR_EQU(&x, zversion_text);
mval_write(output, &var, TRUE);
/* SV_ZYERROR */
var.mvtype = MV_STR;
var.str = dollar_zyerror.str;
ZS_VAR_EQU(&x, zyerror_text);
mval_write(output, &var, TRUE);
}
/* Workhorse of fetching source for given trigger.
*/
STATICFNDEF void trigger_fill_xecute_buffer_read_trigger_source(gv_trigger_t *trigdsc)
{
enum cdb_sc cdb_status;
int4 index;
mstr gbl, xecute_buff;
mval trig_index;
sgmnt_addrs *csa;
sgmnt_data_ptr_t csd;
gvt_trigger_t *gvt_trigger;
gv_namehead *gvt;
gv_namehead *save_gv_target;
gd_region *save_gv_cur_region;
sgm_info *save_sgm_info_ptr;
gv_key save_currkey[DBKEYALLOC(MAX_KEY_SZ)];
assert(0 < dollar_tlevel);
assert(NULL != trigdsc);
SAVE_TRIGGER_REGION_INFO(save_currkey);
gvt_trigger = trigdsc->gvt_trigger; /* We now know our base block now */
index = trigdsc - gvt_trigger->gv_trig_array + 1; /* We now know our trigger index value */
i2mval(&trig_index, index);
DBGTRIGR((stderr, "trigger_fill_xecute_buffer_read_trigger_source: entry $tlevel:%d\tindex:%d of %d\n",
dollar_tlevel, index, gvt_trigger->num_gv_triggers));
gvt = gv_target = gvt_trigger->gv_target; /* gv_target contains global name */
gbl.addr = gvt->gvname.var_name.addr;
gbl.len = gvt->gvname.var_name.len;
/* Our situation is that while our desired gv_target has csa information, we don't know specifically
* which global directory was in use so we can't run gv_bind_name() lest we find the given global
* name in the wrong global directory thus running the wrong triggers. But we know this target is
* properly formed since it had to be when it was recorded when the triggers were loaded. Because of
* that, we can get the correct csa and gv_target and csa-region will point us to a region that will
* work even if it isn't exactly the one we used to get to this trigger.
*/
TP_CHANGE_REG_IF_NEEDED(gvt->gd_csa->region);
csa = cs_addrs;
csd = csa->hdr;
assert(csd == cs_data);
tp_set_sgm();
/* See if we need to reload our triggers */
if ((csa->db_trigger_cycle != gvt->db_trigger_cycle)
|| (csa->db_dztrigger_cycle && (gvt->db_dztrigger_cycle != csa->db_dztrigger_cycle)))
{ /* The process' view of the triggers could be potentially stale. Restart to be safe.
* Triggers can be invoked only by GT.M and Update process. Out of these, we expect only
* GT.M to see restarts due to concurrent trigger changes. Update process is the only
* updater on the secondary so we dont expect it to see any concurrent trigger changes
* Assert accordingly.
*/
DBGTRIGR((stderr, "trigger_fill_xecute_buffer_read_trigger_source: stale trigger view\n"));
assert(CDB_STAGNATE > t_tries);
assert(IS_GTM_IMAGE);
t_retry(cdb_sc_triggermod);
}
SET_GVTARGET_TO_HASHT_GBL(csa);
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED;
assert(0 == trigdsc->xecute_str.str.len); /* Make sure not replacing/losing a buffer */
xecute_buff.addr = trigger_gbl_fill_xecute_buffer(gbl.addr, gbl.len, &trig_index, NULL, (int4 *)&xecute_buff.len);
trigdsc->xecute_str.str = xecute_buff;
/* Restore gv_target/gv_currkey which need to be kept in sync */
RESTORE_TRIGGER_REGION_INFO(save_currkey);
return;
}
