Merge branch 'sd-yield'

Author: benma

src/rust/bitbox02-rust/src/backup.rs

@@ -158,18 +158,18 @@ fn bitwise_recovery(buf1: &[u8], buf2: &[u8], buf3: &[u8]) -> Result<Zeroizing<V
     Ok(recovered_contents)
 }
 
-pub fn load(
+pub async fn load(
     hal: &mut impl crate::hal::Hal,
     dir: &str,
 ) -> Result<(Zeroizing<BackupData>, pb_backup::BackupMetaData), ()> {
-    let files = hal.sd().list_subdir(Some(dir))?;
+    let files = hal.sd().list_subdir(Some(dir)).await?;
     if files.len() != 3 {
         return Err(());
     }
     let file_contents: [Zeroizing<Vec<u8>>; 3] = [
-        hal.sd().load_bin(&files[0], dir)?,
-        hal.sd().load_bin(&files[1], dir)?,
-        hal.sd().load_bin(&files[2], dir)?,
+        hal.sd().load_bin(&files[0], dir).await?,
+        hal.sd().load_bin(&files[1], dir).await?,
+        hal.sd().load_bin(&files[2], dir).await?,
     ];
     for contents in file_contents.iter() {
         if let o @ Ok(_) = load_from_buffer(contents) {
@@ -186,7 +186,7 @@ pub fn load(
     )?)
 }
 
-pub fn create(
+pub async fn create(
     hal: &mut impl crate::hal::Hal,
     seed: &[u8],
     name: &str,
@@ -232,7 +232,11 @@ pub fn create(
     };
     let backup_encoded = backup.encode_to_vec();
     let dir = id(seed);
-    let files = hal.sd().list_subdir(Some(&dir)).or(Err(Error::SdList))?;
+    let files = hal
+        .sd()
+        .list_subdir(Some(&dir))
+        .await
+        .or(Err(Error::SdList))?;
 
     let filename_datetime = {
         let tm = bitbox02::get_datetime(backup_create_timestamp).map_err(|_| Error::Generic)?;
@@ -255,10 +259,12 @@ pub fn create(
         }
         hal.sd()
             .write_bin(&filename, &dir, &backup_encoded)
+            .await
             .or(Err(Error::SdWrite))?;
         if hal
             .sd()
             .load_bin(&filename, &dir)
+            .await
             .or(Err(Error::SdRead))?
             .as_slice()
             != backup_encoded.as_slice()
@@ -268,7 +274,7 @@ pub fn create(
     }
     let mut stale = false;
     for file in files {
-        if hal.sd().erase_file_in_subdir(&file, &dir).is_err() {
+        if hal.sd().erase_file_in_subdir(&file, &dir).await.is_err() {
             stale = true
         }
     }
@@ -285,6 +291,8 @@ mod tests {
     use crate::hal::testing::TestingHal;
     use core::convert::TryInto;
 
+    use util::bb02_async::block_on;
+
     #[test]
     fn test_id() {
         // Seeds of different lengths (16, 24, 32 bytes)
@@ -307,11 +315,23 @@ mod tests {
         let mut mock_hal = TestingHal::new();
         let timestamp = 1601281809;
         let birthdate = timestamp - 32400;
-        assert!(create(&mut mock_hal, seed, "test name", timestamp, birthdate).is_ok());
+        assert!(
+            block_on(create(
+                &mut mock_hal,
+                seed,
+                "test name",
+                timestamp,
+                birthdate
+            ))
+            .is_ok()
+        );
         let dir = id(seed);
-        assert_eq!(mock_hal.sd.list_subdir(None), Ok(vec![dir.clone()]));
         assert_eq!(
-            mock_hal.sd.list_subdir(Some(&dir)),
+            block_on(mock_hal.sd.list_subdir(None)),
+            Ok(vec![dir.clone()])
+        );
+        assert_eq!(
+            block_on(mock_hal.sd.list_subdir(Some(&dir))),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-09Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_1.bin".into(),
@@ -320,42 +340,59 @@ mod tests {
         );
 
         // Recreating using same timestamp is not allowed and doesn't change the backups.
-        assert!(create(&mut mock_hal, seed, "new name", timestamp, birthdate).is_err());
+        assert!(
+            block_on(create(
+                &mut mock_hal,
+                seed,
+                "new name",
+                timestamp,
+                birthdate
+            ))
+            .is_err()
+        );
         assert_eq!(
-            mock_hal.sd.list_subdir(Some(&dir)),
+            block_on(mock_hal.sd.list_subdir(Some(&dir))),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-09Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_1.bin".into(),
                 "backup_Mon_2020-09-28T08-30-09Z_2.bin".into()
             ])
         );
 
-        let contents: [zeroize::Zeroizing<Vec<u8>>; 3] = mock_hal
-            .sd
-            .list_subdir(Some(&dir))
-            .unwrap()
-            .iter()
-            .map(|file| mock_hal.sd.load_bin(file, &dir).unwrap())
-            .collect::<Vec<_>>()
-            .try_into()
-            .unwrap();
+        let contents: [zeroize::Zeroizing<Vec<u8>>; 3] =
+            block_on(mock_hal.sd.list_subdir(Some(&dir)))
+                .unwrap()
+                .iter()
+                .map(|file| block_on(mock_hal.sd.load_bin(file, &dir)).unwrap())
+                .collect::<Vec<_>>()
+                .try_into()
+                .unwrap();
         assert!(
             contents[0].as_slice() == contents[1].as_slice()
                 && contents[0].as_slice() == contents[2].as_slice()
         );
 
         // Recreating the backup removes the previous files.
-        assert!(create(&mut mock_hal, seed, "new name", timestamp + 1, birthdate).is_ok());
+        assert!(
+            block_on(create(
+                &mut mock_hal,
+                seed,
+                "new name",
+                timestamp + 1,
+                birthdate
+            ))
+            .is_ok()
+        );
         assert_eq!(
-            mock_hal.sd.list_subdir(Some(&dir)),
+            block_on(mock_hal.sd.list_subdir(Some(&dir))),
             Ok(vec![
                 "backup_Mon_2020-09-28T08-30-10Z_0.bin".into(),
                 "backup_Mon_2020-09-28T08-30-10Z_1.bin".into(),
                 "backup_Mon_2020-09-28T08-30-10Z_2.bin".into()
             ])
         );
 
-        let (backup_data, metadata) = load(&mut mock_hal, &dir).unwrap();
+        let (backup_data, metadata) = block_on(load(&mut mock_hal, &dir)).unwrap();
         assert_eq!(backup_data.get_seed(), seed);
         assert_eq!(backup_data.0.birthdate, birthdate);
         assert_eq!(metadata.name.as_str(), "new name");

src/rust/bitbox02-rust/src/hal.rs

@@ -18,12 +18,19 @@ pub use crate::workflow::Workflows as Ui;
 use alloc::string::String;
 use alloc::vec::Vec;
 
+use futures_lite::future::yield_now;
+
+#[allow(async_fn_in_trait)]
 pub trait Sd {
-    fn sdcard_inserted(&mut self) -> bool;
-    fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()>;
-    fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()>;
-    fn load_bin(&mut self, filename: &str, dir: &str) -> Result<zeroize::Zeroizing<Vec<u8>>, ()>;
-    fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()>;
+    async fn sdcard_inserted(&mut self) -> bool;
+    async fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()>;
+    async fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()>;
+    async fn load_bin(
+        &mut self,
+        filename: &str,
+        dir: &str,
+    ) -> Result<zeroize::Zeroizing<Vec<u8>>, ()>;
+    async fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()>;
 }
 
 /// Hardware abstraction layer for BitBox devices.
@@ -36,28 +43,42 @@ pub struct BitBox02Sd;
 
 impl Sd for BitBox02Sd {
     #[inline(always)]
-    fn sdcard_inserted(&mut self) -> bool {
-        bitbox02::sd::sdcard_inserted()
+    async fn sdcard_inserted(&mut self) -> bool {
+        let result = bitbox02::sd::sdcard_inserted();
+        yield_now().await;
+        result
     }
 
     #[inline(always)]
-    fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
-        bitbox02::sd::list_subdir(subdir)
+    async fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
+        let result = bitbox02::sd::list_subdir(subdir);
+        yield_now().await;
+        result
     }
 
     #[inline(always)]
-    fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
-        bitbox02::sd::erase_file_in_subdir(filename, dir)
+    async fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
+        let result = bitbox02::sd::erase_file_in_subdir(filename, dir);
+        yield_now().await;
+        result
     }
 
     #[inline(always)]
-    fn load_bin(&mut self, filename: &str, dir: &str) -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
-        bitbox02::sd::load_bin(filename, dir)
+    async fn load_bin(
+        &mut self,
+        filename: &str,
+        dir: &str,
+    ) -> Result<zeroize::Zeroizing<Vec<u8>>, ()> {
+        let result = bitbox02::sd::load_bin(filename, dir);
+        yield_now().await;
+        result
     }
 
     #[inline(always)]
-    fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
-        bitbox02::sd::write_bin(filename, dir, data)
+    async fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
+        let result = bitbox02::sd::write_bin(filename, dir, data);
+        yield_now().await;
+        result
     }
 }
 
@@ -105,11 +126,11 @@ pub mod testing {
     }
 
     impl super::Sd for TestingSd {
-        fn sdcard_inserted(&mut self) -> bool {
+        async fn sdcard_inserted(&mut self) -> bool {
             self.inserted.unwrap()
         }
 
-        fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
+        async fn list_subdir(&mut self, subdir: Option<&str>) -> Result<Vec<String>, ()> {
             match subdir {
                 Some(key) => Ok(self
                     .files
@@ -120,14 +141,14 @@ pub mod testing {
             }
         }
 
-        fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
+        async fn erase_file_in_subdir(&mut self, filename: &str, dir: &str) -> Result<(), ()> {
             self.files
                 .get_mut(dir)
                 .and_then(|files| files.remove(filename).map(|_| ()))
                 .ok_or(())
         }
 
-        fn load_bin(
+        async fn load_bin(
             &mut self,
             filename: &str,
             dir: &str,
@@ -139,7 +160,7 @@ pub mod testing {
                 .ok_or(())
         }
 
-        fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
+        async fn write_bin(&mut self, filename: &str, dir: &str, data: &[u8]) -> Result<(), ()> {
             self.files
                 .entry(dir.into())
                 .or_default()
@@ -176,29 +197,38 @@ pub mod testing {
         use super::*;
         use crate::hal::Sd;
 
+        use util::bb02_async::block_on;
+
         // Quick check if our mock TestingSd implementation makes sense.
         #[test]
         fn test_sd_list_write_read_erase() {
             let mut sd = TestingSd::new();
-            assert_eq!(sd.list_subdir(None), Ok(vec![]));
-            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec![]));
+            assert_eq!(block_on(sd.list_subdir(None)), Ok(vec![]));
+            assert_eq!(block_on(sd.list_subdir(Some("dir1"))), Ok(vec![]));
 
-            assert!(sd.load_bin("file1.txt", "dir1").is_err());
-            assert!(sd.write_bin("file1.txt", "dir1", b"data").is_ok());
-            assert_eq!(sd.list_subdir(None), Ok(vec!["dir1".into()]));
-            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec!["file1.txt".into()]));
+            assert!(block_on(sd.load_bin("file1.txt", "dir1")).is_err());
+            assert!(block_on(sd.write_bin("file1.txt", "dir1", b"data")).is_ok());
+            assert_eq!(block_on(sd.list_subdir(None)), Ok(vec!["dir1".into()]));
+            assert_eq!(
+                block_on(sd.list_subdir(Some("dir1"))),
+                Ok(vec!["file1.txt".into()])
+            );
             assert_eq!(
-                sd.load_bin("file1.txt", "dir1").unwrap().as_slice(),
+                block_on(sd.load_bin("file1.txt", "dir1"))
+                    .unwrap()
+                    .as_slice(),
                 b"data"
             );
-            assert!(sd.write_bin("file1.txt", "dir1", b"replaced data").is_ok());
+            assert!(block_on(sd.write_bin("file1.txt", "dir1", b"replaced data")).is_ok());
             assert_eq!(
-                sd.load_bin("file1.txt", "dir1").unwrap().as_slice(),
+                block_on(sd.load_bin("file1.txt", "dir1"))
+                    .unwrap()
+                    .as_slice(),
                 b"replaced data"
             );
-            assert!(sd.erase_file_in_subdir("doesnt-exist.txt", "dir1").is_err());
-            assert!(sd.erase_file_in_subdir("file1.txt", "dir1").is_ok());
-            assert_eq!(sd.list_subdir(Some("dir1")), Ok(vec![]));
+            assert!(block_on(sd.erase_file_in_subdir("doesnt-exist.txt", "dir1")).is_err());
+            assert!(block_on(sd.erase_file_in_subdir("file1.txt", "dir1")).is_ok());
+            assert_eq!(block_on(sd.list_subdir(Some("dir1"))), Ok(vec![]));
         }
     }
 }

src/rust/bitbox02-rust/src/hww/api.rs

@@ -172,9 +172,9 @@ async fn process_api(hal: &mut impl crate::hal::Hal, request: &Request) -> Resul
             set_mnemonic_passphrase_enabled::process(hal, request).await
         }
         Request::InsertRemoveSdcard(request) => sdcard::process(hal, request).await,
-        Request::ListBackups(_) => backup::list(hal),
+        Request::ListBackups(_) => backup::list(hal).await,
         Request::CheckSdcard(_) => Ok(Response::CheckSdcard(pb::CheckSdCardResponse {
-            inserted: hal.sd().sdcard_inserted(),
+            inserted: hal.sd().sdcard_inserted().await,
         })),
         Request::CheckBackup(request) => backup::check(hal, request).await,
         Request::CreateBackup(request) => backup::create(hal, request).await,