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)
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)); }
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; }
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 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; }
void util_help(void) { int rc; char *help_option; char help_cmd_string[HELP_CMD_STRING_SIZE]; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; assert(1 >= TREF(parms_cnt)); assert(GTM_IMAGE < image_type && UTIL_HELP_IMAGES > image_type); if (0 == TREF(parms_cnt)) help_option = utilImageGLDs[INVALID_IMAGE]; else { assert(TAREF1(parm_ary, TREF(parms_cnt) - 1)); assert((char *)-1L != (TAREF1(parm_ary, TREF(parms_cnt) - 1))); help_option = (TAREF1(parm_ary, TREF(parms_cnt) - 1)); } SNPRINTF(help_cmd_string, SIZEOF(help_cmd_string), "$gtm_dist/mumps -run %%XCMD 'do ^GTMHELP(\"%s\",\"$gtm_dist/%shelp.gld\")'", help_option, utilImageGLDs[image_type]); rc = SYSTEM(help_cmd_string); if (0 != rc) rts_error_csa(NULL, VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_TEXT("HELP command error"), rc); }
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 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 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 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 */ }
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); } }
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; }
void sgnl_gvnulsubsc(void) { unsigned char buff[MAX_ZWR_KEY_SZ], *end; if ((end = format_targ_key(&buff[0], MAX_ZWR_KEY_SZ, gv_currkey, TRUE)) == 0) { end = &buff[MAX_ZWR_KEY_SZ - 1]; } gv_currkey->end = 0; rts_error_csa(NULL, VARLSTCNT(8) ERR_NULSUBSC, 2, gv_cur_region->rname_len, &gv_cur_region->rname[0], ERR_GVIS, 2, end - &buff[0], &buff[0]); }
int gtm_conv(UConverter* from, UConverter* to, mstr *src, char* dstbuff, int* bufflen) { char *dstptr, *dstbase, *srcptr; const char *ichset; int dstlen, src_charlen, srclen; UErrorCode status, status1; if (0 == src->len) return 0; if (NULL == dstbuff) { /* Compute the stringpool buffer space needed for conversion given that source * is encoded in the ichset representation. The ICU functions ucnv_getMinCharSize() * and ucnv_getMaxCharSize() are used to compute the minimum and maximum number of * bytes required per UChar if converted from/to ichset/ochset respectively */ src_charlen = (src->len / ucnv_getMinCharSize(from)) + 1; /* number of UChar's from ichset */ dstlen = UCNV_GET_MAX_BYTES_FOR_STRING(src_charlen, ucnv_getMaxCharSize(to)); dstlen = (dstlen > MAX_STRLEN) ? MAX_STRLEN : dstlen; ENSURE_STP_FREE_SPACE(dstlen); dstbase = (char *)stringpool.free; } else { dstbase = dstbuff; dstlen = *bufflen; } srcptr = src->addr; srclen = (int)src->len; dstptr = dstbase; status = U_ZERO_ERROR; /* initialization to "success" is required by ICU */ ucnv_convertEx(to, from, &dstptr, dstptr + dstlen, (const char**)&srcptr, srcptr + srclen, NULL, NULL, NULL, NULL, TRUE, TRUE, &status); if (U_FAILURE(status)) { if (U_BUFFER_OVERFLOW_ERROR == status) { /* translation requires more space than the maximum allowed GT.M string size */ if (NULL == dstbuff) rts_error_csa(NULL, VARLSTCNT(1) ERR_MAXSTRLEN); else { /* Insufficient buffer passed. Return the required buffer length */ src_charlen = (srclen / ucnv_getMinCharSize(from)) + 1; *bufflen = UCNV_GET_MAX_BYTES_FOR_STRING(src_charlen, ucnv_getMaxCharSize(to)); return -1; } } status1 = U_ZERO_ERROR; ichset = ucnv_getName(from, &status1); assert(U_SUCCESS(status1)); UTF8_BADCHAR(1,(unsigned char *) (srcptr - 1), NULL,STRLEN(ichset), ichset); } return (int) (dstptr - dstbase); }
static bool dse_process(int argc) { int res; ESTABLISH_RET(util_ch, TRUE); func = 0; util_interrupt = 0; if (EOF == (res = parse_cmd())) { if (util_interrupt) { rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_CTRLC); REVERT; return TRUE; } else { REVERT; return FALSE; } } else if (res) { if (1 < argc) { /* Here we need to REVERT since otherwise we stay in dse in a loop * The design of dse needs to be changed to act like VMS (which is: * if there is an error in the dse command (dse dumpoa), go to command * prompt, but UNIX exits */ REVERT; 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(); REVERT; return(1 >= argc); }
void op_gvincr(mval *increment, mval *result) { unsigned char buff[MAX_ZWR_KEY_SZ], *end; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; /* If specified var name is global ^%Y*, the name is illegal to use in a SET or KILL command, only GETs are allowed */ if ((RESERVED_NAMESPACE_LEN <= gv_currkey->end) && (0 == MEMCMP_LIT(gv_currkey->base, RESERVED_NAMESPACE))) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_PCTYRESERVED); if (gv_cur_region->read_only) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_DBPRIVERR, 2, DB_LEN_STR(gv_cur_region)); if ((TREF(gv_last_subsc_null) || TREF(gv_some_subsc_null)) && (ALWAYS != gv_cur_region->null_subs)) sgnl_gvnulsubsc(); assert(gv_currkey->end + 1 <= gv_cur_region->max_key_size); MV_FORCE_NUM(increment); switch (gv_cur_region->dyn.addr->acc_meth) { case dba_bg: case dba_mm: gvcst_incr(increment, result); break; case dba_cm: gvcmx_increment(increment, result); break; case dba_usr: /* $INCR not supported for DDP/USR access method */ if (0 == (end = format_targ_key(buff, MAX_ZWR_KEY_SZ, gv_currkey, TRUE))) end = &buff[MAX_ZWR_KEY_SZ - 1]; rts_error_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_UNIMPLOP, 0, ERR_TEXT, 2, LEN_AND_LIT("GTCM DDP server does not support $INCREMENT"), ERR_GVIS, 2, end - buff, buff, ERR_TEXT, 2, REG_LEN_STR(gv_cur_region)); break; default: assertpro(FALSE); } assert(MV_DEFINED(result)); }
void emit_op_base_offset(generic_op op, short base_reg, int offset, short use_reg) { switch (op) { case CLEAR: code_buf[code_idx++] = I386_INS_MOV_Ev_Iv; emit_base_offset(0, base_reg, offset); *((int4 *)&code_buf[code_idx]) = 0; code_idx += SIZEOF(int4); break; case COMPARE: code_buf[code_idx++] = I386_INS_CMP_Gv_Ev; emit_base_offset(use_reg, base_reg, offset); break; case INCREMENT: code_buf[code_idx++] = I386_INS_Grp5_Prefix; emit_base_offset(I386_INS_INC_Ev, base_reg, offset); break; case LOAD: code_buf[code_idx++] = I386_INS_MOV_Gv_Ev; emit_base_offset(use_reg, base_reg, offset); break; case LOAD_ADDRESS: code_buf[code_idx++] = I386_INS_LEA_Gv_M; emit_base_offset(use_reg, base_reg, offset); break; case PUSH: code_buf[code_idx++] = I386_INS_Grp5_Prefix; emit_base_offset(I386_INS_PUSH_Ev, base_reg, offset); break; case PUSH_ADDRESS: code_buf[code_idx++] = I386_INS_LEA_Gv_M; emit_base_offset(use_reg, base_reg, offset); code_buf[code_idx++] = I386_INS_PUSH_eAX + use_reg; break; case STORE: code_buf[code_idx++] = I386_INS_MOV_Ev_Gv; emit_base_offset(use_reg, base_reg, offset); break; case TEST: code_buf[code_idx++] = I386_INS_Grp1_Ev_Ib_Prefix; emit_base_offset(I386_INS_CMP__, base_reg, offset); code_buf[code_idx++] = 0; break; default: rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); break; } }
void op_fnzconvert3(mval *src, mval* ichset, mval* ochset, mval* dst) { UConverter *from, *to; int dstlen; MV_FORCE_STR(src); if (!gtm_utf8_mode) { /* Unicode not enabled, report error rather than silently ignoring the conversion */ rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_INVFCN, 0, ERR_TEXT, 2, LEN_AND_LIT("Three-argument form of $ZCONVERT() is not allowed in the current $ZCHSET")); } MV_FORCE_STR(ichset); MV_FORCE_STR(ochset); /* The only supported names are: "UTF-8", "UTF-16", "UTF-16LE" and "UTF-16BE */ if (NULL == (from = get_chset_desc(&ichset->str))) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_BADCHSET, 2, ichset->str.len, ichset->str.addr); if (NULL == (to = get_chset_desc(&ochset->str))) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_BADCHSET, 2, ochset->str.len, ochset->str.addr); dstlen = gtm_conv(from, to, &src->str, NULL, NULL); assert(-1 != dstlen); MV_INIT_STRING(dst, dstlen, stringpool.free); stringpool.free += dst->str.len; }
int4 add_inter(int val, sm_int_ptr_t addr, sm_global_latch_ptr_t latch) { int4 cntrval, newcntrval, spins, maxspins, retries; boolean_t cswpsuccess; sm_int_ptr_t volatile cntrval_p; ++fast_lock_count; maxspins = num_additional_processors ? MAX_LOCK_SPINS(LOCK_SPINS, num_additional_processors) : 1; cntrval_p = addr; /* Need volatile context especially on Itanium */ for (retries = LOCK_TRIES - 1; 0 < retries; retries--) /* - 1 so do rel_quant 3 times first */ { /* seems like a legitinate spin which could take advantage of transactional memory */ for (spins = maxspins; 0 < spins; spins--) { cntrval = *cntrval_p; newcntrval = cntrval + val; /* This is (currently as of 08/2007) the only non-locking usage of compswap in GT.M. We are not passing compswap an actual sm_global_latch_ptr_t addr like its function would normally dictate. However, since the address of the field we want to deal with is the first int in the global_latch_t, we just pass our int address properly cast to the type that compswap is expecting. The assert below verifies that this assumption has not changed (SE 08/2007) */ assert(0 == OFFSETOF(global_latch_t, u.parts.latch_pid)); IA64_ONLY(cswpsuccess = compswap_unlock(RECAST(sm_global_latch_ptr_t)cntrval_p, cntrval, newcntrval)); NON_IA64_ONLY(cswpsuccess = compswap((sm_global_latch_ptr_t)cntrval_p, cntrval, newcntrval)); if (cswpsuccess) { --fast_lock_count; assert(0 <= fast_lock_count); return newcntrval; } } if (retries & 0x3) /* On all but every 4th pass, do a simple rel_quant */ rel_quant(); /* Release processor to holder of lock (hopefully) */ else { /* On every 4th pass, we bide for awhile */ wcs_sleep(LOCK_SLEEP); assert(0 == (LOCK_TRIES % 4)); /* assures there are 3 rel_quants prior to first wcs_sleep() */ } } --fast_lock_count; assert(FALSE); rts_error_csa(CSA_ARG(NULL) VARLSTCNT(9) ERR_DBCCERR, 2, LEN_AND_LIT("*unknown*"), ERR_ERRCALL, 3, CALLFROM); return 0; /* To keep the compiler quiet */ }
boolean_t job_addr(mstr *rtn, mstr *label, int4 offset, char **hdr, char **labaddr, boolean_t *need_rtnobj_shm_free) { rhdtyp *rt_hdr; int4 *lp; mval rt; DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; if (NULL == (rt_hdr = find_rtn_hdr(rtn))) { rt.mvtype = MV_STR; rt.str = *rtn; op_zlink(&rt, NULL); rt_hdr = find_rtn_hdr(rtn); if (NULL == rt_hdr) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_ZLINKFILE, 2, rtn->len, rtn->addr, ERR_ZLMODULE, 2, STRLEN(&zlink_mname.c[0]), &zlink_mname); *need_rtnobj_shm_free = ARLINK_ONLY(rt_hdr->shared_object) NON_ARLINK_ONLY(FALSE); *hdr = (char *)rt_hdr; } else *need_rtnobj_shm_free = FALSE; lp = NULL; if ((rt_hdr->compiler_qlf & CQ_LINE_ENTRY) || (0 == offset)) /* Label offset with routine compiled with NOLINE_ENTRY should cause error. */ lp = find_line_addr(rt_hdr, label, offset, NULL); if (!lp) return (FALSE); /* Set the pointer to address / offset for line number entry storage in TABENT_PROXY. */ # ifdef USHBIN_SUPPORTED ARLINK_ONLY((TABENT_PROXY).rtnhdr_adr = rt_hdr); (TABENT_PROXY).lnr_adr = lp; # else /* On non-shared-binary, calculcate the offset to the corresponding lnr_tabent record by subtracting * the base address (routine header) from line number entry's address, and save the result in * lab_ln_ptr field of TABENT_PROXY structure. */ (TABENT_PROXY).lab_ln_ptr = ((int4)lp - (int4)rt_hdr); # endif if (NULL != labaddr) *labaddr = (char *)LINE_NUMBER_ADDR(rt_hdr, lp); *hdr = (char *)rt_hdr; return (TRUE); }
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; }
void emit_op_alit (generic_op op, unsigned char use_reg) { switch (op) { case LOAD_ADDRESS: code_buf[code_idx++] = I386_INS_MOV_eAX + use_reg; break; case PUSH: code_buf[code_idx++] = I386_INS_Grp5_Prefix; modrm_byte.modrm.reg_opcode = I386_INS_PUSH_Ev; modrm_byte.modrm.mod = I386_MOD32_BASE; modrm_byte.modrm.r_m = I386_REG_disp32_NO_BASE; code_buf[code_idx++] = modrm_byte.byte; break; case PUSH_ADDRESS: code_buf[code_idx++] = I386_INS_PUSH_Iv; break; default: rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); break; } }
static void clean_initialize(mutex_struct_ptr_t addr, int n, bool crash) { mutex_que_entry_ptr_t q_free_entry; # if defined(MUTEX_MSEM_WAKE) && !defined(POSIX_MSEM) msemaphore *status; # endif assert(n > 0); addr->queslots = n; /* Initialize the waiting process queue to be empty */ addr->prochead.que.fl = addr->prochead.que.bl = 0; SET_LATCH_GLOBAL(&addr->prochead.latch, LOCK_AVAILABLE); /* Initialize the free queue to be empty */ addr->freehead.que.fl = addr->freehead.que.bl = 0; SET_LATCH_GLOBAL(&addr->freehead.latch, LOCK_AVAILABLE); /* Clear the first free entry */ q_free_entry = (mutex_que_entry_ptr_t)((sm_uc_ptr_t)&addr->freehead + SIZEOF(mutex_que_head)); q_free_entry->que.fl = q_free_entry->que.bl = 0; q_free_entry->pid = 0; q_free_entry->super_crit = (void *)NULL; q_free_entry->mutex_wake_instance = 0; while (n--) { # ifdef MUTEX_MSEM_WAKE # ifdef POSIX_MSEM if (-1 == sem_init(&q_free_entry->mutex_wake_msem, TRUE, 0)) /* Shared lock with no initial resources (locked) */ # else if ((NULL == (status = msem_init(&q_free_entry->mutex_wake_msem, MSEM_LOCKED))) || ((msemaphore *)-1 == status)) # endif rts_error_csa(CSA_ARG(NULL) VARLSTCNT(7) ERR_MUTEXERR, 0, ERR_TEXT, 2, RTS_ERROR_TEXT("Error with mutex wait memory semaphore initialization"), errno); # endif /* Initialize fl,bl links to 0 before INSQTI as it (gtm_insqti in relqueopi.c) asserts this */ DEBUG_ONLY(((que_ent_ptr_t)q_free_entry)->fl = 0;) DEBUG_ONLY(((que_ent_ptr_t)q_free_entry)->bl = 0;) if (INTERLOCK_FAIL == INSQTI((que_ent_ptr_t)q_free_entry++, (que_head_ptr_t)&addr->freehead))
void op_zut(mval *s) { struct timeval tv; gtm_int8 microseconds, msectmp; int numdigs; int4 pwr; assertpro(-1 != gettimeofday(&tv, NULL)); microseconds = (1LL * MICROSEC_IN_SEC * tv.tv_sec) + tv.tv_usec; if ((microseconds < 0) && (microseconds > E_18)) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_WEIRDSYSTIME); if (microseconds < E_6) { s->m[1] = ((int4)microseconds * 1000); s->mvtype = MV_INT | MV_NM; } else { msectmp = microseconds; /* Count the number of digits */ for (numdigs = 0; msectmp; numdigs++, msectmp /= 10); if (numdigs <= NUM_DEC_DG_1L) { s->m[0] = 0; s->m[1] = (int4)microseconds * ten_pwr[NUM_DEC_DG_1L - numdigs]; } else { pwr = ten_pwr[numdigs - NUM_DEC_DG_1L]; s->m[0] = (microseconds % pwr) * ten_pwr[NUM_DEC_DG_2L - numdigs]; s->m[1] = microseconds / pwr; } s->mvtype = MV_NM; s->e = MV_XBIAS + numdigs; } s->sgn = 0; return; }