Exemplo n.º 1
0
kcontext_t *new_ThreadContext(CTX)
{
	KNH_SYSLOCK(_ctx);
	kcontext_t *newCtx = new_hcontext(_ctx);
	newCtx->share = ctx->share;
	newCtx->stat = ctx->stat;
	newCtx->spi = ctx->spi;
	newCtx->script = ctx->script;
	newCtx->parent = WCTX(_ctx);
//	newCtx->freeObjectList = NULL;
//	newCtx->freeObjectTail = NULL;
	KINITv(newCtx->gma, new_(GammaBuilder));
	knh_GammaBuilder_init(newCtx);
	CommonContext_init(_ctx, newCtx);
	knh_stack_initexpand(newCtx, NULL, K_STACKSIZE);

	ctx->wshare->contextCounter++;
	ctx->wshare->threadCounter++;
	if(newCtx->ctxobjNC == NULL) {
		newCtx->ctxobjNC = knh_toContext(newCtx);
	}
	kArray_add(ctx->share->contextListNULL, newCtx->ctxobjNC);
	newCtx->safepoint = ctx->share->ctx0->safepoint;
	KNH_SYS_UNLOCK(_ctx);
	return newCtx;
}
Exemplo n.º 2
0
static void trapILL(int sig RECARG)
{
	static const char *emsg[] = {
			/* FPE_NOOP	  0*/ "SIGILL",
			/* ILL_ILLOPC 1*/ "illegal opcode",
			/* ILL_ILLTRP 2*/ "illegal trap",
			/* ILL_PRVOPC 3*/ "privileged opcode",
			/* ILL_ILLOPN 4*/ "illegal operand",
			/* 	5	*/ "illegal addressing mode",
			/* 	6	*/ "privileged register",
			/* 	7	*/ "coprocessor error",
			/* 	8	*/ "internal stack error"};
	CTX ctx = knh_getCurrentContext();
	record_signal(ctx, sig RECDATA);
	if(ctx != NULL) {
#if defined(K_USING_MINGW_)
		int si_code = 0;
#else
		int si_code = (si->si_code < 9) ? si->si_code : 0;
#endif /* defined(K_USING_MINGW_) */
		WCTX(ctx)->signal = sig;
		THROW_Halt(ctx, NULL, emsg[si_code]);
	}
	_Exit(EX_SOFTWARE);
}
Exemplo n.º 3
0
static void knh_shell(CTX ctx)
{
	void *shell_status = NULL;
	BEGIN_LOCAL(ctx, lsfp, 2);
//	LOCAL_NEW(ctx, lsfp, 0, kInputStream *, bin, new_BytesInputStream(ctx, new_Bytes(ctx, "shell", K_PAGESIZE)));
	{
		CWB_t cwbbuf, *cwb = CWB_open(ctx, &cwbbuf);
		knh_showWelcome(ctx, cwb->w);
		knh_showSecurityAlert(ctx, cwb->w);
		shell_status = shell_init(ctx, CWB_totext(ctx, cwb), NULL);
		CWB_close(ctx, cwb);
	}
	while(1) {
		{
			CWB_t cwbbuf, *cwb = CWB_open(ctx, &cwbbuf);
			kstatus_t status = readstmt(ctx, cwb);
			if(status == K_BREAK) {
				CWB_close(ctx, cwb);
				break;
			}
			if(CWB_size(cwb) == 0) {
				CWB_close(ctx, cwb);
				continue;
			}
			status = shell_command(ctx, CWB_totext(ctx, cwb));
			if(status == K_BREAK) {
				CWB_close(ctx, cwb);
				break;
			}
			if(status == K_REDO) {
				CWB_close(ctx, cwb);
				continue;
			}
#ifdef K_USING_SUGAR
			kString *script = CWB_newString(ctx, cwb, 0);
			KNH_SETv(ctx, lsfp[0].o, script);
			knh_beval2(ctx, S_totext(script), 1);
#else
			kInputStream *bin = new_BytesInputStream(ctx, CWB_totext(ctx, cwb), CWB_size(cwb));
			KNH_SETv(ctx, lsfp[0].o, bin);
			knh_beval(ctx, bin, 1);
#endif
		}
		knh_OutputStream_flush(ctx, ctx->out);
		if(ctx->isEvaled == 1) {
			CWB_t cwbbuf, *cwb = CWB_open(ctx, &cwbbuf);
			knh_write_Object(ctx, cwb->w, ctx->evaled, FMT_dump);
			knh_showSecurityAlert(ctx, cwb->w);
			if(CWB_size(cwb) !=0) {
				shell_display(ctx, shell_status, CWB_totext(ctx, cwb));
			}
			CWB_close(ctx, cwb);
			WCTX(ctx)->isEvaled = 0;
		}
	}
	shell_cleanup(ctx, shell_status);
	END_LOCAL(ctx, lsfp);
}
Exemplo n.º 4
0
static void knh_setsignal(CTX ctx, void *block, size_t n)
#endif /* defined(K_USING_MINGW_) */
{
#if !defined(K_USING_MINGW_)
	struct sigaction sa = {};
	struct sigaction *sa_orig = (struct sigaction*)block;
#endif /* !defined(K_USING_MINGW_) */
	WCTX(ctx)->signal = 0;
	WCTX(ctx)->siginfo = NULL;

#ifndef K_USING_DEBUG
#if defined(K_USING_MINGW_)
	KNH_SIGNAL(SIGSEGV, trapSEGV);
	KNH_SIGNAL(SIGILL, trapILL);
#else
	sa.sa_sigaction = trapSEGV;
	sa.sa_flags     = SA_SIGINFO;
	KNH_SIGACTION(SIGSEGV, &sa, sa_orig, n);
	sa.sa_sigaction = trapILL;
	sa.sa_flags     = SA_SIGINFO;
	KNH_SIGACTION(SIGILL, &sa, sa_orig, n);
	sa.sa_sigaction = trapBUS;
	sa.sa_flags     = SA_SIGINFO;
	KNH_SIGACTION(SIGBUS, &sa, sa_orig, n);
#endif /* defined(K_USING_MINGW_) */
#endif

#if defined(K_USING_MINGW_)
	KNH_SIGNAL(SIGFPE, trapSIGFPE);
#else
	sa.sa_sigaction = trapSIGFPE;
	sa.sa_flags     = SA_SIGINFO|SA_NODEFER;
	KNH_SIGACTION(SIGFPE, &sa, sa_orig, n);
#endif /* defined(K_USING_MINGW_) */
	if(CTX_isInteractive(ctx)) {
		DBG_P("set SIGINT This is not so good");
#if defined(K_USING_MINGW_)
		KNH_SIGNAL(SIGINT, trapSIGINT);
#else
		sa.sa_sigaction = trapSIGINT;
		sa.sa_flags     = SA_SIGINFO|SA_NODEFER;
		KNH_SIGACTION(SIGINT, &sa, sa_orig, n);
#endif /* defined(K_USING_MINGW_) */
	}
}
Exemplo n.º 5
0
static void knh_unsetsignal(CTX ctx, void *block, size_t n)
#endif /* defined(K_USING_MINGW_) */
{
#if !defined(K_USING_MINGW_)
	struct sigaction *sa_orig = (struct sigaction*)block;
	if(sa_orig != NULL) {
#endif /* !defined(K_USING_MINGW_) */
#ifndef K_USING_DEBUG
		KNH_SIGACTION2(SIGILL,  sa_orig, n);
#if !defined(K_USING_MINGW_)
		KNH_SIGACTION2(SIGBUS,  sa_orig, n);
#endif /* !defined(K_USING_MINGW_) */
		KNH_SIGACTION2(SIGSEGV, sa_orig, n);
#endif
		KNH_SIGACTION2(SIGFPE, sa_orig, n);
		if(CTX_isInteractive(ctx)) {
			KNH_SIGACTION2(SIGINT, sa_orig, n);
		}
#if !defined(K_USING_MINGW_)
	}
#endif /* !defined(K_USING_MINGW_) */
	WCTX(ctx)->signal = 0;
	WCTX(ctx)->siginfo = NULL;
}
Exemplo n.º 6
0
static void trapBUS(int sig RECARG)
{
	static const char *emsg[] = {
			/* BUS_NOOP	  0*/ "BUS_NOOP",
			/* BUS_ADRALN 1*/ "invalid address alignment",
			/* BUS_ADRERR 2*/ "nonexistent physical address",
			/* BUS_OBJERR 3*/ "object-specific HW error"};
	CTX ctx = knh_getCurrentContext();
	record_signal(ctx, sig RECDATA);
	if(ctx != NULL) {
		int si_code = (si->si_code < 4) ? si->si_code : 1;
		WCTX(ctx)->signal = sig;
		THROW_Halt(ctx, NULL, emsg[si_code]);
	}
	_Exit(EX_SOFTWARE);
}
Exemplo n.º 7
0
static void trapSEGV(int sig RECARG)
{
	CTX ctx = knh_getCurrentContext();
	record_signal(ctx, sig RECDATA);
#if !defined(K_USING_MINGW_)
	if (si->si_code == SEGV_ACCERR) {
		void* address = (void*)si->si_addr;
		fprintf(stderr, "address=%p\n", address);
	}
#endif /* defined(K_USING_MINGW_) */
	if(ctx != NULL) {
		WCTX(ctx)->signal = sig;
		THROW_Halt(ctx, NULL, "segmentation fault");
	}
	_Exit(EX_SOFTWARE);
}
Exemplo n.º 8
0
		knh_mutex_free(ctx, (kmutex_t *)po->rawptr);
		po->rawptr = NULL;
	}
}

/* ======================================================================== */
// [KMETHODS]

//## @Native Thread Thread.spawn(dynamic f, dynamic[] args)
KMETHOD Thread_spawn(CTX ctx, ksfp_t *sfp _RIX)
{
	kFunc *f = sfp[1].fo;
	kArray *args = sfp[2].a;
	if(IS_NOTNULL(((kObject *)f))) {
		Thread_t *t = (Thread_t *)KNH_MALLOC(ctx, sizeof(Thread_t));
		kcontext_t *newCtx = new_ThreadContext(WCTX(ctx));
		t->ctx = newCtx;
		t->func = f;
		t->args = args;
		kthread_create(ctx, &(t->thread), NULL, spawn_start, t);
		RETURN_(new_ReturnRawPtr(ctx, sfp, t));
	}
}

//## @Native void Thread.join();
KMETHOD Thread_join(CTX ctx, ksfp_t *sfp _RIX)
{
	Thread_t *t = RawPtr_to(Thread_t *, sfp[0]);
	void *v;

	KNH_SYSLOCK(ctx);