Changeset 0957f62 for libcfa

Timestamp:

Mar 1, 2026, 5:47:54 PM (45 hours ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

02e7483

Parents:

8086004

Message:

add routines stack_verify and stack_pointer, in debug mode call stack_verify on front-side of context switch and time-slicing

Location:

libcfa/src/concurrency

Files:

• coroutine.cfa (modified) (3 diffs)
• coroutine.hfa (modified) (5 diffs)
• preemption.cfa (modified) (3 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 06:48:19 2025
-// Update Count     : 31
+// Last Modified On : Sun Mar  1 17:36:41 2026
+// Update Count     : 115
 //
 
@@ -326 +326 @@
 void ^?{}( ehm_cleanup & this ) { free( this.ex ); }
 
+void * stack_pointer( coroutine$ * cor ) libcfa_public {
+        if ( active_coroutine() == cor ) {                                      // accessing myself ?
+                void * sp;                                                                              // use my current stack value
+                #if defined( __i386__ )
+                asm( "movl %%esp,%0" : "=m" (sp) : );
+                #elif defined( __x86_64__ )
+                asm( "movq %%rsp,%0" : "=m" (sp) : );
+                #elif defined( __arm_64__ )
+                asm( "mov x9, sp; str x9,%0" : "=m" (sp) : : "x9" );
+                #else
+                        #error Cforall : internal error, unsupported architecture
+                #endif
+                return sp;
+        } else {                                                                                        // accessing another coroutine
+                return cor->context.SP;
+        } // if
+} // stackPointer
+
+void * stack_pointer() libcfa_public { return stack_pointer( active_coroutine() ); }
+
+#define xstr(s) str(s)
+#define str(s) #s
+#define STACK_ERROR 4
+#define STACK_WARNING 16
+
+void stack_verify( coroutine$ * cor ) libcfa_public {
+        void * sp = stack_pointer( cor );                                       // optimizations
+        struct __stack_t * cor_stack = __get_stack( cor );
+        void * safelimit = (void *)((char *)cor_stack->limit + STACK_ERROR * 1024); // space needed for printing abort message and backtrace
+
+        if ( sp < safelimit ) {                                                         // must leave stack space to call abort
+                abort( "Stack overflow detected: stack pointer %p below safe limit %p.\n"
+                           "Possible cause is allocation of large stack frame(s) and/or deep call stack.",
+                           sp, safelimit );
+        } else if ( sp < (void *)((char *)cor_stack->limit + STACK_WARNING * 1024) ) { // must leave stack space to call abort
+                #define STACK_WARNING_MSG "Cforall Runtime warning : within " xstr(STACK_WARNING) "K of stack limit.\n"
+                __cfaabi_bits_write( STDERR_FILENO, STACK_WARNING_MSG, sizeof( STACK_WARNING_MSG ) - 1 );
+        } else if ( sp > cor_stack->base ) {
+                abort( "Stack underflow detected: stack pointer %p above base %p.\n"
+                           "Possible cause is corrupted stack frame via overwriting memory.",
+                           sp, cor_stack->base );
+        } // if
+} // verify
+
+void stack_verify() libcfa_public { return stack_verify( active_coroutine() ); }
+
 bool poll( coroutine$ * cor ) libcfa_public {
         nonlocal_exception * nl_ex = pop_ehm_head( cor );
@@ -351 +397 @@
 // user facing ehm operations
 forall(T & | is_coroutine(T)) {
+        void * stack_pointer( T & cor ) libcfa_public { return stack_pointer( get_coroutine( cor ) ); }
+        void stack_verify( T & cor ) libcfa_public { return stack_verify( get_coroutine( cor ) ); }
+
         // enable/disable non-local exceptions
         void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }

libcfa/src/concurrency/coroutine.hfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 06:52:04 2025
-// Update Count     : 15
+// Last Modified On : Sun Mar  1 17:44:11 2026
+// Update Count     : 43
 //
 
@@ -98 +98 @@
 }
 
+void stack_verify( coroutine$ * cor );
+void stack_verify();
+
 // Private wrappers for context switch and stack creation
-// Wrapper for co
 static inline void $ctx_switch( coroutine$ * src, coroutine$ * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
@@ -110 +112 @@
         /* paranoid */ verify( !athrd->corctx_flag );
         athrd->corctx_flag = true;
+
+        #if defined( __CFA_DEBUG__ )
+        stack_verify( src );                                                            // test on front side of context switch, backside is too late.
+        #endif // __CFA_DEBUG__
 
         // set new coroutine that task is executing
@@ -225 +231 @@
 
 // non local ehm and coroutine utility routines
+void * stack_pointer( coroutine$ * cor );
+void * stack_pointer();
 void enable_ehm();
 void disable_ehm();
@@ -234 +242 @@
 
 forall(T & | is_coroutine(T)) {
+        void * stack_pointer( T & cor );
+        void stack_verify( T & cor );
     void enable_ehm( T & cor );         // enable checking non-local exceptions for cor via checked_poll
     void disable_ehm( T & cor );        // disable checking non-local exceptions for cor via checked_poll

libcfa/src/concurrency/preemption.cfa

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 07:24:39 2025
-// Update Count     : 63
+// Last Modified On : Sun Mar  1 10:00:18 2026
+// Update Count     : 68
 //
 
@@ -571 +571 @@
         __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", __cfaabi_tls.this_processor, __cfaabi_tls.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
 
+        #if defined( __CFA_DEBUG__ )
+        stack_verify();                                                                         // good place to check for stack overflow
+        #endif // __CFA_DEBUG__
+
         // Sync flag : prevent recursive calls to the signal handler
         __cfaabi_tls.preemption_state.in_progress = true;
@@ -591 +595 @@
         #endif
 
-        force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch
+        force_yield( __ALARM_PREEMPTION );                                      // Do the actual __cfactx_switch
 }