sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

sef: Naming refactory.

Browse source 
Change-Id: Id313e73fde577e48a17f2c16c808c9156a1be804
This commit is contained in:
Cristiano Giuffrida 2014-09-28 18:53:31 +02:00 committed by David van Moolenbroek
parent dd09614042
commit e6f5b0cc65
4 changed files with 41 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
minix/lib/libsys/sef_init.c
View file

@ -5,12 +5,12 @@
#include <string.h> #include <string.h>
/* SEF Init callbacks. */ /* 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_fresh;
sef_cb_init_t sef_cb_init_lu; sef_cb_init_t sef_cb_init_lu;
sef_cb_init_t sef_cb_init_restart; sef_cb_init_t sef_cb_init_restart;
sef_cb_init_response_t sef_cb_init_response; sef_cb_init_response_t sef_cb_init_response;
} sef_cbs = { } sef_init_cbs = {
SEF_CB_INIT_FRESH_DEFAULT, SEF_CB_INIT_FRESH_DEFAULT,
SEF_CB_INIT_LU_DEFAULT, SEF_CB_INIT_LU_DEFAULT,
SEF_CB_INIT_RESTART_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. */ /* Let the callback code handle the specific initialization type. */
switch(type) { switch(type) {
case SEF_INIT_FRESH: case SEF_INIT_FRESH:
result = sef_cbs.sef_cb_init_fresh(type, info); result = sef_init_cbs.sef_cb_init_fresh(type, info);
break; break;
case SEF_INIT_LU: case SEF_INIT_LU:
result = sef_cbs.sef_cb_init_lu(type, info); result = sef_init_cbs.sef_cb_init_lu(type, info);
break; break;
case SEF_INIT_RESTART: case SEF_INIT_RESTART:
result = sef_cbs.sef_cb_init_restart(type, info); result = sef_init_cbs.sef_cb_init_restart(type, info);
break; break;
default: default:
@ -67,7 +67,7 @@ static int process_init(int type, sef_init_info_t *info)
m.m_source = sef_self_endpoint; m.m_source = sef_self_endpoint;
m.m_type = RS_INIT; m.m_type = RS_INIT;
m.m_rs_init.result = result; 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; return r;
} }
@ -128,7 +128,7 @@ int do_sef_init_request(message *m_ptr)
void sef_setcb_init_fresh(sef_cb_init_t cb) void sef_setcb_init_fresh(sef_cb_init_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_init_lu(sef_cb_init_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_init_restart(sef_cb_init_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_init_response(sef_cb_init_response_t cb)
{ {
assert(cb != NULL); 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)) 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; return OK;
} }

34
minix/lib/libsys/sef_liveupdate.c
View file

@ -9,14 +9,14 @@ static int sef_lu_flags;
extern __attribute__((weak)) int st_do_state_cleanup(void); extern __attribute__((weak)) int st_do_state_cleanup(void);
/* SEF Live update callbacks. */ /* 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_prepare_t sef_cb_lu_prepare;
sef_cb_lu_state_isvalid_t sef_cb_lu_state_isvalid; 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_changed_t sef_cb_lu_state_changed;
sef_cb_lu_state_dump_t sef_cb_lu_state_dump; 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_state_save_t sef_cb_lu_state_save;
sef_cb_lu_response_t sef_cb_lu_response; sef_cb_lu_response_t sef_cb_lu_response;
} sef_cbs = { } sef_lu_cbs = {
SEF_CB_LU_PREPARE_DEFAULT, SEF_CB_LU_PREPARE_DEFAULT,
SEF_CB_LU_STATE_ISVALID_DEFAULT, SEF_CB_LU_STATE_ISVALID_DEFAULT,
SEF_CB_LU_STATE_CHANGED_DEFAULT, SEF_CB_LU_STATE_CHANGED_DEFAULT,
@ -64,7 +64,7 @@ void do_sef_lu_before_receive(void)
sef_lu_debug_begin(); sef_lu_debug_begin();
sef_lu_dprint("%s, cycle=%d. Dumping state variables:\n", sef_lu_dprint("%s, cycle=%d. Dumping state variables:\n",
sef_debug_header(), sef_lu_debug_cycle); 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(); sef_lu_debug_end();
#endif #endif
@ -73,7 +73,7 @@ void do_sef_lu_before_receive(void)
*/ */
r = OK; r = OK;
if(sef_lu_state != SEF_LU_STATE_WORK_FREE) { 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) { if(r == OK) {
sef_lu_ready(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. */ /* 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 = 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(!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); sef_lu_ready(ENOSYS);
} }
else { else {
@ -115,7 +115,7 @@ int do_sef_lu_request(message *m_ptr)
* handle the rest. * handle the rest.
*/ */
if(old_state != sef_lu_state) { 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) if (st_do_state_cleanup)
r = st_do_state_cleanup(); r = st_do_state_cleanup();
if(r == OK) { 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) { if(r != OK) {
/* Abort update in case of error. */ /* 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_type = RS_LU_PREPARE;
m.m_rs_update.state = sef_lu_state; m.m_rs_update.state = sef_lu_state;
m.m_rs_update.result = result; 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 #if SEF_LU_DEBUG
sef_lu_debug_begin(); sef_lu_debug_begin();
@ -181,7 +181,7 @@ static void sef_lu_ready(int result)
old_state = sef_lu_state; old_state = sef_lu_state;
sef_lu_state = SEF_LU_STATE_NULL; sef_lu_state = SEF_LU_STATE_NULL;
if(old_state != sef_lu_state) { 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) void sef_setcb_lu_prepare(sef_cb_lu_prepare_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_lu_state_changed(sef_cb_lu_state_changed_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_lu_state_dump(sef_cb_lu_state_dump_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_lu_state_save(sef_cb_lu_state_save_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_lu_response(sef_cb_lu_response_t cb)
{ {
assert(cb != NULL); 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)) 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; return OK;
} }

8
minix/lib/libsys/sef_ping.c
View file

@ -3,9 +3,9 @@
#include <minix/sysutil.h> #include <minix/sysutil.h>
/* SEF Ping callbacks. */ /* SEF Ping callbacks. */
static struct sef_cbs { static struct sef_ping_cbs {
sef_cb_ping_reply_t sef_cb_ping_reply; sef_cb_ping_reply_t sef_cb_ping_reply;
} sef_cbs = { } sef_ping_cbs = {
SEF_CB_PING_REPLY_DEFAULT SEF_CB_PING_REPLY_DEFAULT
}; };
@ -31,7 +31,7 @@ int do_sef_ping_request(message *m_ptr)
#endif #endif
/* Let the callback code handle the request. */ /* 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 not to let anybody else intercept the request. */
return(OK); 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) void sef_setcb_ping_reply(sef_cb_ping_reply_t cb)
{ {
assert(cb != NULL); assert(cb != NULL);
sef_cbs.sef_cb_ping_reply = cb; sef_ping_cbs.sef_cb_ping_reply = cb;
} }
/*===========================================================================* /*===========================================================================*

18
minix/lib/libsys/sef_signal.c
View file

@ -4,10 +4,10 @@
#include <minix/sysutil.h> #include <minix/sysutil.h>
/* SEF Signal callbacks. */ /* SEF Signal callbacks. */
static struct sef_cbs { static struct sef_signal_cbs {
sef_cb_signal_handler_t sef_cb_signal_handler; sef_cb_signal_handler_t sef_cb_signal_handler;
sef_cb_signal_manager_t sef_cb_signal_manager; sef_cb_signal_manager_t sef_cb_signal_manager;
} sef_cbs = { } sef_signal_cbs = {
SEF_CB_SIGNAL_HANDLER_DEFAULT, SEF_CB_SIGNAL_HANDLER_DEFAULT,
SEF_CB_SIGNAL_MANAGER_DEFAULT SEF_CB_SIGNAL_MANAGER_DEFAULT
}; };
@ -47,10 +47,10 @@ static void process_sigmgr_signals(void)
assert(s >= 0); assert(s >= 0);
if(s) { if(s) {
/* Let the callback code process the signal. */ /* 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. */ /* Stop if process is gone. */
if(r == EDEADSRCDST) { if(r == EDEADEPT) {
break; break;
} }
} }
@ -77,7 +77,7 @@ static void process_sigmgr_self_signals(sigset_t sigset)
assert(s >= 0); assert(s >= 0);
if(s) { if(s) {
/* Let the callback code process the signal. */ /* 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); assert(s >= 0);
if (s) { if (s) {
/* Let the callback code handle the kernel signal. */ /* 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. */ /* Handle SIGKSIG for a signal manager. */
if(signo == SIGKSIG) { if(signo == SIGKSIG) {
@ -125,7 +125,7 @@ int do_sef_signal_request(message *m_ptr)
#endif #endif
/* Let the callback code handle the signal. */ /* 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. */ /* 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) void sef_setcb_signal_handler(sef_cb_signal_handler_t cb)
{ {
assert(cb != NULL); 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) void sef_setcb_signal_manager(sef_cb_signal_manager_t cb)
{ {
assert(cb != NULL); assert(cb != NULL);
sef_cbs.sef_cb_signal_manager = cb; sef_signal_cbs.sef_cb_signal_manager = cb;
} }
/*===========================================================================* /*===========================================================================*