From 744d6ae0918c5ae5840b3bb06ec8d632180f41b5 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sun, 9 Jan 2022 14:03:20 +0800 Subject: [PATCH] reduce system workload checking network connection state an activity_interval Arc::AtomicU32 is shared between the connection manager thread and the main net thread. Every time there is a packet received, the activity interval is bumped to 0. If two interval polls pass, then a more expensive wlan_status() call is issued to the COM to see if we're really still connected. On a typcial network, the ARP traffic alone is sufficient to keep the status timeout from happening. The status interval is currently set at slightly over 10 seconds, so if you fall off the network entirely, about 20 seconds will pass before an automatic rejoin is issued. This can be adjusted by tuning the POLL_INTERVAL_MS variable inside the net service's connection_manager.rs module. --- services/net/src/connection_manager.rs | 99 ++++++++++++++++++++++++++ services/net/src/main.rs | 4 +- 2 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 services/net/src/connection_manager.rs diff --git a/services/net/src/connection_manager.rs b/services/net/src/connection_manager.rs new file mode 100644 index 000000000..65ce87e72 --- /dev/null +++ b/services/net/src/connection_manager.rs @@ -0,0 +1,99 @@ +use crate::api::*; +use std::sync::Arc; +use core::sync::atomic::{AtomicU32, Ordering}; +use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack, send_message, Message}; +use num_traits::*; +use std::io::Read; + +#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)] +pub(crate) enum ConnectionManagerOpcode { + Run, + Poll, + Stop, + Quit, +} +#[allow(dead_code)] +const POLL_INTERVAL_MS: usize = 10_151; // stagger slightly off of an integer-seconds interval to even out loads + +pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc) { + let tt = ticktimer_server::Ticktimer::new().unwrap(); + let xns = xous_names::XousNames::new().unwrap(); + let mut com = com::Com::new(&xns).unwrap(); + let mut pddb = pddb::Pddb::new(); + let self_cid = xous::connect(sid).unwrap(); + // give the system some time to boot before trying to run this + tt.sleep_ms(POLL_INTERVAL_MS).unwrap(); + + let mut run = true; + send_message(self_cid, Message::new_scalar(ConnectionManagerOpcode::Poll.to_usize().unwrap(), POLL_INTERVAL_MS, 0, 0, 0)).expect("couldn't kick off next poll"); + loop { + let msg = xous::receive_message(sid).unwrap(); + log::debug!("got msg: {:?}", msg); + match FromPrimitive::from_usize(msg.body.id()) { + Some(ConnectionManagerOpcode::Run) => msg_scalar_unpack!(msg, poll_interval, _, _, _, { + if !run { + run = true; + send_message(self_cid, Message::new_scalar(ConnectionManagerOpcode::Poll.to_usize().unwrap(), poll_interval, 0, 0, 0)).expect("couldn't kick off next poll"); + } + }), + Some(ConnectionManagerOpcode::Poll) => msg_scalar_unpack!(msg, next_poll, _, _, _, { + if activity_interval.fetch_add(POLL_INTERVAL_MS as u32, Ordering::SeqCst) > POLL_INTERVAL_MS as u32 { + log::info!("wlan activity interval timeout"); + // if the pddb isn't mounted, don't even bother checking -- we can't connect until we have a place to get keys + if pddb.is_mounted() { + // the status check code is going to get refactored, so this is a "bare minimum" check + let status = com.wlan_status().unwrap(); + if status.contains("down") { + log::info!("wlan is not connected, attempting auto-reconnect to known AP list"); + if let Ok(ap_list) = pddb.list_keys(AP_DICT_NAME, None) { + com.wlan_leave().expect("couldn't issue leave command"); // leave the previous config to reset state + // TODO: add an SSID scan phase, so we only try to connect to SSIDs that are currently visible. + // for now, just try every single one as a brute force approach. + for ap in ap_list { + let mut wpa_pw_file = pddb.get(AP_DICT_NAME, &ap, None, false, false, None, Some(||{})).expect("couldn't retrieve AP password"); + let mut wp_pw_raw = [0u8; com::api::WF200_PASS_MAX_LEN]; + if let Ok(readlen) = wpa_pw_file.read(&mut wp_pw_raw) { + let pw = std::str::from_utf8(&wp_pw_raw[..readlen]).expect("password was not valid utf-8"); + com.wlan_set_ssid(&ap).expect("couldn't set SSID"); + com.wlan_set_pass(pw).expect("couldn't set password"); + com.wlan_join().expect("couldn't issue join command"); + } + // this needs to not be a dead-wait loop, but for now the WLAN API doesn't support anything better + tt.sleep_ms(5_000).unwrap(); + if !com.wlan_status().unwrap().contains("down") { + break; + } + } + } else { + log::warn!("Connection manager couldn't access {}, but continuing to poll.", AP_DICT_NAME); + } + } else { + // we're up, reset the interval + activity_interval.store(0, Ordering::SeqCst); + } + } + } + if run { + tt.sleep_ms(next_poll).unwrap(); + send_message(self_cid, Message::new_scalar(ConnectionManagerOpcode::Poll.to_usize().unwrap(), next_poll, 0, 0, 0)).expect("couldn't kick off next poll"); + } + }), + // stop is blocking because we need to ensure the previous poll has finished before moving on, otherwise, + // we could get a double-run condition + Some(ConnectionManagerOpcode::Stop) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { + run = false; + xous::return_scalar(msg.sender, 0).expect("couldn't ack stop"); + }), + Some(ConnectionManagerOpcode::Quit) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { + xous::return_scalar(msg.sender, 0).unwrap(); + log::warn!("exiting connection manager"); + break; + }), + None => { + log::error!("couldn't convert opcode: {:?}", msg); + } + } + } + unsafe{xous::disconnect(self_cid).ok()}; + xous::destroy_server(sid).unwrap(); +} \ No newline at end of file diff --git a/services/net/src/main.rs b/services/net/src/main.rs index 3d49ea1ec..eb6bbedfc 100644 --- a/services/net/src/main.rs +++ b/services/net/src/main.rs @@ -188,8 +188,9 @@ fn xmain() -> ! { let cm_cid = xous::connect(cm_sid).unwrap(); let activity_interval = Arc::new(AtomicU32::new(0)); thread::spawn({ + let activity_interval = activity_interval.clone(); move || { - connection_manager::connection_manager(cm_sid, activity_interval.clone()); + connection_manager::connection_manager(cm_sid, activity_interval); } }); @@ -623,6 +624,7 @@ fn xmain() -> ! { } }, ComIntSources::WlanRxReady => { + activity_interval.store(0, Ordering::Relaxed); // reset the activity interval to 0 if let Some(_config) = net_config { if let Some(rxlen) = maybe_rxlen { match iface.device_mut().push_rx_avail(rxlen) {