/*===========================================================================*
* sef_lu_ready *
*===========================================================================*/
static void sef_lu_ready(int result)
{
message m;
int old_state, r;
#if SEF_LU_DEBUG
sef_lu_debug_begin();
sef_lu_dprint("%s, cycle=%d. Ready to update with result: %d%s\n",
sef_debug_header(), sef_lu_debug_cycle,
result, (result == OK ? "(OK)" : ""));
sef_lu_debug_end();
#endif
/* If result is OK, let the callback code save
* any state that must be carried over to the new version.
*/
if(result == OK) {
r = sef_cbs.sef_cb_lu_state_save(sef_lu_state);
if(r != OK) {
/* Abort update if callback returned error. */
result = r;
}
}
/* Let the callback code produce a live update response and block.
* We should get beyond this point only if either result is an error or
* something else goes wrong in the callback code.
*/
m.m_source = sef_self_endpoint;
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);
#if SEF_LU_DEBUG
sef_lu_debug_begin();
sef_lu_dprint("%s, cycle=%d. The %s aborted the update with result %d!\n",
sef_debug_header(), sef_lu_debug_cycle,
(result == OK ? "server" : "client"),
(result == OK ? r : result)); /* EINTR if update was canceled. */
sef_lu_debug_end();
#endif
/* Something went wrong. Update was aborted and we didn't get updated.
* Restore things back to normal and continue executing.
*/
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_cb_lu_prepare_never_ready *
*===========================================================================*/
int sef_cb_lu_prepare_never_ready(int UNUSED(state))
{
#if SEF_LU_DEBUG
sef_lu_debug_begin();
sef_lu_dprint("%s, cycle=%d. Simulating a service never ready to update...\n",
sef_debug_header(), sef_lu_debug_cycle);
sef_lu_debug_end();
#endif
return ENOTREADY;
}
/*===========================================================================*
* sef_cb_lu_state_dump *
*===========================================================================*/
void sef_cb_lu_state_dump(int state)
{
sef_lu_dprint("floppy: live update state = %d\n", state);
sef_lu_dprint("floppy: f_busy = %d\n", f_busy);
sef_lu_dprint("floppy: motor_status = 0x%02X\n", motor_status);
sef_lu_dprint("floppy: f_drive = %d\n", f_drive);
sef_lu_dprint("floppy: last_was_write = %d\n", last_was_write);
sef_lu_dprint("floppy: SEF_LU_STATE_WORK_FREE(%d) reached = %d\n",
SEF_LU_STATE_WORK_FREE, TRUE);
sef_lu_dprint("floppy: SEF_LU_STATE_REQUEST_FREE(%d) reached = %d\n",
SEF_LU_STATE_REQUEST_FREE, (!IS_REQUEST_PENDING(f_busy)));
sef_lu_dprint("floppy: SEF_LU_STATE_PROTOCOL_FREE(%d) reached = %d\n",
SEF_LU_STATE_PROTOCOL_FREE, (!IS_REQUEST_PENDING(f_busy)));
sef_lu_dprint("floppy: FL_STATE_MOTOR_OFF(%d) reached = %d\n",
FL_STATE_MOTOR_OFF, (!IS_REQUEST_PENDING(f_busy)
&& !IS_MOTOR_RUNNING(motor_status, f_drive)));
}
/*===========================================================================*
* sef_cb_lu_state_dump *
*===========================================================================*/
PUBLIC void sef_cb_lu_state_dump(int state)
{
sef_lu_dprint("sb16: live update state = %d\n", state);
sef_lu_dprint("sb16: is_processing = %d\n", is_processing);
sef_lu_dprint("sb16: is_status_msg_expected = %d\n",
is_status_msg_expected);
sef_lu_dprint("sb16: SEF_LU_STATE_WORK_FREE(%d) reached = %d\n",
SEF_LU_STATE_WORK_FREE, TRUE);
sef_lu_dprint("sb16: SEF_LU_STATE_REQUEST_FREE(%d) reached = %d\n",
SEF_LU_STATE_REQUEST_FREE, TRUE);
sef_lu_dprint("sb16: SEF_LU_STATE_PROTOCOL_FREE(%d) reached = %d\n",
SEF_LU_STATE_PROTOCOL_FREE, (!is_processing && !is_status_msg_expected));
sef_lu_dprint("sb16: SB16_STATE_PROCESSING_PROTOCOL_FREE(%d) reached = %d\n",
SB16_STATE_PROCESSING_PROTOCOL_FREE, (!is_processing));
}
/*===========================================================================*
* sef_cb_lu_state_dump *
*===========================================================================*/
PUBLIC void sef_cb_lu_state_dump(int state)
{
sef_lu_dprint("printer: live update state = %d\n", state);
sef_lu_dprint("printer: writing = %d\n", writing);
sef_lu_dprint("printer: is_status_msg_expected = %d\n",
is_status_msg_expected);
sef_lu_dprint("printer: SEF_LU_STATE_WORK_FREE(%d) reached = %d\n",
SEF_LU_STATE_WORK_FREE, TRUE);
sef_lu_dprint("printer: SEF_LU_STATE_REQUEST_FREE(%d) reached = %d\n",
SEF_LU_STATE_REQUEST_FREE, TRUE);
sef_lu_dprint("printer: SEF_LU_STATE_PROTOCOL_FREE(%d) reached = %d\n",
SEF_LU_STATE_PROTOCOL_FREE, (!writing && !is_status_msg_expected));
sef_lu_dprint("printer: PR_STATE_WRITE_PROTOCOL_FREE(%d) reached = %d\n",
PR_STATE_WRITE_PROTOCOL_FREE, (!writing));
}
/*===========================================================================*
* sef_cb_lu_state_dump *
*===========================================================================*/
PUBLIC void sef_cb_lu_state_dump(int state)
{
/* Load state information. */
load_state_info();
sef_lu_dprint("log: live update state = %d\n", state);
sef_lu_dprint("log: is_read_pending = %d\n", is_read_pending);
sef_lu_dprint("log: is_select_callback_pending = %d\n",
is_select_callback_pending);
sef_lu_dprint("log: SEF_LU_STATE_WORK_FREE(%d) reached = %d\n",
SEF_LU_STATE_WORK_FREE, TRUE);
sef_lu_dprint("log: SEF_LU_STATE_REQUEST_FREE(%d) reached = %d\n",
SEF_LU_STATE_REQUEST_FREE, (!is_read_pending));
sef_lu_dprint("log: SEF_LU_STATE_PROTOCOL_FREE(%d) reached = %d\n",
SEF_LU_STATE_PROTOCOL_FREE, (!is_read_pending
&& !is_select_callback_pending));
sef_lu_dprint("log: LOG_STATE_SELECT_PROTOCOL_FREE(%d) reached = %d\n",
LOG_STATE_SELECT_PROTOCOL_FREE, (!is_select_callback_pending));
}
/*===========================================================================*
* do_sef_lu_before_receive *
*===========================================================================*/
void do_sef_lu_before_receive(void)
{
/* Handle SEF Live update before receive events. */
int r;
/* Initialize on first receive. */
if(!sef_self_first_receive_done) {
sef_lu_state = SEF_LU_STATE_NULL;
}
/* Nothing to do if we are not preparing for a live update. */
if(sef_lu_state == SEF_LU_STATE_NULL) {
return;
}
/* Debug. */
#if SEF_LU_DEBUG
sef_lu_debug_cycle++;
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_debug_end();
#endif
/* Let the callback code handle the event.
* For SEF_LU_STATE_WORK_FREE, we're always ready, tell immediately.
*/
r = OK;
if(sef_lu_state != SEF_LU_STATE_WORK_FREE) {
r = sef_cbs.sef_cb_lu_prepare(sef_lu_state);
}
if(r == OK) {
sef_lu_ready(OK);
}
}
/*===========================================================================*
* sef_cb_lu_state_dump_null *
*===========================================================================*/
void sef_cb_lu_state_dump_null(int UNUSED(state))
{
sef_lu_dprint("NULL\n");
}
