CM: Applications can now handle process events

Applications can register handler function for specific process
events. These functions will be called before the library handler
routines for that event.

Author: coderarjob

include/cm/cm.h

@@ -10,7 +10,7 @@
 
 #include <types.h>
 #include <stdarg.h>
-#if defined(KERNEL) || defined (UNITTEST)
+#if defined(KERNEL) || defined(UNITTEST)
     #include <cm/osif.h>
     #include <cm/syscall.h>
 #else
@@ -36,7 +36,6 @@ void cm_delay (UINT ms);
  ***************************************************************************************************/
 INT cm_thread_create (void (*startLocation)(), bool isKernelMode);
 INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode);
-bool cm_process_is_yield_requested();
 
 static inline void cm_process_yield()
 {
@@ -57,3 +56,10 @@ static inline void* cm_process_get_datamem_start()
 {
     return (void*)syscall (OSIF_SYSCALL_PROCESS_GET_DATAMEM_START, 0, 0, 0, 0, 0);
 }
+
+/***************************************************************************************************
+ * Handling of process events
+***************************************************************************************************/
+typedef void (*cm_event_handler)(OSIF_ProcessEvent const * const);
+bool cm_process_register_event_handler(OSIF_ProcessEvents event, cm_event_handler h);
+bool cm_process_handle_events();

include/cm/err.h

@@ -19,8 +19,9 @@
 
 typedef enum CMErrors {
     // OS Errors start from 0 and must end before the start of library errors
-    LIBRARY_ERRORS_START = 100,
-    CM_ERR_INVALID_INPUT = 100,
+    LIBRARY_ERRORS_START                    = 100,
+    CM_ERR_INVALID_INPUT                    = 100,
+    CM_ERR_EVENT_HANDLER_ALREADY_REGISTERED = 101,
 } CMErrors;
 
 extern uint32_t cm_error_num__;

include/cm/osif.h

@@ -37,7 +37,8 @@ typedef enum OSIF_SYSCALLS {
 typedef enum OSIF_ProcessEvents {
     OSIF_PROCESS_EVENT_NONE                  = 0,
     OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ    = 1,
-    OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED = 2
+    OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED = 2,
+    OSIF_PROCESS_EVENTS_COUNT
 } OSIF_ProcessEvents;
 
 typedef struct OSIF_ProcessEvent {

src/apps/gui0.c

@@ -33,9 +33,7 @@ void proc_main()
     cm_thread_create (&thread0, false);
 
     while (1) {
-        if (cm_process_is_yield_requested()) {
-            cm_process_yield();
-        }
+        cm_process_handle_events();
     }
 }
 

src/cm/cm.c

@@ -14,22 +14,6 @@ uint32_t cm_error_num__;
 
 #define cm_MICRODEC_TO_TICK_COUNT(us) ((us) / cm_get_tick_period_us())
 
-void event_handler_NDU_()
-{
-    volatile OSIF_ProcessEvent e = { 0 };
-    cm_process_pop_event ((OSIF_ProcessEvent*)&e);
-    switch (e.event) {
-    case OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ:
-        cm_process_yield();
-        break;
-    case OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED:
-        CM_DBG_INFO ("Child exitted with code: %x", e.data);
-        break;
-    case OSIF_PROCESS_EVENT_NONE:
-        break;
-    }
-}
-
 void cm_delay (UINT ms)
 {
     UINT us = ms * 1000;
@@ -38,6 +22,6 @@ void cm_delay (UINT ms)
     U32 end_tick   = start_tick + cm_MICRODEC_TO_TICK_COUNT (us);
 
     while (cm_get_tickcount() < end_tick) {
-        event_handler_NDU_();
+        cm_process_handle_events();
     }
 }

src/cm/process.c

@@ -7,6 +7,66 @@
 #include <process.h>
 #include <cm/syscall.h>
 #include <cm/err.h>
+#include <cm/cm.h>
+#include <stdbool.h>
+
+/***************************************************************************************************
+ * Handling of process events
+ * Some events are handled automaticaly by the library while others are for the applications to
+ * handle. The applications can register a hander function for each event and those will be called
+ * when the associated event is read.
+ *
+ * Not that though every thread receives events, the application event handler function is common
+ * and is shared by every thread & the parent process. Per thread handling of events can be
+ * done by quering process id.
+ ***************************************************************************************************/
+static cm_event_handler app_event_handlers[OSIF_PROCESS_EVENTS_COUNT] = { 0 };
+
+bool cm_process_register_event_handler (OSIF_ProcessEvents e, cm_event_handler h)
+{
+    if (app_event_handlers[e] != NULL) {
+        CM_RETURN_ERROR__ (CM_ERR_EVENT_HANDLER_ALREADY_REGISTERED, false);
+    }
+
+    app_event_handlers[e] = h;
+    return true;
+}
+
+/***************************************************************************************************
+* Default handler for process events
+*
+* Note:
+* Since its upto each process to read their events queue and handle them,
+* it is important that cm_process_handle_events() gets called regularly.
+**************************************************************************************************/
+bool cm_process_handle_events()
+{
+    volatile OSIF_ProcessEvent e = { 0 };
+    if (!cm_process_pop_event ((OSIF_ProcessEvent*)&e)) {
+        CM_RETURN_ERROR__ (cm_get_os_error(), false);
+    }
+
+    switch (e.event) {
+    case OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ:
+        if (app_event_handlers[e.event]) {
+            app_event_handlers[e.event]((const OSIF_ProcessEvent* const)&e);
+        }
+        cm_process_yield();
+        break;
+    case OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED:
+        if (app_event_handlers[e.event]) {
+            app_event_handlers[e.event]((const OSIF_ProcessEvent* const)&e);
+        }
+        break;
+    case OSIF_PROCESS_EVENT_NONE:
+        break;
+    default:
+        // TODO: Should panic! and kill the process
+        break;
+    }
+    return true;
+}
+/**************************************************************************************************/
 
 INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode)
 {
@@ -44,10 +104,3 @@ INT cm_thread_create (void (*startLocation)(), bool isKernelMode)
     }
     return pid;
 }
-
-bool cm_process_is_yield_requested()
-{
-    volatile OSIF_ProcessEvent e = { 0 };
-    cm_process_pop_event ((OSIF_ProcessEvent*)&e);
-    return (e.event == OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ);
-}