void jnl_file_close(gd_region *reg, bool clean, bool dummy) { jnl_file_header header; sgmnt_addrs *csa; jnl_private_control *jpc; jnl_buffer_ptr_t jb; struct_jrec_eof eof_record; off_jnl_t eof_addr; uint4 status; error_def (ERR_PREMATEOF); error_def (ERR_JNLCLOSE); error_def (ERR_JNLWRERR); csa = &FILE_INFO(reg)->s_addrs; assert(csa->now_crit || (csa->hdr->clustered && (CCST_CLOSED == csa->nl->ccp_state))); ASSERT_JNLFILEID_NOT_NULL(csa) jpc = csa->jnl; #if defined(UNIX) if (csa->dbsync_timer) { cancel_timer((TID)csa); csa->dbsync_timer = FALSE; } #elif defined(VMS) /* See comment about ordering of the two statements below, in similar code in gds_rundown */ if (csa->dbsync_timer) { csa->dbsync_timer = FALSE; ++astq_dyn_avail; } sys$cantim(csa, PSL$C_USER); /* cancel all dbsync-timers for this region */ #endif if ((NULL == jpc) || (NOJNL == jpc->channel)) return; if (clean) { jb = jpc->jnl_buff; jnl_write_eof_rec(csa, &eof_record); jnl_flush(reg); assert(jb->dskaddr == jb->freeaddr); UNIX_ONLY(jnl_fsync(reg, jb->dskaddr);) UNIX_ONLY(assert(jb->freeaddr == jb->fsync_dskaddr);)
void show_source_line(char* buf, boolean_t warn) { char *b, *c, *c_top; int chlen, chwidth; unsigned int ch; error_def(ERR_SRCLIN); error_def(ERR_SRCLOC); for (c = (char *)source_buffer, b = buf, c_top = c + last_source_column - 1; c < c_top; ) { if (*c == '\t') *b++ = *c++; else if (!gtm_utf8_mode || *(uchar_ptr_t)c <= ASCII_MAX) { *b++ = ' '; c++; } #ifdef UNICODE_SUPPORTED else { chlen = (int)(UTF8_MBTOWC(c, c_top, ch) - (uchar_ptr_t)c); if (WEOF != ch && 0 < (chwidth = UTF8_WCWIDTH(ch))) { memset(b, ' ', chwidth); b += chwidth; } c += chlen; } #endif } memcpy(b, ARROW, STR_LIT_LEN(ARROW)); b += STR_LIT_LEN(ARROW); *b = '\0'; if (warn) { dec_nofac = TRUE; dec_err(VARLSTCNT (6) ERR_SRCLIN, 4, LEN_AND_STR((char *)source_buffer), b - buf, buf); if (!run_time) dec_err(VARLSTCNT(6) ERR_SRCLOC, 4, last_source_column, source_line, source_name_len, source_file_name); dec_nofac = FALSE; } }
void iosocket_flush(io_desc *iod) { #ifdef C9A06001531 /* pending change request C9A06001531 */ d_socket_struct *dsocketptr; socket_struct *socketptr; int on = 1, off = 0; char *errptr; int4 errlen; error_def(ERR_SOCKWRITE); error_def(ERR_TEXT); error_def(ERR_CURRSOCKOFR); assert(gtmsocket == iod->type); dsocketptr = (d_socket_struct *)iod->dev_sp; socketptr = dsocketptr->socket[dsocketptr->current_socket]; if (dsocketptr->current_socket >= dsocketptr->n_socket) { rts_error(VARLSTCNT(4) ERR_CURRSOCKOFR, 2, dsocketptr->current_socket, dsocketptr->n_socket); return; } memcpy(dsocketptr->dollar_device, "0", SIZEOF("0")); if( -1 == tcp_routines.aa_setsockopt(socketptr->sd, SOL_SOCKET, TCP_NODELAY, &on, SIZEOF(on)) || (-1 == tcp_routines.aa_setsockopt(socketptr->sd, SOL_SOCKET, TCP_NODELAY, &off, SIZEOF(off)))) { errptr = (char *)STRERROR(errno); errlen = strlen(errptr); iod->dollar.za = 9; MEMCPY_LIT(dsocketptr->dollar_device, "1,"); memcpy(&dsocketptr->dollar_device[SIZEOF("1,") - 1], errptr, errlen + 1); /* we want the null */ if (socketptr->ioerror) rts_error(VARLSTCNT(6) ERR_SOCKWRITE, 0, ERR_TEXT, 2, errlen, errptr); return; } #endif return; }
viewtab_entry *viewkeys(mstr *v) { /* given view keyword, return pointer to viewtab_entry for that keyword or: return 0 means not found, return -1 means keyword is ambiguous */ unsigned char cmpbuf[VT_KWSIZE]; const viewtab_entry *vt_ptr, *vt_top; short len; int n; error_def(ERR_VIEWNOTFOUND); error_def(ERR_VIEWAMBIG); if (v->len == 0) vt_ptr = (viewtab_entry *)NULL; else { len = (v->len < sizeof(cmpbuf) ? v->len : sizeof(cmpbuf)); lower_to_upper(cmpbuf, (uchar_ptr_t)v->addr, len); vt_top = TOP_VIEWTAB_ENTRY; for (vt_ptr = viewtab ; vt_ptr < vt_top ; vt_ptr++) { n = memcmp(vt_ptr->keyword, cmpbuf, len); if (n > 0) { vt_ptr = 0; break; } else if (n == 0) { if (vt_ptr < vt_top - 1 && memcmp(cmpbuf, (vt_ptr + 1)->keyword, len) == 0) vt_ptr = (viewtab_entry *)-1L; break; } } } if (vt_ptr == (viewtab_entry *)-1L) rts_error(VARLSTCNT(4) ERR_VIEWAMBIG, 2, v->len, v->addr); else if (!vt_ptr || vt_ptr >= vt_top) rts_error(VARLSTCNT(4) ERR_VIEWNOTFOUND, 2, v->len, v->addr); return (viewtab_entry *)vt_ptr; }
void rel_crit(gd_region *reg) { unix_db_info *udi; sgmnt_addrs *csa; enum cdb_sc status; error_def(ERR_CRITRESET); error_def(ERR_DBCCERR); udi = FILE_INFO(reg); csa = &udi->s_addrs; assert(!hold_onto_locks && !csa->hold_onto_crit); if (csa->now_crit) { assert(0 == crit_count); crit_count++; /* prevent interrupts */ assert(csa->nl->in_crit == process_id || csa->nl->in_crit == 0); CRIT_TRACE(crit_ops_rw); /* see gdsbt.h for comment on placement */ csa->nl->in_crit = 0; DEBUG_ONLY(locknl = csa->nl;) /* for DEBUG_ONLY LOCK_HIST macro */
/* Lookup package. Return package handle if success, NULL otherwise. * package_name - DLL name * msgtype - message severity of the errors reported if any. * Note - Errors are not issued if msgtype is SUCCESS, which is to be used if the callers are not * interested in message report and not willing to have condition handler overhead. */ void_ptr_t fgn_getpak(char *package_name, int msgtype) { void_ptr_t ret_handle; char_ptr_t dummy_err_str; char err_str[MAX_ERRSTR_LEN]; /* needed as util_out_print doesn't handle 64bit pointers */ error_def(ERR_TEXT); error_def(ERR_DLLNOOPEN); if (!(ret_handle = dlopen(package_name, RTLD_LAZY))) { if (SUCCESS != msgtype) { assert(!(msgtype & ~SEV_MSK)); COPY_DLLERR_MSG; rts_error(VARLSTCNT(8) MAKE_MSG_TYPE(ERR_DLLNOOPEN, msgtype), 2, LEN_AND_STR(package_name), ERR_TEXT, 2, LEN_AND_STR(err_str)); } } return ret_handle; }
void jnlext_write(fi_type *file_info, char *buffer, int length) { uint4 status; error_def (ERR_JNLEXTR); file_info->rab->rab$w_rsz = length - 1; file_info->rab->rab$l_rbf = buffer; status = sys$put(file_info->rab); if (status != RMS$_NORMAL) rts_error(VARLSTCNT(5) ERR_JNLEXTR, 2, file_info->fab->fab$b_fns, file_info->fab->fab$l_fna, status); }
void op_decrlock(int4 timeout) { int count; mlk_pvtblk **prior; void lckclr(void); error_def(ERR_TPLOCK); lckclr(); if (tp_pointer) { prior = &mlk_pvt_root; for (count = 0; count < lks_this_cmd; count++) { /* if there were any old locks before TSTART, they can't be unlocked */ if ((*prior)->granted && (*prior)->tp && (*prior)->tp->level > (*prior)->level - (*prior)->translev) rts_error(VARLSTCNT(1) ERR_TPLOCK); prior = &((*prior)->next); } } prior = &mlk_pvt_root; for (count = 0; count < lks_this_cmd; count++) { if (prior) { if (!(*prior)->granted) { /* if entry was never granted, delete list entry */ mlk_pvtblk_delete(prior); } else { (*prior)->level -= (*prior)->translev > (*prior)->level ? (*prior)->level : (*prior)->translev; if (!(*prior)->zalloc && (0 == (*prior)->level)) { mlk_unlock(*prior); mlk_pvtblk_delete(prior); } else prior = &((*prior)->next); } } } if (gtcm_connection && remlkreq) { cm_action = INCREMENTAL; gvcmx_unlock(0, TRUE, INCREMENTAL); remlkreq = FALSE; } return; }
int m_tcommit(void) { error_def(ERR_SPOREOL); if (window_token != TK_EOL && window_token != TK_SPACE) { stx_error(ERR_SPOREOL); return FALSE; } newtriple(OC_TCOMMIT); return TRUE; }
void op_commarg(mval *v, unsigned char argcode) { bool rval; mstr *obj, object; icode_str indir_src; error_def (ERR_INDEXTRACHARS); MV_FORCE_STR(v); assert(argcode >=3 && argcode < SIZEOF(indir_fcn) / SIZEOF(indir_fcn[0])); indir_src.str = v->str; indir_src.code = argcode; if (NULL == (obj = cache_get(&indir_src))) { if (((indir_do == argcode) || (indir_goto == argcode)) && (frame_pointer->type & SFT_COUNT) && v->str.len && (v->str.len < MAX_MIDENT_LEN) && !proc_act_type && do_indir_do(v, argcode)) { return; } comp_init(&v->str); for (;;) { if (!(rval = (*indir_fcn[argcode])())) break; if (TK_EOL == window_token) break; if (TK_COMMA == window_token) advancewindow(); else { /* Allow trailing spaces/comments that we will ignore */ while (TK_SPACE == window_token) advancewindow(); if (TK_EOL == window_token) break; rts_error(VARLSTCNT(1) ERR_INDEXTRACHARS); } } if (comp_fini(rval, &object, OC_RET, 0, v->str.len)) { indir_src.str.addr = v->str.addr; /* we reassign because v->str.addr might have been changed by stp_gcol() */ cache_put(&indir_src, &object); comp_indr(&object); if (indir_linetail == argcode) frame_pointer->type = SFT_COUNT; } } else { comp_indr(obj); if (indir_linetail == argcode) frame_pointer->type = SFT_COUNT; } }
/* * ----------------------------------------------- * op_fnqlength() * MUMPS QLength function * * Arguments: * src - Pointer to Source Name string mval * dst - destination buffer to save the piece in * Return: * none * ----------------------------------------------- */ void op_fnqlength(mval *src, mval *dst) { int dummy1; int dummy2; int subscripts = -2; /* no interest in finding a particular component */ error_def(ERR_NOCANONICNAME); if (!is_canonic_name(src, &subscripts, &dummy1, &dummy2)) rts_error(VARLSTCNT(4) ERR_NOCANONICNAME, 2, src->str.len, src->str.addr); MV_FORCE_MVAL(dst, subscripts); /* is_canonic_name has to parse anyway, so take count from it */ return; }
/* make sure that the journal file is available if appropriate */ uint4 jnl_ensure_open(void) { uint4 jnl_status; jnl_private_control *jpc; sgmnt_addrs *csa; sgmnt_data_ptr_t csd; boolean_t first_open_of_jnl, need_to_open_jnl; int close_res; # if defined(VMS) static const gds_file_id file; uint4 status; # endif error_def(ERR_JNLFILOPN); csa = cs_addrs; csd = csa->hdr; assert(csa->now_crit); jpc = csa->jnl; assert(NULL != jpc); assert(JNL_ENABLED(csa->hdr)); /* The goal is to change the code below to do only one JNL_FILE_SWITCHED(jpc) check instead of the additional * (NOJNL == jpc->channel) check done below. The assert below ensures that the NOJNL check can indeed * be subsumed by the JNL_FILE_SWITCHED check (with the exception of the source-server which has a special case that * needs to be fixed in C9D02-002241). Over time, this has to be changed to one check. */ assert((NOJNL != jpc->channel) || JNL_FILE_SWITCHED(jpc) || is_src_server); need_to_open_jnl = FALSE; jnl_status = 0; if (NOJNL == jpc->channel) { # ifdef VMS if (NOJNL != jpc->old_channel) { if (lib$ast_in_prog()) /* called from wcs_wipchk_ast */ jnl_oper_user_ast(gv_cur_region); else { status = sys$setast(DISABLE); jnl_oper_user_ast(gv_cur_region); if (SS$_WASSET == status) ENABLE_AST; } } # endif need_to_open_jnl = TRUE; } else if (JNL_FILE_SWITCHED(jpc)) { /* The journal file has been changed "on the fly"; close the old one and open the new one */ VMS_ONLY(assert(FALSE);) /* everyone having older jnl open should have closed it at time of switch in VMS */ JNL_FD_CLOSE(jpc->channel, close_res); /* sets jpc->channel to NOJNL */ need_to_open_jnl = TRUE; }
int mu_extr_getblk(unsigned char *ptr) { error_def(ERR_GVGETFAIL); enum cdb_sc status; rec_hdr_ptr_t rp; bool two_histories, end_of_tree; blk_hdr_ptr_t bp; srch_blk_status *bh; srch_hist *rt_history; t_begin(ERR_GVGETFAIL, FALSE); for (;;) { if (cdb_sc_normal != (status = gvcst_search(gv_currkey, NULL))) { t_retry(status); continue; } end_of_tree = two_histories = FALSE; bh = gv_target->hist.h; rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset); bp = (blk_hdr_ptr_t)bh->buffaddr; if (rp >= (rec_hdr_ptr_t)CST_TOB(bp)) { rt_history = gv_target->alt_hist; if (cdb_sc_normal == (status = gvcst_rtsib(rt_history, 0))) { two_histories = TRUE; if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, rt_history->h))) { t_retry(status); continue; } bp = (blk_hdr_ptr_t)rt_history->h[0].buffaddr; } else if (cdb_sc_endtree == status) end_of_tree = TRUE; else { t_retry(status); continue; } } memcpy(ptr, bp, bp->bsiz); if (t_end(&gv_target->hist, two_histories ? rt_history : NULL) != 0) { if (two_histories) memcpy(gv_target->hist.h, rt_history->h, sizeof(srch_blk_status) * (rt_history->depth + 1)); return !end_of_tree; } } }
boolean_t iosocket_listen(io_desc *iod, unsigned short len) { d_socket_struct *dsocketptr; socket_struct *socketptr; char *errptr; int4 errlen; error_def(ERR_SOCKLISTEN); error_def(ERR_TEXT); error_def(ERR_LQLENGTHNA); error_def(ERR_SOCKACTNA); error_def(ERR_CURRSOCKOFR); error_def(ERR_LISTENPASSBND); if (MAX_LISTEN_QUEUE_LENGTH < len) { rts_error(VARLSTCNT(3) ERR_LQLENGTHNA, 1, len); return FALSE; } assert(iod->type == gtmsocket); dsocketptr = (d_socket_struct *)iod->dev_sp; socketptr = dsocketptr->socket[dsocketptr->current_socket]; if (dsocketptr->current_socket >= dsocketptr->n_socket) { rts_error(VARLSTCNT(4) ERR_CURRSOCKOFR, 2, dsocketptr->current_socket, dsocketptr->n_socket); return FALSE; } if ((socketptr->state != socket_bound) || (socketptr->passive != TRUE)) { rts_error(VARLSTCNT(1) ERR_LISTENPASSBND); return FALSE; } dsocketptr->dollar_key[0] = '\0'; /* establish a queue of length len for incoming connections */ if (-1 == tcp_routines.aa_listen(socketptr->sd, len)) { errptr = (char *)STRERROR(errno); errlen = STRLEN(errptr); rts_error(VARLSTCNT(6) ERR_SOCKLISTEN, 0, ERR_TEXT, 2, errlen, errptr); return FALSE; } socketptr->state = socket_listening; len = sizeof(LISTENING) - 1; memcpy(&dsocketptr->dollar_key[0], LISTENING, len); dsocketptr->dollar_key[len++] = '|'; memcpy(&dsocketptr->dollar_key[len], socketptr->handle, socketptr->handle_len); len += socketptr->handle_len; dsocketptr->dollar_key[len++] = '|'; SPRINTF(&dsocketptr->dollar_key[len], "%d", socketptr->local.port); return TRUE; }
int gtmsource_losttncomplete(void) { int idx; gtmsource_local_ptr_t gtmsourcelocal_ptr; error_def(ERR_MUPCLIERR); error_def(ERR_TEXT); assert(holds_sem[SOURCE][JNL_POOL_ACCESS_SEM]); /* We dont need the access control semaphore here. So release it first and avoid any potential deadlocks. */ if (0 != rel_sem(SOURCE, JNL_POOL_ACCESS_SEM)) rts_error(VARLSTCNT(5) ERR_TEXT, 2, RTS_ERROR_LITERAL("Error in source server losttncomplete rel_sem"), REPL_SEM_ERRNO); assert(NULL == jnlpool.gtmsource_local); repl_log(stderr, TRUE, TRUE, "Initiating LOSTTNCOMPLETE operation on instance [%s]\n", jnlpool.repl_inst_filehdr->this_instname); /* If this is a root primary instance, propagate this information to secondaries as well so they reset zqgblmod_seqno to 0. * If propagating primary, no need to send this to tertiaries as the receiver on the tertiary cannot have started with * non-zero "zqgblmod_seqno" to begin with (PRIMARYNOTROOT error would have been issued). */ if (!jnlpool.jnlpool_ctl->upd_disabled) { grab_lock(jnlpool.jnlpool_dummy_reg); jnlpool.jnlpool_ctl->send_losttn_complete = TRUE; gtmsourcelocal_ptr = jnlpool.gtmsource_local_array; for (idx = 0; idx < NUM_GTMSRC_LCL; idx++, gtmsourcelocal_ptr++) { if (('\0' == gtmsourcelocal_ptr->secondary_instname[0]) && (0 == gtmsourcelocal_ptr->read_jnl_seqno) && (0 == gtmsourcelocal_ptr->connect_jnl_seqno)) continue; gtmsourcelocal_ptr->send_losttn_complete = TRUE; } rel_lock(jnlpool.jnlpool_dummy_reg); } /* Reset zqgblmod_seqno and zqgblmod_tn to 0 in this instance as well */ repl_inst_reset_zqgblmod_seqno_and_tn(); return (NORMAL_SHUTDOWN); }
boolean_t mur_fopen_sp(jnl_ctl_list *jctl) { struct stat stat_buf; int status, perms; error_def(ERR_JNLFILEOPNERR); error_def(ERR_SYSCALL); perms = O_RDONLY; jctl->read_only = TRUE; /* Both for recover and rollback open in read/write mode. We do not need to write in journal file * for mupip journal extract/show/verify or recover -forward. So open it as read-only */ if (mur_options.update && !mur_options.forward) { perms = O_RDWR; jctl->read_only = FALSE; } jctl->channel = OPEN((char *)jctl->jnl_fn, perms); if (-1 != jctl->channel) { FSTAT_FILE(jctl->channel, &stat_buf, status); if (-1 != status) { jctl->os_filesize = (off_jnl_t)stat_buf.st_size; return TRUE; } jctl->status = errno; CLOSEFILE(jctl->channel, status); } else jctl->status = errno; if (ENOENT == jctl->status) /* File Not Found is a common error, so no need for SYSCALL */ gtm_putmsg(VARLSTCNT(5) ERR_JNLFILEOPNERR, 2, jctl->jnl_fn_len, jctl->jnl_fn, jctl->status); else gtm_putmsg(VARLSTCNT(12) ERR_JNLFILEOPNERR, 2, jctl->jnl_fn_len, jctl->jnl_fn, ERR_SYSCALL, 5, LEN_AND_STR((-1 == jctl->channel) ? "open" : "fstat"), CALLFROM, jctl->status); jctl->channel = NOJNL; return FALSE; }
int f_zcall( oprtype *a, opctype op) { triple *root, *last, *curr,*ref; oprtype argv[CHARMAXARGS], *argp; int argc; error_def(ERR_FCHARMAXARGS); argp = &argv[0]; argc = 0; if (!expr(argp)) return FALSE; assert(argp->oprclass == TRIP_REF); argc++; argp++; for (;;) { if (window_token != TK_COMMA) break; advancewindow(); if (window_token == TK_COMMA || window_token == TK_RPAREN) { ref = newtriple(OC_NULLEXP); *argp = put_tref(ref); } else { if (!expr(argp)) return FALSE; assert(argp->oprclass == TRIP_REF); } argc++; argp++; if (argc >= CHARMAXARGS) { stx_error(ERR_FCHARMAXARGS); return FALSE; } } root = last = maketriple(op); root->operand[0] = put_ilit(argc + 1); argp = &argv[0]; for (; argc > 0 ;argc--, argp++) { curr = newtriple(OC_PARAMETER); curr->operand[0] = *argp; last->operand[1] = put_tref(curr); last = curr; } ins_triple(root); *a = put_tref(root); return TRUE; }
void op_fnzbitxor(mval *dst, mval *bitstr1, mval *bitstr2) { int n, str_len1, str_len2, new_str_len; unsigned char *byte_1, *byte_n; unsigned char *byte1_1, *byte1_n, byte1_len; unsigned char *byte2_1, *byte2_n, byte2_len; error_def(ERR_INVBITSTR); MV_FORCE_STR(bitstr1); MV_FORCE_STR(bitstr2); if (!bitstr1->str.len || !bitstr2->str.len) rts_error(VARLSTCNT(1) ERR_INVBITSTR); byte1_len = *(unsigned char *)bitstr1->str.addr; str_len1 = (bitstr1->str.len - 1) * 8; if (7 < byte1_len) rts_error(VARLSTCNT(1) ERR_INVBITSTR); byte2_len = *(unsigned char *)bitstr2->str.addr; str_len2 = (bitstr2->str.len -1) * 8; if (7 < byte2_len) rts_error(VARLSTCNT(1) ERR_INVBITSTR); if (str_len1 - byte1_len > str_len2 - byte2_len) new_str_len = str_len2 - byte2_len; else new_str_len = str_len1 - byte1_len; n = (new_str_len + 7)/8 ; if (stringpool.top - stringpool.free < n + 1) stp_gcol(n + 1); byte_1 = (unsigned char *)stringpool.free; *byte_1 = n * 8 - new_str_len; byte1_1 = (unsigned char *)bitstr1->str.addr; byte2_1 = (unsigned char *)bitstr2->str.addr; for(byte_n = byte_1 + 1, byte1_n = byte1_1 + 1, byte2_n = byte2_1 + 1 ; byte_n <= (byte_1 + n); byte_n++, byte1_n++, byte2_n++) { *byte_n = *byte1_n ^ *byte2_n; } *--byte_n &= mask[*byte_1]; dst->mvtype = MV_STR; dst->str.addr = (char *)stringpool.free; dst->str.len = n + 1; stringpool.free += n + 1; }
int crit_wake (sm_uint_ptr_t pid) { error_def(ERR_NOSUCHPROC); if (0 == kill(*pid, SIGALRM)) return 0; else if (ESRCH == errno) { send_msg(VARLSTCNT(5) ERR_NOSUCHPROC, 3, *pid, RTS_ERROR_LITERAL("wake")); return(ESRCH); } else assert(EINVAL != errno); return send_mesg2gtmsecshr(WAKE_MESSAGE, *pid, (char *)NULL, 0); }
int repl_log_init(repl_log_file_t log_type, int *log_fd, int *stats_fd, char *log, char *stats_log) { /* Open the log file */ char log_file_name[MAX_FN_LEN + 1], *err_code; int tmp_fd; int save_errno; int stdout_status, stderr_status; int rc; #ifdef __MVS__ int status; int realfiletag; struct stat info; #endif error_def(ERR_REPLLOGOPN); error_def(ERR_TEXT); ZOS_ONLY(error_def(ERR_BADTAG);) if (*log == '\0')
int continue_proc(pid_t pid) { error_def(ERR_NOSUCHPROC); if (0 == kill(pid, SIGCONT)) return(0); else if (ESRCH == errno) { send_msg(VARLSTCNT(5) ERR_NOSUCHPROC, 3, pid, RTS_ERROR_LITERAL("continue")); return(ESRCH); } else assert(EINVAL != errno); return(send_mesg2gtmsecshr(CONTINUE_PROCESS, pid, (char *)NULL, 0)); }
static CONDITION_HANDLER(dir_ch) { int dummy1, dummy2; error_def(ERR_ASSERT); error_def(ERR_GTMASSERT); error_def(ERR_GTMCHECK); error_def(ERR_STACKOFLOW); START_CH; if (DUMP) { NEXTCH; } op_kill(zsrch_dir1); op_kill(zsrch_dir2); op_kill(ind_var); ind_var = op_putindx(VARLSTCNT(2) zsrch_var, &ind_val); ind_var->v.mvtype = MV_STR; ind_var->v.str.len = 0; UNWIND(dummy1, dummy2); }
void op_fno2(lv_val *src,mval *key,mval *dst,mval *direct) { error_def(ERR_ORDER2); MV_FORCE_DEFINED(key); MV_FORCE_NUM(direct); if (!MV_IS_INT(direct) || (direct->m[1] != 1*MV_BIAS && direct->m[1] != -1*MV_BIAS)) rts_error(VARLSTCNT(1) ERR_ORDER2); else { if (direct->m[1] == 1*MV_BIAS) op_fnorder(src,key,dst); else op_fnzprevious(src,key,dst); } }
/* -------------------------------------------------------------------------------- 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; error_def(ERR_FILERENAME); error_def(ERR_RENAMEFAIL); 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) return RENAME_FAILED; /* File is present in the system */ assert(0 < MAX_FN_LEN - org_fn_len - 1); if (SS_NORMAL != (status = prepare_unique_name(org_fn, org_fn_len, "", "", rename_fn, rename_fn_len, 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))) { if (run_time) send_msg(VARLSTCNT(9) ERR_RENAMEFAIL, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn, status, 0, *ustatus); else gtm_putmsg(VARLSTCNT1(8) ERR_RENAMEFAIL, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn, status, PUT_SYS_ERRNO(*ustatus)); return RENAME_FAILED; } if (run_time) send_msg(VARLSTCNT (6) ERR_FILERENAME, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn); else gtm_putmsg(VARLSTCNT (6) ERR_FILERENAME, 4, org_fn_len, org_fn, *rename_fn_len, rename_fn); return RENAME_SUCCESS; }
void copy_stack_frame(void) { register stack_frame *sf; unsigned char *msp_save; error_def(ERR_STACKOFLOW); error_def(ERR_STACKCRIT); msp_save = msp; sf = (stack_frame *) (msp -= sizeof(stack_frame)); if (msp <= stackwarn) { if (msp <= stacktop) { msp = msp_save; rts_error(VARLSTCNT(1) ERR_STACKOFLOW); } else rts_error(VARLSTCNT(1) ERR_STACKCRIT); } assert(msp < stackbase); *sf = *frame_pointer; sf->old_frame_pointer = frame_pointer; sf->flags = 0; /* Don't propagate special flags */ frame_pointer = sf; }
void mu_signal_process(char *command, int signal) { unsigned short slen; int len, toprocess_id, save_errno; char buff[256]; error_def(ERR_MUPCLIERR); error_def(ERR_MUPIPSIG); slen = sizeof(buff); if (!cli_get_str("ID", buff, &slen)) mupip_exit(ERR_MUPCLIERR); len = slen; toprocess_id = asc2i((uchar_ptr_t)buff, len); if (toprocess_id < 0) { util_out_print("Error converting !AD to a number", FLUSH, len, buff); mupip_exit(ERR_MUPCLIERR); } else { if (-1 == kill(toprocess_id, signal)) { save_errno = errno; util_out_print("Error issuing !AD to process !UL: !AZ", FLUSH, LEN_AND_STR(command), toprocess_id, STRERROR(errno)); } else { util_out_print("!AD issued to process !UL", FLUSH, LEN_AND_STR(command), toprocess_id); if (!MEMCMP_LIT(command, STOP_STR)) { send_msg(VARLSTCNT(9) ERR_MUPIPSIG, 7, LEN_AND_STR(command), signal, process_id, process_id, toprocess_id, toprocess_id); } } } return; }
void op_zmess(int4 errnum, ...) { va_list var; int4 status, cnt, faocnt; unsigned short m_len; unsigned char faostat[4]; unsigned char msgbuff[MAX_MSG_SIZE + 1]; unsigned char buff[FAO_BUFFER_SPACE]; int4 fao[MAX_FAO_PARMS + 1]; $DESCRIPTOR(d_sp, msgbuff); error_def(ERR_TPRETRY); VAR_START(var, errnum); va_count(cnt); cnt--; status = sys$getmsg(errnum, &m_len, &d_sp, 0, &faostat[0]); if ((status & 1) && m_len) { buff[m_len] = 0; memset(&fao[0], 0, SIZEOF(fao)); faocnt = (cnt ? faostat[1] : cnt); faocnt = (faocnt > MAX_FAO_PARMS ? MAX_FAO_PARMS : faocnt); if (faocnt) faocnt = mval2fao(msgbuff, var, &fao[0], cnt, faocnt, buff, buff + SIZEOF(buff)); va_end(var); if (faocnt != -1) { /* Currently there are a max of 20 fao parms (MAX_FAO_PARMS) allowed, hence passing upto fao_list[19]. * An assert is added to ensure this code is changed whenever the macro MAX_FAO_PARMS is changed. * The # of arguments passed below should change accordingly. */ assert(MAX_FAO_PARMS == 20); if (ERR_TPRETRY == errnum) { /* A TP restart is being signalled. Set t_fail_hist just like a TRESTART command would */ op_trestart_set_cdb_code(); } rts_error(VARLSTCNT(MAX_FAO_PARMS + 2) errnum, faocnt, fao[0], fao[1], fao[2], fao[3], fao[4], fao[5], fao[6], fao[7], fao[8], fao[9], fao[10], fao[11], fao[12], fao[13], fao[14], fao[15], fao[16], fao[17], fao[18], fao[19]); } return; } else { va_end(var); rts_error(VARLSTCNT(1) status); } }
void gtcm_open_cmerrlog(void) { int len; mstr lfn1, lfn2; char lfn_path[MAX_TRANS_NAME_LEN + 1]; char new_lfn_path[MAX_TRANS_NAME_LEN + 1]; int new_len; uint4 ustatus; int4 rval; FILE *new_file; error_def(ERR_TEXT); if (0 != (len = STRLEN(gtcm_gnp_server_log))) { lfn1.addr = gtcm_gnp_server_log; lfn1.len = len; } else { lfn1.addr = GTCM_GNP_CMERR_FN; lfn1.len = sizeof(GTCM_GNP_CMERR_FN) - 1; } rval = TRANS_LOG_NAME(&lfn1, &lfn2, lfn_path, sizeof(lfn_path), do_sendmsg_on_log2long); if (rval == SS_NORMAL || rval == SS_NOLOGNAM) { lfn_path[lfn2.len] = 0; rename_file_if_exists(lfn_path, lfn2.len, new_lfn_path, &new_len, &ustatus); new_file = Fopen(lfn_path, "a"); if (NULL != new_file) { gtcm_errfile = TRUE; if (gtcm_errfs) fclose(gtcm_errfs); gtcm_errfs = new_file; if (dup2(fileno(gtcm_errfs), 1) < 0) { rts_error(VARLSTCNT(5) ERR_TEXT, 2, LEN_AND_LIT("Error on dup2 of stdout"), errno); } if (dup2(fileno(gtcm_errfs), 2) < 0) { rts_error(VARLSTCNT(5) ERR_TEXT, 2, LEN_AND_LIT("Error on dup2 of stderr"), errno); } } else fprintf(stderr, "Unable to open %s : %s\n", lfn_path, STRERROR(errno)); } else fprintf(stderr, "Unable to resolve %s : return value = %d\n", GTCM_GNP_CMERR_FN, rval); gtcm_firsterr = FALSE; }
/* This routine returns whether the free_blocks counter in the file-header is ok (TRUE) or not (FALSE). * If not, it corrects it. This assumes cs_addrs, cs_data and gv_cur_region to point to the region of interest. * It also assumes that the master-map is correct and finds out non-full local bitmaps and counts the number of * free blocks in each of them and sums them up to determine the perceived correct free_blocks count. * The reason why this is ok is that even if the master-map incorrectly reports a local bitmap as full, our new free_blocks * count will effectively make the free space in that local-bitmap invisible and make a gdsfilext necessary and valid. * A later mupip integ will scavenge that invisible space for us. The worst that can therefore happen is that we will transiently * not be using up existing space. But we will always ensure that the free_blocks counter goes in sync with the master-map. */ boolean_t is_free_blks_ctr_ok(void) { boolean_t blk_used; block_id bml, free_bit, free_bml, maxbitsthismap; cache_rec_ptr_t cr; int cycle; sm_uc_ptr_t bmp; unsigned int local_maps, total_blks, free_blocks; error_def(ERR_DBBADFREEBLKCTR); assert(&FILE_INFO(gv_cur_region)->s_addrs == cs_addrs && cs_addrs->hdr == cs_data && cs_addrs->now_crit); total_blks = (dba_mm == cs_data->acc_meth) ? cs_addrs->total_blks : cs_addrs->ti->total_blks; local_maps = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP); for (free_blocks = 0, free_bml = 0; free_bml < local_maps; free_bml++) { bml = bmm_find_free((uint4)free_bml, (sm_uc_ptr_t)MM_ADDR(cs_data), local_maps); if (bml < free_bml) break; free_bml = bml; bml *= BLKS_PER_LMAP; if (!(bmp = t_qread(bml, (sm_int_ptr_t)&cycle, &cr)) || (BM_SIZE(BLKS_PER_LMAP) != ((blk_hdr_ptr_t)bmp)->bsiz) || (LCL_MAP_LEVL != ((blk_hdr_ptr_t)bmp)->levl)) { assert(FALSE); /* In pro, we will simply skip counting this local bitmap. */ continue; } assert(free_bml <= (local_maps - 1)); maxbitsthismap = (free_bml != (local_maps - 1)) ? BLKS_PER_LMAP : total_blks - bml; for (free_bit = 0; free_bit < maxbitsthismap; free_bit++) { free_bit = bm_find_blk(free_bit, (sm_uc_ptr_t)bmp + sizeof(blk_hdr), maxbitsthismap, &blk_used); assert(NO_FREE_SPACE <= free_bit); if (0 > free_bit) break; free_blocks++; } } assert(cs_addrs->ti->free_blocks == free_blocks); if (cs_addrs->ti->free_blocks != free_blocks) { send_msg(VARLSTCNT(6) ERR_DBBADFREEBLKCTR, 4, DB_LEN_STR(gv_cur_region), cs_addrs->ti->free_blocks, free_blocks); cs_addrs->ti->free_blocks = free_blocks; return FALSE; } return TRUE; }
condition_code dcp_get_circuit(mval *logical) { condition_code status; error_def(ERR_DDPINVCKT); status = trans_log_name(&logical->str, &my_circuit_name, cktnam_buff); if (SS$_NORMAL == status) { if (DDP_CIRCUIT_NAME_LEN == my_circuit_name.len && is_five_bit(my_circuit_name.addr)) my_circuit = five_bit(my_circuit_name.addr); else status = ERR_DDPINVCKT; } return status; }