add sequencing to suspend/resume order of operations

this is necessary because we want to make sure that the SPINOR
service does not shut down before the PDDB service finishes syncing
its disks.
This commit is contained in:
bunnie 2022-01-10 13:45:56 +08:00
parent b3b6a9e8ec
commit c5fe1bc99b
17 changed files with 82 additions and 27 deletions

View file

@ -39,7 +39,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(codec_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
/*
let trng = trng::Trng::new(&xns).unwrap();
let mut noise: [u32; codec::FIFO_DEPTH] = [0; codec::FIFO_DEPTH];

View file

@ -342,7 +342,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(com_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
// create an array to track return connections for battery stats
let mut battstats_conns: [Option<xous::CID>; 32] = [None; 32];

View file

@ -749,7 +749,7 @@ fn susres_thread(engine_arg: usize) {
// register a suspend/resume listener
let sr_cid = xous::connect(susres_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::SusResOps::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::SusResOps::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
log::trace!("starting engine25519 suspend/resume manager loop");
loop {

View file

@ -278,7 +278,7 @@ fn susres_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
// register a suspend/resume listener
let sr_cid = xous::connect(susres_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::SusResOps::SuspendResume as u32, sr_cid)
let mut susres = susres::Susres::new(None, &xns, api::SusResOps::SuspendResume as u32, sr_cid)
.expect("couldn't create suspend/resume object");
log::trace!("starting Sha512 suspend/resume manager loop");

View file

@ -133,7 +133,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, Opcode::SuspendResume as u32, sr_cid)
let mut susres = susres::Susres::new(None, &xns, Opcode::SuspendResume as u32, sr_cid)
.expect("couldn't create suspend/resume object");
let mut bulkread = BulkRead::default(); // holding buffer for bulk reads; wastes ~8k when not in use, but saves a lot of copy/init for each iteration of the read

View file

@ -833,7 +833,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let self_cid = xous::connect(kbd_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, Opcode::SuspendResume as u32, self_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, Opcode::SuspendResume as u32, self_cid).expect("couldn't create suspend/resume object");
// start a thread that can ping the keyboard loop when a key is held down
let ticktimer = ticktimer_server::Ticktimer::new().unwrap();

View file

@ -606,7 +606,7 @@ fn i2c_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
// register a suspend/resume listener
let sr_cid = xous::connect(i2c_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, I2cOpcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, I2cOpcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut suspend_pending_token: Option<usize> = None;
log::trace!("starting i2c main loop");
@ -724,7 +724,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(llio_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut latest_activity = 0;
let mut usb_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];

View file

@ -181,7 +181,7 @@ fn xmain() -> ! {
log::trace!("ready to accept requests");
// register a suspend/resume listener
let sr_cid = xous::connect(net_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
// kick off the connection manager thread
let cm_sid = xous::create_server().expect("couldn't create connection manager server");

View file

@ -467,7 +467,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(pddb_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
loop {
let mut msg = xous::receive_message(pddb_sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {

View file

@ -284,7 +284,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let main_cid = xous::connect(keys_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, main_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, main_cid).expect("couldn't create suspend/resume object");
// create a policy menu object
let mut policy_menu = gam::menu::Menu::new(crate::ROOTKEY_MENU_NAME);

View file

@ -95,7 +95,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(codec_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
loop {
let msg = xous::receive_message(codec_sid).unwrap();

View file

@ -553,7 +553,7 @@ fn susres_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
// register a suspend/resume listener
let sr_cid = xous::connect(susres_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::SusResOps::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let mut susres = susres::Susres::new(Some(susres::SuspendOrder::Last), &xns, api::SusResOps::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
let main_cid = xns.request_connection_blocking(api::SERVER_NAME_SPINOR).expect("couldn't connect to our main thread for susres coordination");

View file

@ -6,6 +6,29 @@ use utralib::generated::*;
pub(crate) const SERVER_NAME_SUSRES: &str = "_Suspend/resume manager_";
pub(crate) const SERVER_NAME_EXEC_GATE: &str = "_Suspend/resume execution gate_";
/// Note: there must be at least one subscriber to the `Last` suspend order event, otherwise
/// the logic will never terminate. There may be multiple `Last` subscribers, but the order at
/// which they finish would be indeterminate. Currently, the `Last` subscriber is the `spinor`
/// block, which is last because you want to make sure all the PDDB commits and other saved
/// data are flushed before turning off access to the SPINOR.
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone, PartialEq, Eq)]
pub enum SuspendOrder {
Early,
Normal,
Late,
Last,
}
impl SuspendOrder {
pub fn next(&self) -> SuspendOrder {
match self {
SuspendOrder::Early => SuspendOrder::Normal,
SuspendOrder::Normal => SuspendOrder::Late,
SuspendOrder::Late => SuspendOrder::Last,
SuspendOrder::Last => SuspendOrder::Last,
}
}
}
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
/// requests a suspend
@ -45,6 +68,7 @@ pub(crate) struct ScalarHook {
pub sid: (u32, u32, u32, u32),
pub id: u32, // ID of the scalar message to send through (e.g. the discriminant of the Enum on the caller's side API)
pub cid: xous::CID, // caller-side connection ID for the scalar message to route to. Created by the caller before hooking.
pub order: SuspendOrder,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]

View file

@ -18,7 +18,7 @@ pub struct Susres {
}
impl Susres {
#[cfg(any(target_os = "none", target_os = "xous"))]
pub fn new(xns: &xous_names::XousNames, cb_discriminant: u32, cid: CID) -> Result<Self, xous::Error> {
pub fn new(order: Option<SuspendOrder>, xns: &xous_names::XousNames, cb_discriminant: u32, cid: CID) -> Result<Self, xous::Error> {
REFCOUNT.store(REFCOUNT.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
let conn = xns.request_connection_blocking(api::SERVER_NAME_SUSRES).expect("Can't connect to SUSRES");
let execution_gate_conn = xns.request_connection_blocking(api::SERVER_NAME_EXEC_GATE).expect("Can't connect to the execution gate");
@ -30,6 +30,7 @@ impl Susres {
sid: sid_tuple,
id: cb_discriminant,
cid,
order: order.unwrap_or(SuspendOrder::Normal),
};
let buf = Buffer::into_buf(hookdata).or(Err(xous::Error::InternalError))?;
buf.lend(conn, Opcode::SuspendEventSubscribe.to_u32().unwrap())?;

View file

@ -459,6 +459,7 @@ struct ScalarCallback {
ready_to_suspend: bool,
token: u32,
failed_to_suspend: bool,
order: crate::api::SuspendOrder,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
@ -598,6 +599,7 @@ fn xmain() -> ! {
let mut allow_suspend = true;
let mut suspend_subscribers: [Option<ScalarCallback>; 32] = [None; 32];
let mut current_op_order = crate::api::SuspendOrder::Early;
loop {
let msg = xous::receive_message(susres_sid).unwrap();
if reboot_requested {
@ -648,14 +650,17 @@ fn xmain() -> ! {
let mut all_ready = true;
for maybe_sub in suspend_subscribers.iter() {
if let Some(sub) = maybe_sub {
if sub.ready_to_suspend == false {
log::trace!("not ready: {}", sub.token);
all_ready = false;
break;
if sub.order == current_op_order {
if sub.ready_to_suspend == false {
log::trace!("not ready: {}", sub.token);
all_ready = false;
break;
}
}
};
}
if all_ready {
// note: we must have at least one `Last` subscriber for this logic to work!
if all_ready && current_op_order == crate::api::SuspendOrder::Last {
log::trace!("all callbacks reporting in, doing suspend");
timeout_pending = false;
//susres_hw.debug_delay(500);
@ -670,6 +675,17 @@ fn xmain() -> ! {
log::trace!("low-level resume done, restoring execution");
RESUME_EXEC.store(true, Ordering::Relaxed);
susres_hw.restore_wfi();
} else if all_ready {
// the current order is finished, send the next tranche
current_op_order = current_op_order.next();
let mut at_least_one_event_sent = false;
while !at_least_one_event_sent {
let (send_success, next_op_order) = send_event(&suspend_subscribers, current_op_order);
if !send_success {
current_op_order = next_op_order;
}
at_least_one_event_sent = send_success;
}
} else {
log::trace!("still waiting on callbacks, returning to main loop");
}
@ -699,7 +715,15 @@ fn xmain() -> ! {
Message::new_scalar(TimeoutOpcode::Run.to_usize().unwrap(), 0, 0, 0, 0)
).expect("couldn't initiate timeout before suspend!");
send_event(&suspend_subscribers);
current_op_order = crate::api::SuspendOrder::Early;
let mut at_least_one_event_sent = false;
while !at_least_one_event_sent {
let (send_success, next_op_order) = send_event(&suspend_subscribers, current_op_order);
if !send_success {
current_op_order = next_op_order;
}
at_least_one_event_sent = send_success;
}
} else {
log::warn!("suspend requested, but the system was not allowed to suspend. Ignoring request.")
}
@ -781,6 +805,7 @@ fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
ready_to_suspend: false,
token: 0,
failed_to_suspend: false,
order: hookdata.order,
};
for i in 0..cb_conns.len() {
if cb_conns[i].is_none() {
@ -802,13 +827,18 @@ fn unhook(cb_conns: &mut [Option<ScalarCallback>; 32]) {
*entry = None;
}
}
fn send_event(cb_conns: &[Option<ScalarCallback>; 32]) {
fn send_event(cb_conns: &[Option<ScalarCallback>; 32], order: crate::api::SuspendOrder) -> (bool, crate::api::SuspendOrder) {
let mut at_least_one_event_sent = false;
for entry in cb_conns.iter() {
if let Some(scb) = entry {
xous::send_message(scb.server_to_cb_cid,
xous::Message::new_scalar(SuspendEventCallback::Event.to_usize().unwrap(),
scb.cb_to_client_cid as usize, scb.cb_to_client_id as usize, scb.token as usize, 0)
).unwrap();
if scb.order == order {
at_least_one_event_sent = true;
xous::send_message(scb.server_to_cb_cid,
xous::Message::new_scalar(SuspendEventCallback::Event.to_usize().unwrap(),
scb.cb_to_client_cid as usize, scb.cb_to_client_id as usize, scb.token as usize, 0)
).unwrap();
}
};
}
(at_least_one_event_sent, order.next())
}

View file

@ -487,7 +487,7 @@ fn xmain() -> ! {
let xns = xous_names::XousNames::new().unwrap();
let sr_cid =
xous::connect(ticktimer_server).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid)
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid)
.expect("couldn't create suspend/resume object");
loop {

View file

@ -786,7 +786,7 @@ fn xmain() -> ! {
// register a suspend/resume listener
let sr_cid = xous::connect(trng_sid).expect("couldn't create suspend callback connection");
let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid)
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid)
.expect("couldn't create suspend/resume object");
let mut error_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];