void act_in_gvt(gv_namehead *gvt)
{
collseq *csp;
# ifdef GTM_TRIGGER
if (IS_MNAME_HASHT_GBLNAME(gvt->gvname.var_name))
return; /* No collation for triggers */
# endif
if (csp = ready_collseq((int)(gvt->act))) /* WARNING: ASSIGNMENT */
{
if (!do_verify(csp, gvt->act, gvt->ver))
{
gvt->root = 0;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_COLLTYPVERSION, 2, gvt->act, gvt->ver,
ERR_GVIS, 2, gvt->gvname.var_name.len, gvt->gvname.var_name.addr);
}
} else
{
gvt->root = 0;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(7) ERR_COLLATIONUNDEF, 1, gvt->act,
ERR_GVIS, 2, gvt->gvname.var_name.len, gvt->gvname.var_name.addr);
}
gvt->collseq = csp;
return;
}
/* This routine reads a PINI record from a Journal file.
* If it is not already in the hash table, it saves it in the hash table,
* For success pplst = (pointer to the pini_list_struct structure) is updated.
* For success it returns SS_NORMAL. Else error code is returned.
*/
uint4 mur_get_pini(jnl_ctl_list *jctl, off_jnl_t pini_addr, pini_list_struct **pplst)
{
pini_list_struct *plst;
struct_jrec_pini *pini_rec;
uint4 status;
ht_ent_int4 *tabent;
struct_jrec_pini *pinirec;
reg_ctl_list *rctl;
mur_read_desc_t *mur_desc;
if (NULL != (tabent = lookup_hashtab_int4(&jctl->pini_list, (uint4 *)&pini_addr)))
plst = tabent->value;
else
plst = NULL;
if (NULL != plst)
{
*pplst = plst;
return SS_NORMAL;
}
rctl = jctl->reg_ctl;
mur_desc = rctl->mur_desc;
mur_desc->random_buff.dskaddr = ROUND_DOWN2(pini_addr, DISK_BLOCK_SIZE);
mur_desc->random_buff.blen = pini_addr - mur_desc->random_buff.dskaddr + PINI_RECLEN;
if (mur_desc->random_buff.dskaddr > jctl->eof_addr - mur_desc->random_buff.blen
|| (SS_NORMAL != (status = mur_read(jctl))))
{
if (mur_options.update && jctl->after_end_of_data && !jgbl.forw_phase_recovery)
return ERR_JNLBADRECFMT;
gtm_putmsg_csa(CSA_ARG(rctl->csa) VARLSTCNT(5) ERR_JNLBADRECFMT, 3, jctl->jnl_fn_len, jctl->jnl_fn,
jctl->rec_offset);
gtm_putmsg_csa(CSA_ARG(rctl->csa) VARLSTCNT(5) ERR_JNLREAD, 3, jctl->jnl_fn_len, jctl->jnl_fn, pini_addr);
assert(FALSE);
murgbl.wrn_count++;
PROCEED_IF_EXTRACT_SHOW_VERIFY(jctl, pini_addr, plst, pplst);
}
pinirec = (struct_jrec_pini *)(mur_desc->random_buff.base + (pini_addr - mur_desc->random_buff.dskaddr));
/* Verify that it's actually a PINI record */
if (JRT_PINI != pinirec->prefix.jrec_type || PINI_RECLEN != pinirec->prefix.forwptr ||
!IS_VALID_JNLREC((jnl_record *)pinirec, jctl->jfh))
{
if (mur_options.update && jctl->after_end_of_data && !jgbl.forw_phase_recovery)
return ERR_JNLBADRECFMT;
gtm_putmsg_csa(CSA_ARG(rctl->csa) VARLSTCNT(5) ERR_JNLBADRECFMT, 3, jctl->jnl_fn_len, jctl->jnl_fn,
jctl->rec_offset);
if (JRT_PINI != pinirec->prefix.jrec_type)
gtm_putmsg_csa(CSA_ARG(rctl->csa) VARLSTCNT(5) ERR_NOPINI, 3, jctl->jnl_fn_len, jctl->jnl_fn, pini_addr);
assert(FALSE);
murgbl.wrn_count++;
PROCEED_IF_EXTRACT_SHOW_VERIFY(jctl, pini_addr, plst, pplst);
}
/* Insert it into the list */
plst = (pini_list_struct *)get_new_element(murgbl.pini_buddy_list, 1);
plst->pini_addr = pini_addr;
plst->new_pini_addr = 0;
plst->state = IGNORE_PROC;
memcpy(&plst->jpv, &pinirec->process_vector[CURR_JPV], SIZEOF(jnl_process_vector));
memcpy(&plst->origjpv, &pinirec->process_vector[ORIG_JPV], SIZEOF(jnl_process_vector));
plst->pini_jpv_time = plst->jpv.jpv_time; /* save copy just in case jpv->jpv_time gets
* changed in forward phase of journal recovery */
NON_GTM64_ONLY(assert(SIZEOF(void *) == SIZEOF(pini_addr));)
void op_trollback(int rb_levels) /* rb_levels -> # of transaction levels by which we need to rollback : BYPASSOK */
{
boolean_t lcl_implicit_trollback = FALSE, reg_reset;
uint4 newlevel;
gd_region *save_cur_region; /* saved copy of gv_cur_region before tp_clean_up/tp_incr_clean_up modifies it */
gd_region *curreg;
gv_key *gv_orig_key_ptr;
sgmnt_addrs *csa;
tp_region *tr;
int tl;
if (implicit_trollback)
{
/* Unlike the call to "op_trollback" from generated code, this invocation of "op_trollback" is from C runtime code.
* Set the global variable to FALSE right away to avoid incorrect values from persisting in case of errors
* down below. Before the reset of the global variable, copy it into a local variable.
*/
lcl_implicit_trollback = implicit_trollback;
implicit_trollback = FALSE;
}
if (!dollar_tlevel)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_TLVLZERO);
if (0 > rb_levels)
{
if (dollar_tlevel < -rb_levels)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_TROLLBK2DEEP, 2, -rb_levels, dollar_tlevel);
} else if (dollar_tlevel <= rb_levels)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_INVROLLBKLVL, 2, rb_levels, dollar_tlevel);
newlevel = (0 > rb_levels) ? dollar_tlevel + rb_levels : rb_levels;
DBG_CHECK_GVTARGET_GVCURRKEY_IN_SYNC(CHECK_CSA_TRUE);
save_cur_region = gv_cur_region;
GTMTRIG_ONLY(assert(tstart_trigger_depth <= gtm_trigger_depth);) /* see similar assert in op_tcommit.c for why */
if (!newlevel)
int mu_rndwn_sem_all(void)
{
int save_errno, exit_status = SS_NORMAL, semid;
char entry[MAX_ENTRY_LEN];
FILE *pf;
char fname[MAX_FN_LEN + 1], *fgets_res;
boolean_t rem_sem;
shm_parms *parm_buff;
if (NULL == (pf = POPEN(IPCS_SEM_CMD_STR ,"r")))
{
save_errno = errno;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("POPEN()"), CALLFROM, save_errno);
return ERR_MUNOTALLSEC;
}
while (NULL != (FGETS(entry, SIZEOF(entry), pf, fgets_res)) && entry[0] != '\n')
{
if (-1 != (semid = parse_sem_id(entry)))
{
if (is_orphaned_gtm_semaphore(semid))
{ /* semval == 0 and corresponding shared memory has been removed */
if (-1 != semctl(semid, 0, IPC_RMID))
{
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_SEMREMOVED, 1, semid);
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_SEMREMOVED, 1, semid);
}
}
}
}
pclose(pf);
return exit_status;
}
void copy_stack_frame(void)
{
register stack_frame *sf;
unsigned char *msp_save;
msp_save = msp;
sf = (stack_frame *)(msp -= SIZEOF(stack_frame));
if (msp <= stackwarn)
{
if (msp <= stacktop)
{
msp = msp_save;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKOFLOW);
} else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKCRIT);
}
assert(msp < stackbase);
assert((frame_pointer < frame_pointer->old_frame_pointer) || (NULL == frame_pointer->old_frame_pointer));
*sf = *frame_pointer;
sf->old_frame_pointer = frame_pointer;
sf->flags = 0; /* Don't propagate special flags */
sf->type &= SFT_ZINTR_OFF; /* Don't propagate special type - normally can't propagate but if $ZINTERRUPT frame is
* rewritten by ZGOTO to a "regular" frame, this frame type *can* propagate.
*/
SET_GLVN_INDX(sf, GLVN_POOL_UNTOUCHED);
sf->ret_value = NULL;
sf->dollar_test = -1; /* initialize it with -1 for indication of not yet being used */
frame_pointer = sf;
DBGEHND((stderr, "copy_stack_frame: Added stackframe at addr 0x"lvaddr" old-msp: 0x"lvaddr" new-msp: 0x"lvaddr"\n",
sf, msp_save, msp));
assert((frame_pointer < frame_pointer->old_frame_pointer) || (NULL == frame_pointer->old_frame_pointer));
}
int create_server(void)
{
int child_pid, done_pid, status = 0;
# ifdef _BSD
union wait chld_status;
# define CSTAT chld_status
# else
# define CSTAT status
# endif
int save_errno;
FORK(child_pid);
if (0 == child_pid)
{
process_id = getpid();
/* Do exec using gtmsecshr_path, which was initialize in file check code - send_mesg2gtmsecshr */
if (WBTEST_ENABLED(WBTEST_BADEXEC_SECSHR_PROCESS))
STRCPY(gtmsecshr_path, "");
status = EXECL(gtmsecshr_path, gtmsecshr_path, 0);
if (-1 == status)
{
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(9) ERR_GTMSECSHRSTART, 3, RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_STRING(secshrstart_error_code[UNABLETOEXECGTMSECSHR]));
UNDERSCORE_EXIT(UNABLETOEXECGTMSECSHR);
}
} else
{
if (-1 == child_pid)
{
status = GNDCHLDFORKFLD;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_GTMSECSHRSTART, 3, RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_TEXT("Failed to fork off gtmsecshr"), errno);
/* Sleep for a while and hope a subsequent fork will succeed */
hiber_start(1000);
}
for (; !status ;)
{
/* To prevent a warning message that the compiler issues */
done_pid = wait(&CSTAT);
if (done_pid == child_pid)
{
status = WEXITSTATUS(CSTAT);
break;
} else if (-1 == done_pid)
{
if (ECHILD == errno) /* Assume normal exit status */
break;
else if (EINTR != errno)
{
status = GNDCHLDFORKFLD;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_GTMSECSHRSTART, 3,
RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_TEXT("Error spawning gtmsecshr"), errno);
}
}
}
}
return status;
}
/* mupfndfil.c
* Description:
* For a region find if the corresponding database is present.
* Arguments:
* reg: Region's pointer
* filestr: Sent as allocated memory, if returned full path is needed in this mstr
* Returns: TRUE if region's database file is found
* FALSE, otherwise
* Side Effects:
* reg->dyn.addr->fname_len and reg->dyn.addr->fname are updated
*/
boolean_t mupfndfil(gd_region *reg, mstr *filestr)
{
char filename[MAX_FN_LEN];
mstr file, def, ret, *retptr;
uint4 ustatus;
switch(reg->dyn.addr->acc_meth)
{
case dba_mm:
case dba_bg:
break;
# ifdef VMS
case dba_usr:
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_NOUSERDB, 4, LEN_AND_LIT("specified function"), REG_LEN_STR(reg));
return FALSE; /* This is currently a VMS only possibility and has no corresponding test case */
# endif
default:
util_out_print("REGION !AD has an unrecognized access method.", TRUE, REG_LEN_STR(reg));
return FALSE;
}
file.addr = (char *)reg->dyn.addr->fname;
file.len = reg->dyn.addr->fname_len;
#if defined(UNIX)
file.addr[file.len] = 0;
if (is_raw_dev(file.addr))
{
def.addr = DEF_NODBEXT;
def.len = SIZEOF(DEF_NODBEXT) - 1;
} else
{
def.addr = DEF_DBEXT; /* UNIX need to pass "*.dat" but reg->dyn.addr->defext has "DAT" */
def.len = SIZEOF(DEF_DBEXT) - 1;
}
#elif defined(VMS)
def.addr = (char *)reg->dyn.addr->defext;
def.len = SIZEOF(reg->dyn.addr->defext);
#endif
if (NULL == filestr)
{
ret.len = SIZEOF(filename);
ret.addr = filename;
retptr = &ret;
} else
retptr = filestr;
if (FILE_PRESENT != gtm_file_stat(&file, &def, retptr, FALSE, &ustatus))
{
if (!jgbl.mupip_journal)
{ /* Do not print error messages in case of call from mur_open_files().
* Currently we use "jgbl.mupip_journal" to identify a call from mupip_recover code */
util_out_print("REGION !AD's file !AD cannot be found.", TRUE, REG_LEN_STR(reg), LEN_AND_STR(file.addr));
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ustatus);
}
return FALSE;
}
reg->dyn.addr->fname_len = retptr->len;
memcpy(reg->dyn.addr->fname, retptr->addr, retptr->len + 1);
return TRUE;
}
void new_stack_frame(rhdtyp *rtn_base, unsigned char *context, unsigned char *transfer_addr)
{
register stack_frame *sf;
unsigned char *msp_save;
unsigned int x1, x2;
assert(NULL != rtn_base);
assert(NULL != transfer_addr);
assert((frame_pointer < frame_pointer->old_frame_pointer) || (NULL == frame_pointer->old_frame_pointer));
msp_save = msp;
sf = (stack_frame *)(msp -= SIZEOF(stack_frame));
if (msp <= stackwarn)
{
if (msp <= stacktop)
{
msp = msp_save;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKOFLOW);
} else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKCRIT);
}
assert((unsigned char *)msp < stackbase);
sf->old_frame_pointer = frame_pointer;
sf->rvector = rtn_base;
sf->vartab_ptr = (char *)VARTAB_ADR(rtn_base);
sf->vartab_len = sf->rvector->vartab_len;
sf->ctxt = context;
sf->mpc = transfer_addr;
sf->flags = 0;
SET_GLVN_INDX(sf, GLVN_POOL_UNTOUCHED);
sf->ret_value = NULL;
sf->dollar_test = -1;
# ifdef HAS_LITERAL_SECT
sf->literal_ptr = (int4 *)LITERAL_ADR(rtn_base);
# endif
sf->temp_mvals = sf->rvector->temp_mvals;
msp -= x1 = rtn_base->temp_size;
sf->temps_ptr = msp;
sf->type = SFT_COUNT;
msp -= x2 = rtn_base->vartab_len * SIZEOF(ht_ent_mname *);
sf->l_symtab = (ht_ent_mname **)msp;
if (msp <= stackwarn)
{
if (msp <= stacktop)
{
msp = msp_save;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKOFLOW);
} else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_STACKCRIT);
}
assert(msp < stackbase);
memset(msp, 0, x1 + x2);
frame_pointer = sf;
assert((frame_pointer < frame_pointer->old_frame_pointer) || (NULL == frame_pointer->old_frame_pointer));
DBGEHND((stderr, "new_stack_frame: Added stackframe at addr 0x"lvaddr" old-msp: 0x"lvaddr" new-msp: 0x"lvaddr
" for routine %.*s (rtnhdr 0x"lvaddr")\n", sf, msp_save, msp, rtn_base->routine_name.len,
rtn_base->routine_name.addr, rtn_base));
return;
}
STATICFNDEF int4 update_trigger_name_value(int trigvn_len, char *trig_name, int trig_name_len, int new_trig_index)
{
sgmnt_addrs *csa;
mname_entry gvent;
gv_namehead *hasht_tree;
int len;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
char new_trig_name[MAX_TRIGNAME_LEN + 1];
int num_len;
char *ptr;
int4 result;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
gd_region *save_gv_cur_region;
gv_namehead *save_gv_target;
sgm_info *save_sgm_info_ptr;
mval trig_gbl;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (MAX_AUTO_TRIGNAME_LEN < trigvn_len)
return PUT_SUCCESS;
SAVE_TRIGGER_REGION_INFO;
SWITCH_TO_DEFAULT_REGION;
if (gv_cur_region->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(gv_cur_region));
assert(0 != gv_target->root);
/* $get(^#t("#TNAME",^#t(GVN,index,"#TRIGNAME")) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1);
if (!gvcst_get(&trig_gbl))
{ /* There has to be a #TNAME entry */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
else
{
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""), trig_name_len - 1,
trig_name);
}
}
len = STRLEN(trig_gbl.str.addr) + 1;
assert(MAX_MIDENT_LEN >= len);
memcpy(name_and_index, trig_gbl.str.addr, len);
ptr = name_and_index + len;
num_len = 0;
I2A(ptr, num_len, new_trig_index);
len += num_len;
/* set ^#t(GVN,index,"#TRIGNAME")=trig_name $C(0) new_trig_index */
SET_TRIGGER_GLOBAL_SUB_SUB_STR(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1,
name_and_index, len, result);
RESTORE_TRIGGER_REGION_INFO;
return result;
}
int op_readfl(mval *v, int4 length, int4 timeout)
{
int4 stat; /* status */
size_t cnt, insize, outsize;
char *start_ptr, *save_ptr;
unsigned char *temp_ch;
int b_length;
if (timeout < 0)
timeout = 0;
/* Length is in units of characters, MAX_STRLEN and allocation unit in stp is bytes. Compute the worst case need in bytes.
* Worst case, every Unicode char is 4 bytes
*/
b_length = (!IS_UTF_CHSET(io_curr_device.in->ichset)) ? length : (length * 4);
if (0 >= length)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_RDFLTOOSHORT);
/* This check is more useful in "M" mode. For UTF-8 mode, checks have to be done while reading */
if (MAX_STRLEN < length)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_RDFLTOOLONG);
assert(stringpool.free >= stringpool.base);
assert(stringpool.free <= stringpool.top);
v->mvtype = MV_STR;
v->str.len = 0; /* Nothing kept from any old value */
ENSURE_STP_FREE_SPACE(b_length + ESC_LEN);
v->str.addr = (char *)stringpool.free;
active_device = io_curr_device.in;
stat = (io_curr_device.in->disp_ptr->readfl)(v, length, timeout);
if (IS_AT_END_OF_STRINGPOOL(v->str.addr, 0))
stringpool.free += v->str.len; /* see UNIX iott_readfl */
assert((int4)v->str.len <= b_length);
assert(stringpool.free <= stringpool.top);
# if defined(KEEP_zOS_EBCDIC) || defined(VMS)
if (DEFAULT_CODE_SET != active_device->in_code_set)
{
cnt = insize = outsize = v->str.len;
assert(stringpool.free >= stringpool.base);
ENSURE_STP_FREE_SPACE(cnt);
temp_ch = stringpool.free;
save_ptr = v->str.addr;
start_ptr = (char *)temp_ch;
stringpool.free += cnt;
assert(stringpool.free >= stringpool.base);
assert(stringpool.free <= stringpool.top);
ICONVERT(active_device->input_conv_cd, (unsigned char **)&(v->str.addr), &insize, &temp_ch, &outsize);
v->str.addr = start_ptr;
}
# endif
active_device = 0;
if (NO_M_TIMEOUT != timeout)
return (stat);
return FALSE;
}
/* check initial len bytes of buffer for a BOM
* if CHSET_UTF16, set ichset to BOM or BE if no BOM
* return the number of bytes to skip
*/
int gtm_utf_bomcheck(io_desc *iod, gtm_chset_t *chset, unsigned char *buffer, int len)
{
int bom_bytes = 0;
switch (*chset)
{
case CHSET_UTF8:
assert(UTF8_BOM_LEN <= len);
if (!memcmp(buffer, UTF8_BOM, UTF8_BOM_LEN))
bom_bytes = UTF8_BOM_LEN;
break;
case CHSET_UTF16BE:
case CHSET_UTF16LE:
case CHSET_UTF16:
assert(UTF16BE_BOM_LEN <= len);
assert(UTF16BE_BOM_LEN == UTF16LE_BOM_LEN);
bom_bytes = UTF16BE_BOM_LEN;
if (!memcmp(buffer, UTF16BE_BOM, UTF16BE_BOM_LEN))
{
if (CHSET_UTF16LE == *chset)
{
iod->dollar.za = 9;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_BOMMISMATCH, 4,
chset_names[CHSET_UTF16BE].len, chset_names[CHSET_UTF16BE].addr,
chset_names[CHSET_UTF16LE].len, chset_names[CHSET_UTF16LE].addr);
}
else if (CHSET_UTF16 == *chset)
*chset = CHSET_UTF16BE;
} else if (!memcmp(buffer, UTF16LE_BOM, UTF16LE_BOM_LEN))
{
if (CHSET_UTF16BE == *chset)
{
iod->dollar.za = 9;
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_BOMMISMATCH, 4,
chset_names[CHSET_UTF16LE].len, chset_names[CHSET_UTF16LE].addr,
chset_names[CHSET_UTF16BE].len, chset_names[CHSET_UTF16BE].addr);
}
else if (CHSET_UTF16 == *chset)
*chset = CHSET_UTF16LE;
} else if (CHSET_UTF16 == *chset)
{ /* no BOM so set to BE and read initial bytes */
*chset = CHSET_UTF16BE; /* no BOM so set to BE */
bom_bytes = 0;
} else
bom_bytes = 0; /* no BOM found */
break;
default:
GTMASSERT;
}
return bom_bytes;
}
STATICFNDEF void mu_rndwn_all_helper(shm_parms *parm_buff, char *fname, int *exit_status, int *tmp_exit_status)
{
replpool_identifier replpool_id;
boolean_t ret_status, jnlpool_sem_created;
unsigned char ipcs_buff[MAX_IPCS_ID_BUF], *ipcs_ptr;
ESTABLISH(mu_rndwn_all_helper_ch);
if (validate_db_shm_entry(parm_buff, fname, tmp_exit_status))
{
if (SS_NORMAL == *tmp_exit_status)
{ /* shm still exists */
mu_gv_cur_reg_init();
gv_cur_region->dyn.addr->fname_len = strlen(fname);
STRNCPY_STR(gv_cur_region->dyn.addr->fname, fname, gv_cur_region->dyn.addr->fname_len);
if (mu_rndwn_file(gv_cur_region, FALSE))
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_MUFILRNDWNSUC, 2, DB_LEN_STR(gv_cur_region));
else
{ /* Save semid so that it will not be removed by mu_rndwn_sem_all() */
add_to_semids_list(FILE_INFO(gv_cur_region)->semid);
*exit_status = ERR_MUNOTALLSEC;
}
mu_gv_cur_reg_free();
} else
{ /* shm has been cleaned up by "validate_db_shm_entry" so no need of any more cleanup here */
assert(ERR_SHMREMOVED == *tmp_exit_status);
*tmp_exit_status = SS_NORMAL; /* reset tmp_exit_status for below logic to treat this as normal */
}
} else if ((SS_NORMAL == *tmp_exit_status)
&& validate_replpool_shm_entry(parm_buff, (replpool_id_ptr_t)&replpool_id, tmp_exit_status))
{
if (SS_NORMAL == *tmp_exit_status)
{
assert(JNLPOOL_SEGMENT == replpool_id.pool_type || RECVPOOL_SEGMENT == replpool_id.pool_type);
ret_status = mu_rndwn_repl_instance(&replpool_id, TRUE, FALSE, &jnlpool_sem_created);
ipcs_ptr = i2asc((uchar_ptr_t)ipcs_buff, parm_buff->shmid);
*ipcs_ptr = '\0';
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) (JNLPOOL_SEGMENT == replpool_id.pool_type) ?
(ret_status ? ERR_MUJPOOLRNDWNSUC : ERR_MUJPOOLRNDWNFL) :
(ret_status ? ERR_MURPOOLRNDWNSUC : ERR_MURPOOLRNDWNFL),
4, LEN_AND_STR(ipcs_buff), LEN_AND_STR(replpool_id.instfilename));
if (!ret_status)
*exit_status = ERR_MUNOTALLSEC;
} else
{ /* shm has been cleaned up by "validate_replpool_shm_entry" so no need of any more cleanup here */
assert(ERR_SHMREMOVED == *tmp_exit_status);
*tmp_exit_status = SS_NORMAL; /* reset tmp_exit_status for below logic to treat this as normal */
}
}
REVERT;
}
STATICFNDEF void times_usec(ext_tms *curr)
{
int res;
struct rusage usage;
struct timespec elp_time;
res = getrusage(RUSAGE_SELF, &usage);
if (-1 == res)
MPROF_RTS_ERROR((CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, LEN_AND_LIT("getrusage"), CALLFROM, errno));
# ifdef __osf__
/* On Tru64 getrusage sometimes fails to increment the seconds value when the microseconds wrap around at 1M. If we detect
* this, we make a second call to getrusage if so. A more complete check would be to also verify whether the new seconds
* value is less than the previous one, but we anyway have an assert in UPDATE_TIME that would catch that, and our testing
* on Tru64 has not shown that type of faulty behavior.
*/
if (((usage.ru_utime.tv_sec == last_usage.ru_utime.tv_sec) && (usage.ru_utime.tv_usec < last_usage.ru_utime.tv_usec))
|| ((usage.ru_stime.tv_sec == last_usage.ru_stime.tv_sec) && (usage.ru_stime.tv_usec < last_usage.ru_stime.tv_usec)))
{
DEBUG_ONLY(last_usage = usage);
res = getrusage(RUSAGE_SELF, &usage);
if (-1 == res)
MPROF_RTS_ERROR((CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, LEN_AND_LIT("getrusage"), CALLFROM, errno));
/* In debug also ensure that a subsequent call to getrusage restored the seconds value. */
assert((usage.ru_utime.tv_sec > last_usage.ru_utime.tv_sec)
|| (usage.ru_stime.tv_sec > last_usage.ru_stime.tv_sec));
}
last_usage = usage;
# endif
curr->tms_utime = (usage.ru_utime.tv_sec * (gtm_uint64_t)1000000) + usage.ru_utime.tv_usec;
curr->tms_stime = (usage.ru_stime.tv_sec * (gtm_uint64_t)1000000) + usage.ru_stime.tv_usec;
/* Also start recording the elapsed time. */
while (TRUE)
{
res = clock_gettime(use_realtime_flag ? CLOCK_REALTIME : CLOCK_MONOTONIC, &elp_time);
if (res == -1)
{
if ((EINVAL == errno) && !use_realtime_flag)
{
use_realtime_flag = TRUE;
continue;
} else
MPROF_RTS_ERROR((CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5,
LEN_AND_LIT("clock_gettime"), CALLFROM, errno));
}
break;
}
curr->tms_etime = (elp_time.tv_sec * (gtm_uint64_t)1000000) + (elp_time.tv_nsec / 1000);
return;
}
void ch_overrun(void)
{
PRN_ERROR;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_NOCHLEFT);
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_NOCHLEFT);
/* If exit handler is already active, we will just core and die */
if (exit_handler_active)
gtm_dump_core();
else
{ /* Otherwise, we generate a core and exit to drive the condition handler */
gtm_fork_n_core();
MUMPS_EXIT;
}
}
int continue_proc(pid_t pid)
{
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
DEBUG_ONLY(if (!TREF(gtm_usesecshr))) /* Cause debug builds to talk to gtmsecshr more often */
{
if (WBTEST_ENABLED(WBTEST_HOLD_GTMSOURCE_SRV_LATCH))
{
/* Simulate the kill below, but ignore its return status so that we end up invoking gtmsecshr */
kill(pid, SIGCONT);
/* Wait until the target quits so that kill() call by gtmsecshr fails with ESRCH */
while (is_proc_alive(pid, 0))
LONG_SLEEP(1);
}
else if (0 == kill(pid, SIGCONT))
return 0;
else if (ESRCH == errno)
{
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_NOSUCHPROC, 3, pid, RTS_ERROR_LITERAL("continue"));
return ESRCH;
} else
assert(EINVAL != errno);
}
return send_mesg2gtmsecshr(CONTINUE_PROCESS, pid, NULL, 0);
}
STATICFNDEF void ext_stx_error(int in_error, ...)
{
va_list args;
char *ext_table_name;
char buf[MAX_SRC_LINE], *b;
int num_tabs, num_spaces;
va_start(args, in_error);
ext_table_name = va_arg(args, char *);
va_end(args);
num_tabs = ext_source_column/TABLEN;
num_spaces = ext_source_column%TABLEN;
b = &buf[0];
memset(buf, '\t', num_tabs+2);
b += num_tabs+NUM_TABS_FOR_GTMERRSTR;
memset(b, ' ', num_spaces);
b += num_spaces;
memcpy(b, "^-----", POINTER_SIZE);
b += POINTER_SIZE;
*b = 0;
dec_err(VARLSTCNT(6) ERR_EXTSRCLIN, 4, ext_source_line_len, ext_source_line, b - &buf[0], &buf[0]);
dec_err(VARLSTCNT(6) ERR_EXTSRCLOC, 4, ext_source_column, ext_source_line_num, LEN_AND_STR(ext_table_name));
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) in_error);
}
STATICFNDEF char *read_table(char *b, int l, FILE *f)
{
char *t;
int fclose_res;
ext_source_column = 0;
FGETS(b, l, f, t);
if (NULL == t)
{
if (0 != ferror(f))
{
FCLOSE(f, fclose_res);
/* Expand error message */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) errno);
} else
assert(feof(f) != 0);
} else
{
/* Unfortunately, fgets does not strip the NL, we will do it for it */
for (ext_source_line_len = 0; *t ; t++)
{
ext_source_line[ext_source_line_len++] = *t;
if (CR == *t)
{
*t = 0;
ext_source_line_num += 1;
break;
}
}
}
return t;
}
void iosocket_iocontrol(mstr *mn, int4 argcnt, va_list args)
{
char action[MAX_DEVCTL_LENGTH];
unsigned short depth;
int length, n, timeout;
pid_t pid;
mval *arg, *handlesvar = NULL;
#ifdef GTM_TLS
mval *option, *tlsid, *password, *extraarg;
#endif
if (0 == mn->len)
return;
assert(MAX_DEVCTL_LENGTH > mn->len);
lower_to_upper((uchar_ptr_t)action, (uchar_ptr_t)mn->addr, mn->len);
length = mn->len;
if (0 == memcmp(action, "LISTEN", length))
{
if (1 > argcnt)
depth = DEFAULT_LISTEN_DEPTH;
else
{
arg = va_arg(args, mval *);
if ((NULL == arg) || M_ARG_SKIPPED(arg) || !MV_DEFINED(arg))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_EXPR);
return;
}
depth = MV_FORCE_INTD(arg);
}
iosocket_listen(io_curr_device.in, depth);
} else if (0 == memcmp(action, "WAIT", length))
void mupip_rctldump(void)
{
# ifdef AUTORELINK_SUPPORTED
unsigned short max_len;
mstr dir;
char objdir[GTM_PATH_MAX];
open_relinkctl_sgm *linkctl;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (TREF(parms_cnt))
{
assert(1 == TREF(parms_cnt));
max_len = SIZEOF(objdir);
if (!cli_get_str("DIRECTORY", objdir, &max_len))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_MUPCLIERR);
dir.addr = objdir;
dir.len = max_len;
linkctl = relinkctl_attach(&dir);
assert(linkctl == TREF(open_relinkctl_list));
assert((NULL == linkctl) || (NULL == linkctl->next));
} else
zro_init();
util_out_print("", RESET); /* Reset output buffer */
zshow_rctldump(NULL); /* callee knows caller is mupip_rctldump type based on the NULL parameter */
# endif /* AUTORELINK_SUPPORTED */
}
int gtmsource_changelog(void)
{
uint4 changelog_desired = 0, changelog_accepted = 0;
int log_fd = 0; /*used to indicate whether the new specified log file is writable*/
int close_status = 0; /*used to indicate if log file is successfully closed*/
char* err_code;
int save_errno;
assert(holds_sem[SOURCE][JNL_POOL_ACCESS_SEM]);
repl_log(stderr, TRUE, TRUE, "Initiating CHANGELOG operation on source server pid [%d] for secondary instance [%s]\n",
jnlpool.gtmsource_local->gtmsource_pid, jnlpool.gtmsource_local->secondary_instname);
if (0 != jnlpool.gtmsource_local->changelog)
{
util_out_print("Change log is already in progress. Not initiating change in log file or log interval", TRUE);
return (ABNORMAL_SHUTDOWN);
}
if ('\0' != gtmsource_options.log_file[0]) /* trigger change in log file */
{
changelog_desired |= REPLIC_CHANGE_LOGFILE;
if (0 != STRCMP(jnlpool.gtmsource_local->log_file, gtmsource_options.log_file))
{ /*check if the new log file is writable*/
OPENFILE3_CLOEXEC(gtmsource_options.log_file,
O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, log_fd);
if (log_fd < 0)
{
save_errno = ERRNO;
err_code = STRERROR(save_errno);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_REPLLOGOPN, 6,
LEN_AND_STR(gtmsource_options.log_file),
LEN_AND_STR(err_code),
LEN_AND_STR(NULL_DEVICE));
} else {
CLOSEFILE_IF_OPEN(log_fd, close_status);
assert(close_status==0);
changelog_accepted |= REPLIC_CHANGE_LOGFILE;
STRCPY(jnlpool.gtmsource_local->log_file, gtmsource_options.log_file);
util_out_print("Change log initiated with file !AD", TRUE, LEN_AND_STR(gtmsource_options.log_file));
}
} else
util_out_print("Log file is already !AD. Not initiating change in log file", TRUE,
LEN_AND_STR(gtmsource_options.log_file));
}
if (0 != gtmsource_options.src_log_interval) /* trigger change in log interval */
{
changelog_desired |= REPLIC_CHANGE_LOGINTERVAL;
if (gtmsource_options.src_log_interval != jnlpool.gtmsource_local->log_interval)
{
changelog_accepted |= REPLIC_CHANGE_LOGINTERVAL;
jnlpool.gtmsource_local->log_interval = gtmsource_options.src_log_interval;
util_out_print("Change log initiated with interval !UL", TRUE, gtmsource_options.src_log_interval);
} else
util_out_print("Log interval is already !UL. Not initiating change in log interval", TRUE,
gtmsource_options.src_log_interval);
}
if (0 != changelog_accepted)
jnlpool.gtmsource_local->changelog = changelog_accepted;
else
util_out_print("No change to log file or log interval", TRUE);
return ((0 != changelog_accepted && changelog_accepted == changelog_desired) ? NORMAL_SHUTDOWN : ABNORMAL_SHUTDOWN);
}
void dse_f_free(void)
{
block_id blk;
boolean_t in_last_bmap, was_crit, was_hold_onto_crit;
cache_rec_ptr_t dummy_cr;
char util_buff[MAX_UTIL_LEN];
int4 bplmap, dummy_int, hint_mod_bplmap, hint_over_bplmap;
int4 lmap_bit, master_bit, nocrit_present, total_blks, util_len;
sm_uc_ptr_t lmap_base;
if (0 == cs_addrs->hdr->bplmap)
{ util_out_print("Cannot perform free block search: bplmap field of file header is zero.", TRUE);
return;
}
bplmap = cs_addrs->hdr->bplmap;
if (BADDSEBLK == (blk = dse_getblk("HINT", DSEBMLOK, DSEBLKNOCUR))) /* WARNING: assignment */
return;
hint_over_bplmap = blk / bplmap;
master_bit = bmm_find_free(hint_over_bplmap, cs_addrs->bmm,
(cs_addrs->ti->total_blks + bplmap - 1)/ bplmap);
if (-1 == master_bit)
{ util_out_print("Error: database full.", TRUE);
return;
}
in_last_bmap = (master_bit == (cs_addrs->ti->total_blks / bplmap));
was_crit = cs_addrs->now_crit;
nocrit_present = (CLI_NEGATED == cli_present("CRIT"));
DSE_GRAB_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
if(!(lmap_base = t_qread(master_bit * bplmap, &dummy_int, &dummy_cr)))
rts_error_csa(CSA_ARG(cs_addrs) VARLSTCNT(1) ERR_DSEBLKRDFAIL);
if (master_bit == hint_over_bplmap)
hint_mod_bplmap = blk - blk / bplmap * bplmap;
else
hint_mod_bplmap = 0;
if (in_last_bmap)
total_blks = (cs_addrs->ti->total_blks - master_bit);
else
total_blks = bplmap;
lmap_bit = bml_find_free(hint_mod_bplmap, lmap_base + SIZEOF(blk_hdr), total_blks);
if (-1 == lmap_bit)
{ memcpy(util_buff, "Error: bit map in block ", 24);
util_len = 24;
util_len += i2hex_nofill(master_bit * bplmap, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], " incorrectly marked free in master map.", 39);
util_len += 39;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE);
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
return;
}
memcpy(util_buff, "!/Next free block is ", 21);
util_len = 21;
util_len += i2hex_nofill(master_bit * bplmap + lmap_bit, (uchar_ptr_t)&util_buff[util_len], 8);
memcpy(&util_buff[util_len], ".!/", 3);
util_len += 3;
util_buff[util_len] = 0;
util_out_print(util_buff, TRUE);
DSE_REL_CRIT_AS_APPROPRIATE(was_crit, was_hold_onto_crit, nocrit_present, cs_addrs, gv_cur_region);
return;
}
STATICFNDEF void cleanup_trigger_hash(char *trigvn, int trigvn_len, char **values, uint4 *value_len, stringkey *set_hash,
stringkey *kill_hash, boolean_t del_kill_hash, int match_index)
{
sgmnt_addrs *csa;
uint4 len;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
gd_region *save_gv_cur_region;
gv_namehead *save_gv_target;
sgm_info *save_sgm_info_ptr;
mstr trigger_key;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
SAVE_TRIGGER_REGION_INFO;
SWITCH_TO_DEFAULT_REGION;
assert(0 != gv_target->root);
if (gv_cur_region->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(gv_cur_region));
if (NULL != strchr(values[CMD_SUB], 'S'))
{
SEARCH_AND_KILL_BY_HASH(trigvn, trigvn_len, set_hash, match_index, csa)
}
if (del_kill_hash)
{
SEARCH_AND_KILL_BY_HASH(trigvn, trigvn_len, kill_hash, match_index, csa);
}
RESTORE_TRIGGER_REGION_INFO;
}
/* --------------------------------------------------------------------------------
This function renames a file, if exists. Otherwise do nothing.
--------------------------------------------------------------------------------- */
int rename_file_if_exists(char *org_fn, int org_fn_len, char *rename_fn, int *rename_fn_len, uint4 *ustatus)
{
mstr orgfile;
int status;
jnl_tm_t now;
memcpy(rename_fn, org_fn, org_fn_len + 1); /* Ensure it to be NULL terminated */
*rename_fn_len = org_fn_len;
orgfile.addr = org_fn;
orgfile.len = org_fn_len;
if (FILE_NOT_FOUND == (status = gtm_file_stat(&orgfile, NULL, NULL, FALSE, ustatus)))
return RENAME_NOT_REQD;
else if (FILE_STAT_ERROR == status)
{
assert(SS_NORMAL != *ustatus);
return RENAME_FAILED;
}
/* File is present in the system */
assert(0 < MAX_FN_LEN - org_fn_len - 1);
JNL_SHORT_TIME(now);
if (SS_NORMAL != (status = prepare_unique_name(org_fn, org_fn_len, "", "", rename_fn, rename_fn_len, now, ustatus)))
{ /* "prepare_unique_name" would not have set "ustatus" to the error code. So set it here and return */
assert(SS_NORMAL == *ustatus);
*ustatus = status;
assert(SS_NORMAL != *ustatus);
return RENAME_FAILED;
}
assert(0 == rename_fn[*rename_fn_len]);
if (SS_NORMAL != (status = gtm_rename(org_fn, org_fn_len, rename_fn, *rename_fn_len, ustatus)))
{
*ustatus = status;
assert(SS_NORMAL != *ustatus);
if (IS_GTM_IMAGE)
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(9) ERR_RENAMEFAIL, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn,
status, 0, *ustatus);
else
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT1(8) ERR_RENAMEFAIL, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn,
status, PUT_SYS_ERRNO(*ustatus));
return RENAME_FAILED;
}
if (IS_GTM_IMAGE)
send_msg_csa(CSA_ARG(NULL) VARLSTCNT (6) ERR_FILERENAME, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn);
else
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT (6) ERR_FILERENAME, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn);
return RENAME_SUCCESS;
}
STATICFNDEF int4 update_trigger_name_value(char *trig_name, int trig_name_len, int new_trig_index)
{
int len;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
int num_len;
char *ptr;
int4 result;
mval trig_gbl;
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 */
/* $get(^#t("#TNAME",^#t(GVN,index,"#TRIGNAME"))) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1);
if (!gvcst_get(&trig_gbl))
{ /* There has to be a #TNAME entry */
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(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
trig_name_len - 1, trig_name);
}
ptr = trig_gbl.str.addr;
len = MIN(trig_gbl.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, len, len);
ptr += len;
if ((trig_gbl.str.len == len) || ('\0' != *ptr))
{
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(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
trig_name_len - 1, trig_name);
}
memcpy(name_and_index, trig_gbl.str.addr, ++len); /* inline increment intended */
ptr = name_and_index + len;
num_len = 0;
I2A(ptr, num_len, new_trig_index);
len += num_len;
/* set ^#t("#TNAME",<trigname>)=gblname_$C(0)_new_trig_index */
SET_TRIGGER_GLOBAL_SUB_SUB_STR(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1,
name_and_index, len, result);
return result;
}
boolean_t iosocket_switch(char *handle, int handle_len, d_socket_struct *from, d_socket_struct *to)
{
int4 index, ii;
socket_struct *socketptr;
if ((NULL == from) ||
(0 > (index = iosocket_handle(handle, &handle_len, FALSE, from))))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_SOCKNOTFND, 2, handle_len, handle);
return FALSE;
} else
{
/* attach the socket to "to" and set it to current */
assert(NULL != to);
if (0 <= iosocket_handle(handle, &handle_len, FALSE, to))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_SOCKETEXIST, 2, handle_len, handle);
return FALSE;
}
if (gtm_max_sockets <= to->n_socket)
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_SOCKMAX, 1, gtm_max_sockets);
return FALSE;
}
socketptr = from->socket[index];
socketptr->dev = to;
to->socket[to->n_socket++] = socketptr;
to->current_socket = to->n_socket - 1;
/* detach it from "from" */
if (from->current_socket >= index)
from->current_socket--;
for(ii = index; ii < from->n_socket - 1; ii++)
{
from->socket[ii] = from->socket[ii + 1];
}
from->n_socket--;
from->socket[from->n_socket] = NULL;
}
return TRUE;
}
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);
}
}
int main (int argc, char **argv)
{
int res;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
common_startup_init(MUPIP_IMAGE);
invocation_mode = MUMPS_UTILTRIGR;
err_init(util_base_ch);
UNICODE_ONLY(gtm_strToTitle_ptr = >m_strToTitle);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, NULL, suspsigs_handler, continue_handler); /* Note: no ^C handler is defined (yet) */
atexit(mupip_exit_handler);
licensed = TRUE;
in_backup = FALSE;
op_open_ptr = mu_op_open;
mu_get_term_characterstics();
gtm_chk_dist(argv[0]);
cli_lex_setup(argc,argv);
if (argc < 2) /* Interactive mode */
display_prompt();
/* this call should be after cli_lex_setup() due to S390 A/E conversion */
init_gtm();
while (TRUE)
{ func = 0;
if ((res = parse_cmd()) == EOF)
break;
else if (res)
{
if (1 < argc)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
else
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
}
if (func)
func();
if (argc > 1) /* Non-interactive mode, exit after command */
break;
display_prompt();
}
mupip_exit(SS_NORMAL);
return 0;
}
/* Enables tracing and ensures that all critical structures are initialized. */
void turn_tracing_on(mval *gvn, boolean_t from_env, boolean_t save_gbl)
{
trace_entry tmp_trc_tbl_entry;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
mdb_ch_set = !from_env;
/* If tracing is on explicitly, or if it is implicit with saving. */
if (save_gbl || !from_env)
{
if (is_tracing_on)
{
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_TRACINGON);
return;
}
if ((0 == gvn->str.len) || ('^' != gvn->str.addr[0]))
MPROF_RTS_ERROR((CSA_ARG(NULL) VARLSTCNT(4) ERR_NOTGBL, 2, gvn->str.len, gvn->str.addr));
}
/* The following should only be a one-time operation. */
if (!TREF(mprof_ptr))
{
TREF(mprof_ptr) = (mprof_wrapper *)malloc(SIZEOF(mprof_wrapper));
memset(TREF(mprof_ptr), 0, SIZEOF(mprof_wrapper));
}
/* Only need to have the gvn if we are going to save the data. */
if (save_gbl && (0 < gvn->str.len))
{
parse_gvn(gvn);
(TREF(mprof_ptr))->gbl_to_fill = *gvn;
(TREF(mprof_ptr))->gbl_to_fill.str.addr = (char *)malloc(gvn->str.len); /* Since len was already set up. */
memcpy((TREF(mprof_ptr))->gbl_to_fill.str.addr, gvn->str.addr, gvn->str.len);
}
/* Preallocate some space. */
if (!(TREF(mprof_ptr))->pcavailbase)
{
(TREF(mprof_ptr))->pcavailbase = (char **)malloc(PROFCALLOC_DSBLKSIZE);
*(TREF(mprof_ptr))->pcavailbase = 0;
}
(TREF(mprof_ptr))->pcavailptr = (TREF(mprof_ptr))->pcavailbase;
(TREF(mprof_ptr))->pcavail = PROFCALLOC_DSBLKSIZE - OFFSET_LEN;
memset((TREF(mprof_ptr))->pcavailptr + 1, 0, (TREF(mprof_ptr))->pcavail);
TIMES(&(TREF(mprof_ptr))->tprev);
UNIX_ONLY(child_times_usec();)
int gtmsource_mode_change(int to_mode)
{
uint4 savepid;
int exit_status;
int status, detach_status, remove_status;
int log_fd = 0, close_status = 0;
char* err_code;
int save_errno;
sgmnt_addrs *repl_csa;
assert(holds_sem[SOURCE][JNL_POOL_ACCESS_SEM]);
repl_log(stdout, TRUE, TRUE, "Initiating %s operation on source server pid [%d] for secondary instance [%s]\n",
(GTMSOURCE_MODE_ACTIVE_REQUESTED == to_mode) ? "ACTIVATE" : "DEACTIVATE",
jnlpool.gtmsource_local->gtmsource_pid, jnlpool.gtmsource_local->secondary_instname);
if ((jnlpool.gtmsource_local->mode == GTMSOURCE_MODE_ACTIVE_REQUESTED)
|| (jnlpool.gtmsource_local->mode == GTMSOURCE_MODE_PASSIVE_REQUESTED))
{
repl_log(stderr, FALSE, TRUE, "Source Server %s already requested, not changing mode\n",
(to_mode == GTMSOURCE_MODE_ACTIVE_REQUESTED) ? "ACTIVATE" : "DEACTIVATE");
return (ABNORMAL_SHUTDOWN);
}
if (((GTMSOURCE_MODE_ACTIVE == jnlpool.gtmsource_local->mode) && (GTMSOURCE_MODE_ACTIVE_REQUESTED == to_mode))
|| ((GTMSOURCE_MODE_PASSIVE == jnlpool.gtmsource_local->mode) && (GTMSOURCE_MODE_PASSIVE_REQUESTED == to_mode)))
{
repl_log(stderr, FALSE, TRUE, "Source Server already %s, not changing mode\n",
(to_mode == GTMSOURCE_MODE_ACTIVE_REQUESTED) ? "ACTIVE" : "PASSIVE");
return (ABNORMAL_SHUTDOWN);
}
assert(ROOTPRIMARY_UNSPECIFIED != gtmsource_options.rootprimary);
/*check if the new log file is writable*/
if ('\0' != gtmsource_options.log_file[0] && 0 != STRCMP(jnlpool.gtmsource_local->log_file, gtmsource_options.log_file))
{
OPENFILE3(gtmsource_options.log_file,
O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, log_fd);
if (log_fd < 0) {
save_errno = ERRNO;
err_code = STRERROR(save_errno);
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_REPLLOGOPN, 6,
LEN_AND_STR(gtmsource_options.log_file),
LEN_AND_STR(err_code),
LEN_AND_STR(NULL_DEVICE));
return (ABNORMAL_SHUTDOWN);
}
CLOSEFILE_IF_OPEN(log_fd, close_status);
assert(close_status==0);
}
if ((GTMSOURCE_MODE_ACTIVE_REQUESTED == to_mode)
&& (ROOTPRIMARY_SPECIFIED == gtmsource_options.rootprimary) && jnlpool.jnlpool_ctl->upd_disabled)
{ /* ACTIVATE is specified with ROOTPRIMARY on a journal pool that was created with PROPAGATEPRIMARY. This is a
* case of transition from propagating primary to root primary. Enable updates in this journal pool and append
* a histinfo record to the replication instance file. The function "gtmsource_rootprimary_init" does just that.
*/
gtmsource_rootprimary_init(jnlpool.jnlpool_ctl->jnl_seqno);
}
DEBUG_ONLY(repl_csa = &FILE_INFO(jnlpool.jnlpool_dummy_reg)->s_addrs;)
void iott_close(io_desc *v, mval *pp)
{
d_tt_struct *ttptr;
params ch;
int status;
int p_offset;
boolean_t ch_set;
assert(v->type == tt);
if (v->state != dev_open)
return;
ESTABLISH_GTMIO_CH(&v->pair, ch_set);
iott_flush(v);
if (v->pair.in != v)
assert(v->pair.out == v);
ttptr = (d_tt_struct *)v->dev_sp;
if (v->pair.out != v)
assert(v->pair.in == v);
v->state = dev_closed;
resetterm(v);
p_offset = 0;
while (*(pp->str.addr + p_offset) != iop_eol)
{
if ((ch = *(pp->str.addr + p_offset++)) == iop_exception)
{
v->error_handler.len = *(pp->str.addr + p_offset);
v->error_handler.addr = (char *)(pp->str.addr + p_offset + 1);
s2pool(&v->error_handler);
}
p_offset += ((IOP_VAR_SIZE == io_params_size[ch]) ?
(unsigned char)*(pp->str.addr + p_offset) + 1 : io_params_size[ch]);
}
if (v == io_std_device.in || (v == io_std_device.out))
{
REVERT_GTMIO_CH(&v->pair, ch_set);
return;
}
CLOSEFILE_RESET(ttptr->fildes, status); /* resets "ttptr->fildes" to FD_INVALID */
if (0 != status)
{
assert(status == errno);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5,
RTS_ERROR_LITERAL("iott_close(CLOSEFILE)"), CALLFROM, status);
}
if (ttptr->recall_buff.addr)
{
free(ttptr->recall_buff.addr);
ttptr->recall_buff.addr = NULL;
}
REVERT_GTMIO_CH(&v->pair, ch_set);
return;
}