Context Navigation

kernel.cfa@ d29255c

Visit:

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast new-ast-unique-expr pthread-emulation qualifiedEnum

Last change on this file since d29255c was ff79d5e, checked in by Thierry Delisle <tdelisle@…>, 5 years ago
Fixed park unpark to support park as first step of main() Fixes #170
Property mode set to `100644`
File size: 35.8 KB

Line
1	//
2	// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3	//
4	// The contents of this file are covered under the licence agreement in the
5	// file "LICENCE" distributed with Cforall.
6	//
7	// kernel.c --
8	//
9	// Author : Thierry Delisle
10	// Created On : Tue Jan 17 12:27:26 2017
11	// Last Modified By : Peter A. Buhr
12	// Last Modified On : Tue May 26 22:05:19 2020
13	// Update Count : 59
14	//
15
16	#define __cforall_thread__
17	// #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
18
19	//C Includes
20	#include <stddef.h>
21	#include <errno.h>
22	#include <string.h>
23	#include <stdio.h>
24	#include <fenv.h>
25	#include <signal.h>
26	#include <unistd.h>
27	#include <limits.h> // PTHREAD_STACK_MIN
28	#include <sys/mman.h> // mprotect
29	extern "C" {
30	#include <sys/resource.h>
31	}
32
33	//CFA Includes
34	#include "time.hfa"
35	#include "kernel_private.hfa"
36	#include "preemption.hfa"
37	#include "startup.hfa"
38
39	//Private includes
40	#define __CFA_INVOKE_PRIVATE__
41	#include "invoke.h"
42
43
44	//-----------------------------------------------------------------------------
45	// Some assembly required
46	#if defined( __i386 )
47	#define CtxGet( ctx ) \
48	__asm__ volatile ( \
49	"movl %%esp,%0\n"\
50	"movl %%ebp,%1\n"\
51	: "=rm" (ctx.SP),\
52	"=rm" (ctx.FP) \
53	)
54
55	// mxcr : SSE Status and Control bits (control bits are preserved across function calls)
56	// fcw : X87 FPU control word (preserved across function calls)
57	#define __x87_store \
58	uint32_t __mxcr; \
59	uint16_t __fcw; \
60	__asm__ volatile ( \
61	"stmxcsr %0\n" \
62	"fnstcw %1\n" \
63	: "=m" (__mxcr),\
64	"=m" (__fcw) \
65	)
66
67	#define __x87_load \
68	__asm__ volatile ( \
69	"fldcw %1\n" \
70	"ldmxcsr %0\n" \
71	::"m" (__mxcr),\
72	"m" (__fcw) \
73	)
74
75	#elif defined( __x86_64 )
76	#define CtxGet( ctx ) \
77	__asm__ volatile ( \
78	"movq %%rsp,%0\n"\
79	"movq %%rbp,%1\n"\
80	: "=rm" (ctx.SP),\
81	"=rm" (ctx.FP) \
82	)
83
84	#define __x87_store \
85	uint32_t __mxcr; \
86	uint16_t __fcw; \
87	__asm__ volatile ( \
88	"stmxcsr %0\n" \
89	"fnstcw %1\n" \
90	: "=m" (__mxcr),\
91	"=m" (__fcw) \
92	)
93
94	#define __x87_load \
95	__asm__ volatile ( \
96	"fldcw %1\n" \
97	"ldmxcsr %0\n" \
98	:: "m" (__mxcr),\
99	"m" (__fcw) \
100	)
101
102
103	#elif defined( __ARM_ARCH )
104	#define CtxGet( ctx ) __asm__ ( \
105	"mov %0,%%sp\n" \
106	"mov %1,%%r11\n" \
107	: "=rm" (ctx.SP), "=rm" (ctx.FP) )
108	#else
109	#error unknown hardware architecture
110	#endif
111
112	//-----------------------------------------------------------------------------
113	//Start and stop routine for the kernel, declared first to make sure they run first
114	static void __kernel_startup (void) __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
115	static void __kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
116
117	//-----------------------------------------------------------------------------
118	// Kernel Scheduling logic
119	static $thread * __next_thread(cluster * this);
120	static void __run_thread(processor * this, $thread * dst);
121	static $thread * __halt(processor * this);
122	static bool __wake_one(cluster * cltr);
123	static bool __wake_proc(processor *);
124
125	//-----------------------------------------------------------------------------
126	// Kernel storage
127	KERNEL_STORAGE(cluster, mainCluster);
128	KERNEL_STORAGE(processor, mainProcessor);
129	KERNEL_STORAGE($thread, mainThread);
130	KERNEL_STORAGE(__stack_t, mainThreadCtx);
131	KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
132
133	cluster * mainCluster;
134	processor * mainProcessor;
135	$thread * mainThread;
136	__scheduler_RWLock_t * __scheduler_lock;
137
138	extern "C" {
139	struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
140	}
141
142	size_t __page_size = 0;
143
144	//-----------------------------------------------------------------------------
145	// Global state
146	thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
147	NULL, // cannot use 0p
148	NULL,
149	{ 1, false, false },
150	6u //this should be seeded better but due to a bug calling rdtsc doesn't work
151	};
152
153	//-----------------------------------------------------------------------------
154	// Struct to steal stack
155	struct current_stack_info_t {
156	__stack_t * storage; // pointer to stack object
157	void * base; // base of stack
158	void * limit; // stack grows towards stack limit
159	void * context; // address of cfa_context_t
160	};
161
162	void ?{}( current_stack_info_t & this ) {
163	__stack_context_t ctx;
164	CtxGet( ctx );
165	this.base = ctx.FP;
166
167	rlimit r;
168	getrlimit( RLIMIT_STACK, &r);
169	size_t size = r.rlim_cur;
170
171	this.limit = (void *)(((intptr_t)this.base) - size);
172	this.context = &storage_mainThreadCtx;
173	}
174
175	//-----------------------------------------------------------------------------
176	// Main thread construction
177
178	void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
179	stack.storage = info->storage;
180	with(*stack.storage) {
181	limit = info->limit;
182	base = info->base;
183	}
184	__attribute__((may_alias)) intptr_t * istorage = (intptr_t*) &stack.storage;
185	*istorage \|= 0x1;
186	name = "Main Thread";
187	state = Start;
188	starter = 0p;
189	last = 0p;
190	cancellation = 0p;
191	}
192
193	void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
194	ticket = 1;
195	state = Start;
196	self_cor{ info };
197	curr_cor = &self_cor;
198	curr_cluster = mainCluster;
199	self_mon.owner = &this;
200	self_mon.recursion = 1;
201	self_mon_p = &self_mon;
202	link.next = 0p;
203	link.prev = 0p;
204
205	node.next = 0p;
206	node.prev = 0p;
207	doregister(curr_cluster, this);
208
209	monitors{ &self_mon_p, 1, (fptr_t)0 };
210	}
211
212	//-----------------------------------------------------------------------------
213	// Processor coroutine
214	void ?{}(processorCtx_t & this) {
215
216	}
217
218	// Construct the processor context of non-main processors
219	static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
220	(this.__cor){ info };
221	this.proc = proc;
222	}
223
224	static void * __invoke_processor(void * arg);
225
226	void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
227	this.name = name;
228	this.cltr = &cltr;
229	id = -1u;
230	terminated{ 0 };
231	destroyer = 0p;
232	do_terminate = false;
233	preemption_alarm = 0p;
234	pending_preemption = false;
235	runner.proc = &this;
236
237	idle{};
238
239	__cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
240
241	this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
242
243	__cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
244	}
245
246	void ^?{}(processor & this) with( this ){
247	if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
248	__cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
249
250	__atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
251	__wake_proc( &this );
252
253	P( terminated );
254	verify( kernelTLS.this_processor != &this);
255	}
256
257	int err = pthread_join( kernel_thread, 0p );
258	if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err));
259
260	free( this.stack );
261	}
262
263	void ?{}(cluster & this, const char name[], Duration preemption_rate, unsigned io_flags) with( this ) {
264	this.name = name;
265	this.preemption_rate = preemption_rate;
266	ready_queue{};
267
268	#if !defined(__CFA_NO_STATISTICS__)
269	print_stats = false;
270	#endif
271
272	procs{ __get };
273	idles{ __get };
274	threads{ __get };
275
276	__kernel_io_startup( this, io_flags, &this == mainCluster );
277
278	doregister(this);
279	}
280
281	void ^?{}(cluster & this) {
282	__kernel_io_shutdown( this, &this == mainCluster );
283
284	unregister(this);
285	}
286
287	//=============================================================================================
288	// Kernel Scheduling logic
289	//=============================================================================================
290	//Main of the processor contexts
291	void main(processorCtx_t & runner) {
292	// Because of a bug, we couldn't initialized the seed on construction
293	// Do it here
294	kernelTLS.rand_seed ^= rdtscl();
295
296	processor * this = runner.proc;
297	verify(this);
298
299	__cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
300
301	// register the processor unless it's the main thread which is handled in the boot sequence
302	if(this != mainProcessor) {
303	this->id = doregister((__processor_id_t*)this);
304	ready_queue_grow( this->cltr );
305	}
306
307	doregister(this->cltr, this);
308
309	{
310	// Setup preemption data
311	preemption_scope scope = { this };
312
313	__cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
314
315	$thread * readyThread = 0p;
316	for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
317	// Try to get the next thread
318	readyThread = __next_thread( this->cltr );
319
320	// If no ready thread
321	if( readyThread == 0p ) {
322	// Block until a thread is ready
323	readyThread = __halt(this);
324	}
325
326	// Check if we actually found a thread
327	if( readyThread ) {
328	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
329	/* paranoid */ verifyf( readyThread->state == Ready \|\| readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
330	/* paranoid */ verifyf( readyThread->link.next == 0p, "Expected null got %p", readyThread->link.next );
331
332	// We found a thread run it
333	__run_thread(this, readyThread);
334
335	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
336	}
337	}
338
339	__cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this);
340	}
341
342	unregister(this->cltr, this);
343
344	V( this->terminated );
345
346	// unregister the processor unless it's the main thread which is handled in the boot sequence
347	if(this != mainProcessor) {
348	ready_queue_shrink( this->cltr );
349	unregister((__processor_id_t*)this);
350	}
351	else {
352	// HACK : the coroutine context switch expects this_thread to be set
353	// and it make sense for it to be set in all other cases except here
354	// fake it
355	kernelTLS.this_thread = mainThread;
356	}
357
358	__cfadbg_print_safe(runtime_core, "Kernel : core %p terminated\n", this);
359
360	stats_tls_tally(this->cltr);
361	}
362
363	static int * __volatile_errno() __attribute__((noinline));
364	static int * __volatile_errno() { asm(""); return &errno; }
365
366	// KERNEL ONLY
367	// runThread runs a thread by context switching
368	// from the processor coroutine to the target thread
369	static void __run_thread(processor * this, $thread * thrd_dst) {
370	$coroutine * proc_cor = get_coroutine(this->runner);
371
372	// Update global state
373	kernelTLS.this_thread = thrd_dst;
374
375	// set state of processor coroutine to inactive
376	verify(proc_cor->state == Active);
377	proc_cor->state = Blocked;
378
379	// Actually run the thread
380	RUNNING: while(true) {
381	thrd_dst->preempted = __NO_PREEMPTION;
382	thrd_dst->state = Active;
383
384	__cfaabi_dbg_debug_do(
385	thrd_dst->park_stale = true;
386	thrd_dst->unpark_stale = true;
387	)
388
389	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
390	/* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
391	/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) \|\| thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
392	/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) \|\| thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
393
394	// set context switch to the thread that the processor is executing
395	verify( thrd_dst->context.SP );
396	__cfactx_switch( &proc_cor->context, &thrd_dst->context );
397	// when __cfactx_switch returns we are back in the processor coroutine
398
399	/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
400	/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
401	/* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
402	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
403
404
405	// We just finished running a thread, there are a few things that could have happened.
406	// 1 - Regular case : the thread has blocked and now one has scheduled it yet.
407	// 2 - Racy case : the thread has blocked but someone has already tried to schedule it.
408	// 4 - Preempted
409	// In case 1, we may have won a race so we can't write to the state again.
410	// In case 2, we lost the race so we now own the thread.
411
412	if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
413	// The thread was preempted, reschedule it and reset the flag
414	__schedule_thread( (__processor_id_t*)this, thrd_dst );
415	break RUNNING;
416	}
417
418	if(unlikely(thrd_dst->state == Halted)) {
419	// The thread has halted, it should never be scheduled/run again
420	// We may need to wake someone up here since
421	unpark( this->destroyer __cfaabi_dbg_ctx2 );
422	this->destroyer = 0p;
423	break RUNNING;
424	}
425
426	/* paranoid */ verify( thrd_dst->state == Active );
427	thrd_dst->state = Blocked;
428
429	// set state of processor coroutine to active and the thread to inactive
430	int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
431	__cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; )
432	switch(old_ticket) {
433	case 1:
434	// This is case 1, the regular case, nothing more is needed
435	break RUNNING;
436	case 2:
437	// This is case 2, the racy case, someone tried to run this thread before it finished blocking
438	// In this case, just run it again.
439	continue RUNNING;
440	default:
441	// This makes no sense, something is wrong abort
442	abort();
443	}
444	}
445
446	// Just before returning to the processor, set the processor coroutine to active
447	proc_cor->state = Active;
448	kernelTLS.this_thread = 0p;
449	}
450
451	// KERNEL_ONLY
452	void returnToKernel() {
453	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
454	$coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
455	$thread * thrd_src = kernelTLS.this_thread;
456
457	// Run the thread on this processor
458	{
459	int local_errno = *__volatile_errno();
460	#if defined( __i386 ) \|\| defined( __x86_64 )
461	__x87_store;
462	#endif
463	verify( proc_cor->context.SP );
464	__cfactx_switch( &thrd_src->context, &proc_cor->context );
465	#if defined( __i386 ) \|\| defined( __x86_64 )
466	__x87_load;
467	#endif
468	*__volatile_errno() = local_errno;
469	}
470
471	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
472	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src );
473	/* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src );
474	}
475
476	// KERNEL_ONLY
477	// Context invoker for processors
478	// This is the entry point for processors (kernel threads)
479	// It effectively constructs a coroutine by stealing the pthread stack
480	static void * __invoke_processor(void * arg) {
481	processor * proc = (processor *) arg;
482	kernelTLS.this_processor = proc;
483	kernelTLS.this_thread = 0p;
484	kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
485	// SKULLDUGGERY: We want to create a context for the processor coroutine
486	// which is needed for the 2-step context switch. However, there is no reason
487	// to waste the perfectly valid stack create by pthread.
488	current_stack_info_t info;
489	__stack_t ctx;
490	info.storage = &ctx;
491	(proc->runner){ proc, &info };
492
493	__cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
494
495	//Set global state
496	kernelTLS.this_thread = 0p;
497
498	//We now have a proper context from which to schedule threads
499	__cfadbg_print_safe(runtime_core, "Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
500
501	// SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
502	// resume it to start it like it normally would, it will just context switch
503	// back to here. Instead directly call the main since we already are on the
504	// appropriate stack.
505	get_coroutine(proc->runner)->state = Active;
506	main( proc->runner );
507	get_coroutine(proc->runner)->state = Halted;
508
509	// Main routine of the core returned, the core is now fully terminated
510	__cfadbg_print_safe(runtime_core, "Kernel : core %p main ended (%p)\n", proc, &proc->runner);
511
512	return 0p;
513	}
514
515	static void Abort( int ret, const char func[] ) {
516	if ( ret ) { // pthread routines return errno values
517	abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
518	} // if
519	} // Abort
520
521	void * __create_pthread( pthread_t * pthread, void * (start)(void ), void * arg ) {
522	pthread_attr_t attr;
523
524	Abort( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
525
526	size_t stacksize;
527	// default stack size, normally defined by shell limit
528	Abort( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
529	assert( stacksize >= PTHREAD_STACK_MIN );
530
531	void * stack;
532	__cfaabi_dbg_debug_do(
533	stack = memalign( __page_size, stacksize + __page_size );
534	// pthread has no mechanism to create the guard page in user supplied stack.
535	if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
536	abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
537	} // if
538	);
539	__cfaabi_dbg_no_debug_do(
540	stack = malloc( stacksize );
541	);
542
543	Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
544
545	Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
546	return stack;
547	}
548
549	// KERNEL_ONLY
550	static void __kernel_first_resume( processor * this ) {
551	$thread * src = mainThread;
552	$coroutine * dst = get_coroutine(this->runner);
553
554	verify( ! kernelTLS.preemption_state.enabled );
555
556	kernelTLS.this_thread->curr_cor = dst;
557	__stack_prepare( &dst->stack, 65000 );
558	__cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
559
560	verify( ! kernelTLS.preemption_state.enabled );
561
562	dst->last = &src->self_cor;
563	dst->starter = dst->starter ? dst->starter : &src->self_cor;
564
565	// make sure the current state is still correct
566	/* paranoid */ verify(src->state == Ready);
567
568	// context switch to specified coroutine
569	verify( dst->context.SP );
570	__cfactx_switch( &src->context, &dst->context );
571	// when __cfactx_switch returns we are back in the src coroutine
572
573	mainThread->curr_cor = &mainThread->self_cor;
574
575	// make sure the current state has been update
576	/* paranoid */ verify(src->state == Active);
577
578	verify( ! kernelTLS.preemption_state.enabled );
579	}
580
581	// KERNEL_ONLY
582	static void __kernel_last_resume( processor * this ) {
583	$coroutine * src = &mainThread->self_cor;
584	$coroutine * dst = get_coroutine(this->runner);
585
586	verify( ! kernelTLS.preemption_state.enabled );
587	verify( dst->starter == src );
588	verify( dst->context.SP );
589
590	// SKULLDUGGERY in debug the processors check that the
591	// stack is still within the limit of the stack limits after running a thread.
592	// that check doesn't make sense if we context switch to the processor using the
593	// coroutine semantics. Since this is a special case, use the current context
594	// info to populate these fields.
595	__cfaabi_dbg_debug_do(
596	__stack_context_t ctx;
597	CtxGet( ctx );
598	mainThread->context.SP = ctx.SP;
599	mainThread->context.FP = ctx.FP;
600	)
601
602	// context switch to the processor
603	__cfactx_switch( &src->context, &dst->context );
604	}
605
606	//-----------------------------------------------------------------------------
607	// Scheduler routines
608	// KERNEL ONLY
609	void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
610	/* paranoid */ verify( thrd );
611	/* paranoid */ verify( thrd->state != Halted );
612	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
613	/* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
614	/* paranoid */ if( thrd->state == Blocked \|\| thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
615	"Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
616	/* paranoid */ if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active,
617	"Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
618	/* paranoid */ #endif
619	/* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
620
621	if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
622
623	ready_schedule_lock ( id );
624	push( thrd->curr_cluster, thrd );
625
626	__wake_one(thrd->curr_cluster);
627	ready_schedule_unlock( id );
628
629	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
630	}
631
632	// KERNEL ONLY
633	static $thread * __next_thread(cluster * this) with( *this ) {
634	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
635
636	ready_schedule_lock ( (__processor_id_t*)kernelTLS.this_processor );
637	$thread * head = pop( this );
638	ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
639
640	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
641	return head;
642	}
643
644	// KERNEL ONLY unpark with out disabling interrupts
645	void __unpark( struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
646	// record activity
647	__cfaabi_dbg_debug_do( char * old_caller = thrd->unpark_caller; )
648	__cfaabi_dbg_record_thrd( *thrd, false, caller );
649
650	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
651	__cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; )
652	switch(old_ticket) {
653	case 1:
654	// Wake won the race, the thread will reschedule/rerun itself
655	break;
656	case 0:
657	/* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
658	/* paranoid */ verify( thrd->state == Blocked );
659
660	// Wake lost the race,
661	__schedule_thread( id, thrd );
662	break;
663	default:
664	// This makes no sense, something is wrong abort
665	abort();
666	}
667	}
668
669	void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
670	if( !thrd ) return;
671
672	disable_interrupts();
673	__unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 );
674	enable_interrupts( __cfaabi_dbg_ctx );
675	}
676
677	void park( __cfaabi_dbg_ctx_param ) {
678	/* paranoid */ verify( kernelTLS.preemption_state.enabled );
679	disable_interrupts();
680	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
681	/* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
682
683	// record activity
684	__cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller );
685
686	returnToKernel();
687
688	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
689	enable_interrupts( __cfaabi_dbg_ctx );
690	/* paranoid */ verify( kernelTLS.preemption_state.enabled );
691
692	}
693
694	// KERNEL ONLY
695	void __leave_thread() {
696	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
697	returnToKernel();
698	abort();
699	}
700
701	// KERNEL ONLY
702	bool force_yield( __Preemption_Reason reason ) {
703	/* paranoid */ verify( kernelTLS.preemption_state.enabled );
704	disable_interrupts();
705	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
706
707	$thread * thrd = kernelTLS.this_thread;
708	/* paranoid */ verify(thrd->state == Active);
709
710	// SKULLDUGGERY: It is possible that we are preempting this thread just before
711	// it was going to park itself. If that is the case and it is already using the
712	// intrusive fields then we can't use them to preempt the thread
713	// If that is the case, abandon the preemption.
714	bool preempted = false;
715	if(thrd->link.next == 0p) {
716	preempted = true;
717	thrd->preempted = reason;
718	returnToKernel();
719	}
720
721	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
722	enable_interrupts_noPoll();
723	/* paranoid */ verify( kernelTLS.preemption_state.enabled );
724
725	return preempted;
726	}
727
728	//=============================================================================================
729	// Kernel Setup logic
730	//=============================================================================================
731	//-----------------------------------------------------------------------------
732	// Kernel boot procedures
733	static void __kernel_startup(void) {
734	verify( ! kernelTLS.preemption_state.enabled );
735	__cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
736
737	__page_size = sysconf( _SC_PAGESIZE );
738
739	__cfa_dbg_global_clusters.list{ __get };
740	__cfa_dbg_global_clusters.lock{};
741
742	// Initialize the global scheduler lock
743	__scheduler_lock = (__scheduler_RWLock_t*)&storage___scheduler_lock;
744	(*__scheduler_lock){};
745
746	// Initialize the main cluster
747	mainCluster = (cluster *)&storage_mainCluster;
748	(*mainCluster){"Main Cluster"};
749
750	__cfadbg_print_safe(runtime_core, "Kernel : Main cluster ready\n");
751
752	// Start by initializing the main thread
753	// SKULLDUGGERY: the mainThread steals the process main thread
754	// which will then be scheduled by the mainProcessor normally
755	mainThread = ($thread *)&storage_mainThread;
756	current_stack_info_t info;
757	info.storage = (__stack_t*)&storage_mainThreadCtx;
758	(*mainThread){ &info };
759
760	__cfadbg_print_safe(runtime_core, "Kernel : Main thread ready\n");
761
762
763
764	// Construct the processor context of the main processor
765	void ?{}(processorCtx_t & this, processor * proc) {
766	(this.__cor){ "Processor" };
767	this.__cor.starter = 0p;
768	this.proc = proc;
769	}
770
771	void ?{}(processor & this) with( this ) {
772	name = "Main Processor";
773	cltr = mainCluster;
774	terminated{ 0 };
775	do_terminate = false;
776	preemption_alarm = 0p;
777	pending_preemption = false;
778	kernel_thread = pthread_self();
779	id = -1u;
780
781	runner{ &this };
782	__cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
783	}
784
785	// Initialize the main processor and the main processor ctx
786	// (the coroutine that contains the processing control flow)
787	mainProcessor = (processor *)&storage_mainProcessor;
788	(*mainProcessor){};
789
790	mainProcessor->id = doregister( (__processor_id_t*)mainProcessor);
791
792	//initialize the global state variables
793	kernelTLS.this_processor = mainProcessor;
794	kernelTLS.this_thread = mainThread;
795
796	// Enable preemption
797	kernel_start_preemption();
798
799	// Add the main thread to the ready queue
800	// once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
801	__schedule_thread((__processor_id_t *)mainProcessor, mainThread);
802
803	// SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
804	// context. Hence, the main thread does not begin through __cfactx_invoke_thread, like all other threads. The trick here is that
805	// mainThread is on the ready queue when this call is made.
806	__kernel_first_resume( kernelTLS.this_processor );
807
808
809	// THE SYSTEM IS NOW COMPLETELY RUNNING
810
811
812	// Now that the system is up, finish creating systems that need threading
813	__kernel_io_finish_start( *mainCluster );
814
815
816	__cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
817
818	verify( ! kernelTLS.preemption_state.enabled );
819	enable_interrupts( __cfaabi_dbg_ctx );
820	verify( TL_GET( preemption_state.enabled ) );
821	}
822
823	static void __kernel_shutdown(void) {
824	//Before we start shutting things down, wait for systems that need threading to shutdown
825	__kernel_io_prepare_stop( *mainCluster );
826
827	/* paranoid */ verify( TL_GET( preemption_state.enabled ) );
828	disable_interrupts();
829	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
830
831	__cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n");
832
833	// SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
834	// When its coroutine terminates, it return control to the mainThread
835	// which is currently here
836	__atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
837	__kernel_last_resume( kernelTLS.this_processor );
838	mainThread->self_cor.state = Halted;
839
840	// THE SYSTEM IS NOW COMPLETELY STOPPED
841
842	// Disable preemption
843	kernel_stop_preemption();
844
845	unregister((__processor_id_t*)mainProcessor);
846
847	// Destroy the main processor and its context in reverse order of construction
848	// These were manually constructed so we need manually destroy them
849	void ^?{}(processor & this) with( this ){
850	/* paranoid */ verify( this.do_terminate == true );
851	__cfaabi_dbg_print_safe("Kernel : destroyed main processor context %p\n", &runner);
852	}
853
854	^(*mainProcessor){};
855
856	// Final step, destroy the main thread since it is no longer needed
857
858	// Since we provided a stack to this taxk it will not destroy anything
859	/* paranoid / verify(mainThread->self_cor.stack.storage == (__stack_t)(((uintptr_t)&storage_mainThreadCtx)\| 0x1));
860	^(*mainThread){};
861
862	^(*mainCluster){};
863
864	^(*__scheduler_lock){};
865
866	^(__cfa_dbg_global_clusters.list){};
867	^(__cfa_dbg_global_clusters.lock){};
868
869	__cfadbg_print_safe(runtime_core, "Kernel : Shutdown complete\n");
870	}
871
872	//=============================================================================================
873	// Kernel Idle Sleep
874	//=============================================================================================
875	static $thread * __halt(processor * this) with( *this ) {
876	if( do_terminate ) return 0p;
877
878	// First, lock the cluster idle
879	lock( cltr->idle_lock __cfaabi_dbg_ctx2 );
880
881	// Check if we can find a thread
882	if( $thread * found = __next_thread( cltr ) ) {
883	unlock( cltr->idle_lock );
884	return found;
885	}
886
887	// Move this processor from the active list to the idle list
888	move_to_front(cltr->procs, cltr->idles, *this);
889
890	// Unlock the idle lock so we don't go to sleep with a lock
891	unlock (cltr->idle_lock);
892
893	// We are ready to sleep
894	__cfadbg_print_safe(runtime_core, "Kernel : Processor %p ready to sleep\n", this);
895	wait( idle );
896
897	// We have woken up
898	__cfadbg_print_safe(runtime_core, "Kernel : Processor %p woke up and ready to run\n", this);
899
900	// Get ourself off the idle list
901	with( *cltr ) {
902	lock (idle_lock __cfaabi_dbg_ctx2);
903	move_to_front(idles, procs, *this);
904	unlock(idle_lock);
905	}
906
907	// Don't check the ready queue again, we may not be in a position to run a thread
908	return 0p;
909	}
910
911	// Wake a thread from the front if there are any
912	static bool __wake_one(cluster * this) {
913	// First, lock the cluster idle
914	lock( this->idle_lock __cfaabi_dbg_ctx2 );
915
916	// Check if there is someone to wake up
917	if( !this->idles.head ) {
918	// Nope unlock and return false
919	unlock( this->idle_lock );
920	return false;
921	}
922
923	// Wake them up
924	__cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head);
925	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
926	post( this->idles.head->idle );
927
928	// Unlock and return true
929	unlock( this->idle_lock );
930	return true;
931	}
932
933	// Unconditionnaly wake a thread
934	static bool __wake_proc(processor * this) {
935	__cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
936
937	disable_interrupts();
938	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
939	bool ret = post( this->idle );
940	enable_interrupts( __cfaabi_dbg_ctx );
941
942	return ret;
943	}
944
945	//=============================================================================================
946	// Unexpected Terminating logic
947	//=============================================================================================
948	static __spinlock_t kernel_abort_lock;
949	static bool kernel_abort_called = false;
950
951	void * kernel_abort(void) __attribute__ ((__nothrow__)) {
952	// abort cannot be recursively entered by the same or different processors because all signal handlers return when
953	// the globalAbort flag is true.
954	lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
955
956	// first task to abort ?
957	if ( kernel_abort_called ) { // not first task to abort ?
958	unlock( kernel_abort_lock );
959
960	sigset_t mask;
961	sigemptyset( &mask );
962	sigaddset( &mask, SIGALRM ); // block SIGALRM signals
963	sigaddset( &mask, SIGUSR1 ); // block SIGALRM signals
964	sigsuspend( &mask ); // block the processor to prevent further damage during abort
965	_exit( EXIT_FAILURE ); // if processor unblocks before it is killed, terminate it
966	}
967	else {
968	kernel_abort_called = true;
969	unlock( kernel_abort_lock );
970	}
971
972	return kernelTLS.this_thread;
973	}
974
975	void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
976	$thread * thrd = kernel_data;
977
978	if(thrd) {
979	int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
980	__cfaabi_bits_write( STDERR_FILENO, abort_text, len );
981
982	if ( &thrd->self_cor != thrd->curr_cor ) {
983	len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
984	__cfaabi_bits_write( STDERR_FILENO, abort_text, len );
985	}
986	else {
987	__cfaabi_bits_write( STDERR_FILENO, ".\n", 2 );
988	}
989	}
990	else {
991	int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
992	__cfaabi_bits_write( STDERR_FILENO, abort_text, len );
993	}
994	}
995
996	int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
997	return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
998	}
999
1000	static __spinlock_t kernel_debug_lock;
1001
1002	extern "C" {
1003	void __cfaabi_bits_acquire() {
1004	lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
1005	}
1006
1007	void __cfaabi_bits_release() {
1008	unlock( kernel_debug_lock );
1009	}
1010	}
1011
1012	//=============================================================================================
1013	// Kernel Utilities
1014	//=============================================================================================
1015	//-----------------------------------------------------------------------------
1016	// Locks
1017	void ?{}( semaphore & this, int count = 1 ) {
1018	(this.lock){};
1019	this.count = count;
1020	(this.waiting){};
1021	}
1022	void ^?{}(semaphore & this) {}
1023
1024	bool P(semaphore & this) with( this ){
1025	lock( lock __cfaabi_dbg_ctx2 );
1026	count -= 1;
1027	if ( count < 0 ) {
1028	// queue current task
1029	append( waiting, kernelTLS.this_thread );
1030
1031	// atomically release spin lock and block
1032	unlock( lock );
1033	park( __cfaabi_dbg_ctx );
1034	return true;
1035	}
1036	else {
1037	unlock( lock );
1038	return false;
1039	}
1040	}
1041
1042	bool V(semaphore & this) with( this ) {
1043	$thread * thrd = 0p;
1044	lock( lock __cfaabi_dbg_ctx2 );
1045	count += 1;
1046	if ( count <= 0 ) {
1047	// remove task at head of waiting list
1048	thrd = pop_head( waiting );
1049	}
1050
1051	unlock( lock );
1052
1053	// make new owner
1054	unpark( thrd __cfaabi_dbg_ctx2 );
1055
1056	return thrd != 0p;
1057	}
1058
1059	bool V(semaphore & this, unsigned diff) with( this ) {
1060	$thread * thrd = 0p;
1061	lock( lock __cfaabi_dbg_ctx2 );
1062	int release = max(-count, (int)diff);
1063	count += diff;
1064	for(release) {
1065	unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 );
1066	}
1067
1068	unlock( lock );
1069
1070	return thrd != 0p;
1071	}
1072
1073	//-----------------------------------------------------------------------------
1074	// Global Queues
1075	void doregister( cluster & cltr ) {
1076	lock ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
1077	push_front( __cfa_dbg_global_clusters.list, cltr );
1078	unlock ( __cfa_dbg_global_clusters.lock );
1079	}
1080
1081	void unregister( cluster & cltr ) {
1082	lock ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
1083	remove( __cfa_dbg_global_clusters.list, cltr );
1084	unlock( __cfa_dbg_global_clusters.lock );
1085	}
1086
1087	void doregister( cluster * cltr, $thread & thrd ) {
1088	lock (cltr->thread_list_lock __cfaabi_dbg_ctx2);
1089	cltr->nthreads += 1;
1090	push_front(cltr->threads, thrd);
1091	unlock (cltr->thread_list_lock);
1092	}
1093
1094	void unregister( cluster * cltr, $thread & thrd ) {
1095	lock (cltr->thread_list_lock __cfaabi_dbg_ctx2);
1096	remove(cltr->threads, thrd );
1097	cltr->nthreads -= 1;
1098	unlock(cltr->thread_list_lock);
1099	}
1100
1101	void doregister( cluster * cltr, processor * proc ) {
1102	lock (cltr->idle_lock __cfaabi_dbg_ctx2);
1103	cltr->nprocessors += 1;
1104	push_front(cltr->procs, *proc);
1105	unlock (cltr->idle_lock);
1106	}
1107
1108	void unregister( cluster * cltr, processor * proc ) {
1109	lock (cltr->idle_lock __cfaabi_dbg_ctx2);
1110	remove(cltr->procs, *proc );
1111	cltr->nprocessors -= 1;
1112	unlock(cltr->idle_lock);
1113	}
1114
1115	//-----------------------------------------------------------------------------
1116	// Debug
1117	__cfaabi_dbg_debug_do(
1118	extern "C" {
1119	void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]) {
1120	this.prev_name = prev_name;
1121	this.prev_thrd = kernelTLS.this_thread;
1122	}
1123
1124	void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
1125	if(park) {
1126	this.park_caller = prev_name;
1127	this.park_stale = false;
1128	}
1129	else {
1130	this.unpark_caller = prev_name;
1131	this.unpark_stale = false;
1132	}
1133	}
1134	}
1135	)
1136
1137	//-----------------------------------------------------------------------------
1138	// Debug
1139	bool threading_enabled(void) __attribute__((const)) {
1140	return true;
1141	}
1142	// Local Variables: //
1143	// mode: c //
1144	// tab-width: 4 //
1145	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format