Beispiel #1
0
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);)
Beispiel #2
0
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;
	}
}
Beispiel #3
0
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;
}
Beispiel #4
0
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;
}
Beispiel #5
0
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 */
Beispiel #6
0
/* 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);
}
Beispiel #8
0
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;
}
Beispiel #9
0
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;
}
Beispiel #10
0
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;
	}
}
Beispiel #11
0
/*
 * -----------------------------------------------
 * 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;
}
Beispiel #12
0
/* 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;
	}
Beispiel #13
0
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;
		}
	}
}
Beispiel #14
0
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;
}
Beispiel #15
0
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);
}
Beispiel #16
0
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;
}
Beispiel #17
0
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;
}
Beispiel #18
0
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;
}
Beispiel #19
0
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);
}
Beispiel #20
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')
Beispiel #21
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));
}
Beispiel #22
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);
}
Beispiel #23
0
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;
}
Beispiel #25
0
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;
}
Beispiel #26
0
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;
}
Beispiel #27
0
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);
	}
}
Beispiel #28
0
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;
}
Beispiel #29
0
/* 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;
}