sef: Naming refactory.

Change-Id: Id313e73fde577e48a17f2c16c808c9156a1be804

diff --git a/minix/lib/libsys/sef_init.c b/minix/lib/libsys/sef_init.c
index dae1935ef3425e9d2bd7a7a3712a281c5113e012..23cf5cf7d63469def9476feb6992eae859756501 100644 (file)
--- a/minix/lib/libsys/sef_init.c
+++ b/minix/lib/libsys/sef_init.c
@@ -5,12 +5,12 @@
 #include <string.h>
 
 /* SEF Init callbacks. */
-static struct sef_cbs {
+static struct sef_init_cbs {
     sef_cb_init_t                       sef_cb_init_fresh;
     sef_cb_init_t                       sef_cb_init_lu;
     sef_cb_init_t                       sef_cb_init_restart;
     sef_cb_init_response_t              sef_cb_init_response;
-} sef_cbs = {
+} sef_init_cbs = {
     SEF_CB_INIT_FRESH_DEFAULT,
     SEF_CB_INIT_LU_DEFAULT,
     SEF_CB_INIT_RESTART_DEFAULT,
@@ -48,13 +48,13 @@ static int process_init(int type, sef_init_info_t *info)
   /* Let the callback code handle the specific initialization type. */
   switch(type) {
       case SEF_INIT_FRESH:
-          result = sef_cbs.sef_cb_init_fresh(type, info);
+          result = sef_init_cbs.sef_cb_init_fresh(type, info);
       break;
       case SEF_INIT_LU:
-          result = sef_cbs.sef_cb_init_lu(type, info);
+          result = sef_init_cbs.sef_cb_init_lu(type, info);
       break;
       case SEF_INIT_RESTART:
-          result = sef_cbs.sef_cb_init_restart(type, info);
+          result = sef_init_cbs.sef_cb_init_restart(type, info);
       break;
 
       default:
@@ -67,7 +67,7 @@ static int process_init(int type, sef_init_info_t *info)
   m.m_source = sef_self_endpoint;
   m.m_type = RS_INIT;
   m.m_rs_init.result = result;
-  r = sef_cbs.sef_cb_init_response(&m);
+  r = sef_init_cbs.sef_cb_init_response(&m);
 
   return r;
 }
@@ -128,7 +128,7 @@ int do_sef_init_request(message *m_ptr)
 void sef_setcb_init_fresh(sef_cb_init_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_init_fresh = cb;
+  sef_init_cbs.sef_cb_init_fresh = cb;
 }
 
 /*===========================================================================*
@@ -137,7 +137,7 @@ void sef_setcb_init_fresh(sef_cb_init_t cb)
 void sef_setcb_init_lu(sef_cb_init_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_init_lu = cb;
+  sef_init_cbs.sef_cb_init_lu = cb;
 }
 
 /*===========================================================================*
@@ -146,7 +146,7 @@ void sef_setcb_init_lu(sef_cb_init_t cb)
 void sef_setcb_init_restart(sef_cb_init_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_init_restart = cb;
+  sef_init_cbs.sef_cb_init_restart = cb;
 }
 
 /*===========================================================================*
@@ -155,7 +155,7 @@ void sef_setcb_init_restart(sef_cb_init_t cb)
 void sef_setcb_init_response(sef_cb_init_response_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_init_response = cb;
+  sef_init_cbs.sef_cb_init_response = cb;
 }
 
 /*===========================================================================*
@@ -197,7 +197,7 @@ int sef_cb_init_reset(int UNUSED(type), sef_init_info_t *UNUSED(info))
  *===========================================================================*/
 int sef_cb_init_crash(int UNUSED(type), sef_init_info_t *UNUSED(info))
 {
-  panic("Simulating a crash at initialization time...");
+  panic("Simulating a crash at initialization time...\n");
 
   return OK;
 }

diff --git a/minix/lib/libsys/sef_liveupdate.c b/minix/lib/libsys/sef_liveupdate.c
index 409336c68dd3f1c6930ee944c6f2389f583fe224..537f9a98cb5f874c0bb9fa59b7fdf266795ffdf0 100644 (file)
--- a/minix/lib/libsys/sef_liveupdate.c
+++ b/minix/lib/libsys/sef_liveupdate.c
@@ -9,14 +9,14 @@ static int sef_lu_flags;
 extern __attribute__((weak)) int st_do_state_cleanup(void);
 
 /* SEF Live update callbacks. */
-static struct sef_cbs {
+static struct sef_lu_cbs {
     sef_cb_lu_prepare_t                 sef_cb_lu_prepare;
     sef_cb_lu_state_isvalid_t           sef_cb_lu_state_isvalid;
     sef_cb_lu_state_changed_t           sef_cb_lu_state_changed;
     sef_cb_lu_state_dump_t              sef_cb_lu_state_dump;
     sef_cb_lu_state_save_t              sef_cb_lu_state_save;
     sef_cb_lu_response_t                sef_cb_lu_response;
-} sef_cbs = {
+} sef_lu_cbs = {
     SEF_CB_LU_PREPARE_DEFAULT,
     SEF_CB_LU_STATE_ISVALID_DEFAULT,
     SEF_CB_LU_STATE_CHANGED_DEFAULT,
@@ -64,7 +64,7 @@ void do_sef_lu_before_receive(void)
   sef_lu_debug_begin();
   sef_lu_dprint("%s, cycle=%d. Dumping state variables:\n",
       sef_debug_header(), sef_lu_debug_cycle);
-  sef_cbs.sef_cb_lu_state_dump(sef_lu_state);
+  sef_lu_cbs.sef_cb_lu_state_dump(sef_lu_state);
   sef_lu_debug_end();
 #endif
 
@@ -73,7 +73,7 @@ void do_sef_lu_before_receive(void)
    */
   r = OK;
   if(sef_lu_state != SEF_LU_STATE_WORK_FREE) {
-      r = sef_cbs.sef_cb_lu_prepare(sef_lu_state);
+      r = sef_lu_cbs.sef_cb_lu_prepare(sef_lu_state);
   }
   if(r == OK) {
       sef_lu_ready(OK);
@@ -98,9 +98,9 @@ int do_sef_lu_request(message *m_ptr)
 
   /* Otherwise only accept live update requests with a valid state. */
   is_valid_state = SEF_LU_ALWAYS_ALLOW_DEBUG_STATES && SEF_LU_STATE_IS_DEBUG(state);
-  is_valid_state = is_valid_state || sef_cbs.sef_cb_lu_state_isvalid(state, flags);
+  is_valid_state = is_valid_state || sef_lu_cbs.sef_cb_lu_state_isvalid(state, flags);
   if(!is_valid_state) {
-      if(sef_cbs.sef_cb_lu_state_isvalid == SEF_CB_LU_STATE_ISVALID_DEFAULT) {
+      if(sef_lu_cbs.sef_cb_lu_state_isvalid == SEF_CB_LU_STATE_ISVALID_DEFAULT) {
           sef_lu_ready(ENOSYS);
       }
       else {
@@ -115,7 +115,7 @@ int do_sef_lu_request(message *m_ptr)
        * handle the rest.
        */
       if(old_state != sef_lu_state) {
-          sef_cbs.sef_cb_lu_state_changed(old_state, sef_lu_state);
+          sef_lu_cbs.sef_cb_lu_state_changed(old_state, sef_lu_state);
       }
   }
 
@@ -148,7 +148,7 @@ static void sef_lu_ready(int result)
       if (st_do_state_cleanup)
           r = st_do_state_cleanup();
       if(r == OK) {
-          r = sef_cbs.sef_cb_lu_state_save(sef_lu_state, sef_lu_flags);
+          r = sef_lu_cbs.sef_cb_lu_state_save(sef_lu_state, sef_lu_flags);
       }
       if(r != OK) {
           /* Abort update in case of error. */
@@ -164,7 +164,7 @@ static void sef_lu_ready(int result)
   m.m_type = RS_LU_PREPARE;
   m.m_rs_update.state = sef_lu_state;
   m.m_rs_update.result = result;
-  r = sef_cbs.sef_cb_lu_response(&m);
+  r = sef_lu_cbs.sef_cb_lu_response(&m);
 
 #if SEF_LU_DEBUG
   sef_lu_debug_begin();
@@ -181,7 +181,7 @@ static void sef_lu_ready(int result)
   old_state = sef_lu_state;
   sef_lu_state = SEF_LU_STATE_NULL;
   if(old_state != sef_lu_state) {
-      sef_cbs.sef_cb_lu_state_changed(old_state, sef_lu_state);
+      sef_lu_cbs.sef_cb_lu_state_changed(old_state, sef_lu_state);
   }
 }
 
@@ -191,7 +191,7 @@ static void sef_lu_ready(int result)
 void sef_setcb_lu_prepare(sef_cb_lu_prepare_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_prepare = cb;
+  sef_lu_cbs.sef_cb_lu_prepare = cb;
 }
 
 /*===========================================================================*
@@ -200,7 +200,7 @@ void sef_setcb_lu_prepare(sef_cb_lu_prepare_t cb)
 void sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_state_isvalid = cb;
+  sef_lu_cbs.sef_cb_lu_state_isvalid = cb;
 }
 
 /*===========================================================================*
@@ -209,7 +209,7 @@ void sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_t cb)
 void sef_setcb_lu_state_changed(sef_cb_lu_state_changed_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_state_changed = cb;
+  sef_lu_cbs.sef_cb_lu_state_changed = cb;
 }
 
 /*===========================================================================*
@@ -218,7 +218,7 @@ void sef_setcb_lu_state_changed(sef_cb_lu_state_changed_t cb)
 void sef_setcb_lu_state_dump(sef_cb_lu_state_dump_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_state_dump = cb;
+  sef_lu_cbs.sef_cb_lu_state_dump = cb;
 }
 
 /*===========================================================================*
@@ -227,7 +227,7 @@ void sef_setcb_lu_state_dump(sef_cb_lu_state_dump_t cb)
 void sef_setcb_lu_state_save(sef_cb_lu_state_save_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_state_save = cb;
+  sef_lu_cbs.sef_cb_lu_state_save = cb;
 }
 
 /*===========================================================================*
@@ -236,7 +236,7 @@ void sef_setcb_lu_state_save(sef_cb_lu_state_save_t cb)
 void sef_setcb_lu_response(sef_cb_lu_response_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_lu_response = cb;
+  sef_lu_cbs.sef_cb_lu_response = cb;
 }
 
 /*===========================================================================*
@@ -315,7 +315,7 @@ int sef_cb_lu_prepare_never_ready(int UNUSED(state))
  *===========================================================================*/
 int sef_cb_lu_prepare_crash(int UNUSED(state))
 {
-  panic("Simulating a crash at update prepare time...");
+  panic("Simulating a crash at update prepare time...\n");
 
   return OK;
 }

diff --git a/minix/lib/libsys/sef_ping.c b/minix/lib/libsys/sef_ping.c
index 2ef642c1e948379840570ea0702b21e39f30891b..54e9fb04dbeb9c8012b4858c22de55210efa8d3d 100644 (file)
--- a/minix/lib/libsys/sef_ping.c
+++ b/minix/lib/libsys/sef_ping.c
@@ -3,9 +3,9 @@
 #include <minix/sysutil.h>
 
 /* SEF Ping callbacks. */
-static struct sef_cbs {
+static struct sef_ping_cbs {
     sef_cb_ping_reply_t                 sef_cb_ping_reply;
-} sef_cbs = {
+} sef_ping_cbs = {
     SEF_CB_PING_REPLY_DEFAULT
 };
 
@@ -31,7 +31,7 @@ int do_sef_ping_request(message *m_ptr)
 #endif
 
   /* Let the callback code handle the request. */
-  sef_cbs.sef_cb_ping_reply(m_ptr->m_source);
+  sef_ping_cbs.sef_cb_ping_reply(m_ptr->m_source);
 
   /* Return OK not to let anybody else intercept the request. */
   return(OK);
@@ -43,7 +43,7 @@ int do_sef_ping_request(message *m_ptr)
 void sef_setcb_ping_reply(sef_cb_ping_reply_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_ping_reply = cb;
+  sef_ping_cbs.sef_cb_ping_reply = cb;
 }
 
 /*===========================================================================*

diff --git a/minix/lib/libsys/sef_signal.c b/minix/lib/libsys/sef_signal.c
index 0a904ee08c514dc79011c9aaf12604d8662ae15f..345fdf22dc616116a713d926f6b8214cbbd0c0e1 100644 (file)
--- a/minix/lib/libsys/sef_signal.c
+++ b/minix/lib/libsys/sef_signal.c
@@ -4,10 +4,10 @@
 #include <minix/sysutil.h>
 
 /* SEF Signal callbacks. */
-static struct sef_cbs {
+static struct sef_signal_cbs {
     sef_cb_signal_handler_t             sef_cb_signal_handler;
     sef_cb_signal_manager_t             sef_cb_signal_manager;
-} sef_cbs = {
+} sef_signal_cbs = {
     SEF_CB_SIGNAL_HANDLER_DEFAULT,
     SEF_CB_SIGNAL_MANAGER_DEFAULT
 };
@@ -47,10 +47,10 @@ static void process_sigmgr_signals(void)
               assert(s >= 0);
               if(s) {
                   /* Let the callback code process the signal. */
-                  r = sef_cbs.sef_cb_signal_manager(target, signo);
+                  r = sef_signal_cbs.sef_cb_signal_manager(target, signo);
 
                   /* Stop if process is gone. */
-                  if(r == EDEADSRCDST) {
+                  if(r == EDEADEPT) {
                       break;
                   }
               }
@@ -77,7 +77,7 @@ static void process_sigmgr_self_signals(sigset_t sigset)
       assert(s >= 0);
       if(s) {
           /* Let the callback code process the signal. */
-          sef_cbs.sef_cb_signal_handler(signo);
+          sef_signal_cbs.sef_cb_signal_handler(signo);
       }
   }
 }
@@ -99,7 +99,7 @@ int do_sef_signal_request(message *m_ptr)
           assert(s >= 0);
           if (s) {
               /* Let the callback code handle the kernel signal. */
-              sef_cbs.sef_cb_signal_handler(signo);
+              sef_signal_cbs.sef_cb_signal_handler(signo);
 
               /* Handle SIGKSIG for a signal manager. */
               if(signo == SIGKSIG) {
@@ -125,7 +125,7 @@ int do_sef_signal_request(message *m_ptr)
 #endif
 
       /* Let the callback code handle the signal. */
-      sef_cbs.sef_cb_signal_handler(signo);
+      sef_signal_cbs.sef_cb_signal_handler(signo);
   }
 
   /* Return OK not to let anybody else intercept the request. */
@@ -138,7 +138,7 @@ int do_sef_signal_request(message *m_ptr)
 void sef_setcb_signal_handler(sef_cb_signal_handler_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_signal_handler = cb;
+  sef_signal_cbs.sef_cb_signal_handler = cb;
 }
 
 /*===========================================================================*
@@ -147,7 +147,7 @@ void sef_setcb_signal_handler(sef_cb_signal_handler_t cb)
 void sef_setcb_signal_manager(sef_cb_signal_manager_t cb)
 {
   assert(cb != NULL);
-  sef_cbs.sef_cb_signal_manager = cb;
+  sef_signal_cbs.sef_cb_signal_manager = cb;
 }
 
 /*===========================================================================*