Push u64 -> u32 conversion upstream

Author: mkeeter

app/cosmo/base.toml

@@ -256,7 +256,7 @@ features = ["stm32h753", "usart6", "baud_rate_3M", "hardware_flow_control", "vla
 uses = ["usart6", "dbgmcu"]
 interrupts = {"usart6.irq" = "usart-irq"}
 priority = 9
-max-sizes = {flash = 68672, ram = 65536}
+max-sizes = {flash = 69120, ram = 65536}
 stacksize = 5400
 start = true
 task-slots = ["sys", { cpu_seq = "cosmo_seq" }, "hf", "control_plane_agent", "net", "packrat", "i2c_driver", { spi_driver = "spi2_driver" }, "sprot", "auxflash"]

drv/cosmo-hf/src/apob.rs

@@ -463,16 +463,15 @@ impl ApobState {
     pub(crate) fn begin(
         &mut self,
         drv: &mut FlashDriver,
-        length: u64,
+        length: u32,
         algorithm: ApobHash,
     ) -> Result<(), ApobBeginError> {
         drv.check_flash_mux_state()
             .map_err(|_| ApobBeginError::InvalidState)?;
-        if length > u64::from(APOB_SLOT_SIZE) {
+        if length > APOB_SLOT_SIZE {
             // XXX should this lock the state machine?
             return Err(ApobBeginError::BadDataLength);
         }
-        let length: u32 = length.try_into().unwrap_lite();
         match *self {
             ApobState::Waiting { write_slot, .. } => {
                 *self = ApobState::Ready {
@@ -509,15 +508,15 @@ impl ApobState {
     pub(crate) fn write(
         &mut self,
         drv: &mut FlashDriver,
-        offset: u64,
+        offset: u32,
         data: Leased<R, [u8]>,
     ) -> Result<(), ApobWriteError> {
         // Check that the flash is muxed to the SP
         drv.check_flash_mux_state()
             .map_err(|_| ApobWriteError::InvalidState)?;
 
         // Check that the offset is within the slot
-        if offset > u64::from(APOB_SLOT_SIZE) {
+        if offset > APOB_SLOT_SIZE {
             return Err(ApobWriteError::InvalidOffset);
         }
 
@@ -537,14 +536,11 @@ impl ApobState {
 
         // Check that the end of the data range is within our expected length
         if offset
-            .checked_add(data.len() as u64)
-            .is_none_or(|d| d > u64::from(expected_length))
+            .checked_add(data.len() as u32)
+            .is_none_or(|d| d > expected_length)
         {
             return Err(ApobWriteError::InvalidSize);
         }
-        let Ok(offset) = u32::try_from(offset) else {
-            return Err(ApobWriteError::InvalidSize);
-        };
         let mut out_buf = [0u8; PAGE_SIZE_BYTES];
         let mut scratch_buf = [0u8; PAGE_SIZE_BYTES];
         for i in (0..data.len()).step_by(PAGE_SIZE_BYTES) {
@@ -581,15 +577,15 @@ impl ApobState {
     pub(crate) fn read(
         &mut self,
         drv: &mut FlashDriver,
-        offset: u64,
+        offset: u32,
         data: Leased<W, [u8]>,
     ) -> Result<usize, ApobReadError> {
         // Check that the flash is muxed to the SP
         drv.check_flash_mux_state()
             .map_err(|_| ApobReadError::InvalidState)?;
 
         // Check that the offset is within the slot
-        if offset > u64::from(APOB_SLOT_SIZE) {
+        if offset > APOB_SLOT_SIZE {
             return Err(ApobReadError::InvalidOffset);
         }
 
@@ -603,8 +599,8 @@ impl ApobState {
 
         // Check that the end of the data range is within a slot size
         if offset
-            .checked_add(data.len() as u64)
-            .is_none_or(|d| d > u64::from(APOB_SLOT_SIZE))
+            .checked_add(data.len() as u32)
+            .is_none_or(|d| d > APOB_SLOT_SIZE)
         {
             return Err(ApobReadError::InvalidSize);
         }
@@ -614,7 +610,7 @@ impl ApobState {
             // Read data from the lease into local storage
             let n = (data.len() - i).min(PAGE_SIZE_BYTES);
             let addr = read_slot
-                .flash_addr(u32::try_from(i as u64 + offset).unwrap_lite())
+                .flash_addr(u32::try_from(i as u32 + offset).unwrap_lite())
                 .unwrap_lite();
 
             // Read back the current data, then write it to the lease

drv/cosmo-hf/src/hf.rs

@@ -509,7 +509,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_begin(
         &mut self,
         _: &RecvMessage,
-        length: u64,
+        length: u32,
         algorithm: drv_hf_api::ApobHash,
     ) -> Result<(), RequestError<drv_hf_api::ApobBeginError>> {
         self.apob_state
@@ -520,7 +520,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_write(
         &mut self,
         _: &RecvMessage,
-        offset: u64,
+        offset: u32,
         data: Leased<R, [u8]>,
     ) -> Result<(), RequestError<drv_hf_api::ApobWriteError>> {
         self.apob_state
@@ -540,7 +540,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_read(
         &mut self,
         _: &RecvMessage,
-        offset: u64,
+        offset: u32,
         data: Leased<W, [u8]>,
     ) -> Result<usize, RequestError<drv_hf_api::ApobReadError>> {
         self.apob_state
@@ -967,7 +967,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_begin(
         &mut self,
         _: &RecvMessage,
-        _length: u64,
+        _length: u32,
         _alg: drv_hf_api::ApobHash,
     ) -> Result<(), RequestError<drv_hf_api::ApobBeginError>> {
         Err(drv_hf_api::ApobBeginError::InvalidState.into())
@@ -976,7 +976,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_write(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<R, [u8]>,
     ) -> Result<(), RequestError<drv_hf_api::ApobWriteError>> {
         Err(drv_hf_api::ApobWriteError::InvalidState.into())
@@ -992,7 +992,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_read(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<W, [u8]>,
     ) -> Result<usize, RequestError<drv_hf_api::ApobReadError>> {
         Err(drv_hf_api::ApobReadError::InvalidState.into())

drv/gimlet-hf-server/src/main.rs

@@ -918,7 +918,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_begin(
         &mut self,
         _: &RecvMessage,
-        _length: u64,
+        _length: u32,
         _alg: drv_hf_api::ApobHash,
     ) -> Result<(), RequestError<drv_hf_api::ApobBeginError>> {
         Err(drv_hf_api::ApobBeginError::NotImplemented.into())
@@ -927,7 +927,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_write(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<R, [u8]>,
     ) -> Result<(), RequestError<drv_hf_api::ApobWriteError>> {
         Err(drv_hf_api::ApobWriteError::NotImplemented.into())
@@ -943,7 +943,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_read(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<W, [u8]>,
     ) -> Result<usize, RequestError<drv_hf_api::ApobReadError>> {
         Err(drv_hf_api::ApobReadError::NotImplemented.into())
@@ -1144,7 +1144,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_begin(
         &mut self,
         _: &RecvMessage,
-        _length: u64,
+        _length: u32,
         _alg: drv_hf_api::ApobHash,
     ) -> Result<(), RequestError<drv_hf_api::ApobBeginError>> {
         Err(drv_hf_api::ApobBeginError::NotImplemented.into())
@@ -1153,7 +1153,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_write(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<R, [u8]>,
     ) -> Result<(), RequestError<drv_hf_api::ApobWriteError>> {
         Err(drv_hf_api::ApobWriteError::NotImplemented.into())
@@ -1169,7 +1169,7 @@ impl idl::InOrderHostFlashImpl for FailServer {
     fn apob_read(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<W, [u8]>,
     ) -> Result<usize, RequestError<drv_hf_api::ApobReadError>> {
         Err(drv_hf_api::ApobReadError::NotImplemented.into())

drv/mock-gimlet-hf-server/src/main.rs

@@ -242,7 +242,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_begin(
         &mut self,
         _: &RecvMessage,
-        _length: u64,
+        _length: u32,
         _alg: drv_hf_api::ApobHash,
     ) -> Result<(), RequestError<drv_hf_api::ApobBeginError>> {
         Err(drv_hf_api::ApobBeginError::NotImplemented.into())
@@ -251,7 +251,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_write(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<R, [u8]>,
     ) -> Result<(), RequestError<drv_hf_api::ApobWriteError>> {
         Err(drv_hf_api::ApobWriteError::NotImplemented.into())
@@ -267,7 +267,7 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
     fn apob_read(
         &mut self,
         _: &RecvMessage,
-        _offset: u64,
+        _offset: u32,
         _data: Leased<W, [u8]>,
     ) -> Result<usize, RequestError<drv_hf_api::ApobReadError>> {
         Err(drv_hf_api::ApobReadError::InvalidState.into())

idl/hf.idol

@@ -254,7 +254,7 @@ Interface(
         "apob_begin": (
             description: "begin writing APOB data to bonus flash",
             args: {
-                "length": "u64",
+                "length": "u32",
                 "algorithm": "ApobHash",
             },
             reply: Result(
@@ -267,7 +267,7 @@ Interface(
         "apob_write": (
             description: "writes to the current APOB slot",
             args: {
-                "offset": "u64",
+                "offset": "u32",
             },
             leases: {
                 "data": (type: "[u8]", read: true),
@@ -289,7 +289,7 @@ Interface(
         "apob_read": (
             description: "reads from the current APOB slot",
             args: {
-                "offset": "u64",
+                "offset": "u32",
             },
             leases: {
                 "data": (type: "[u8]", write: true),

task/host-sp-comms/src/main.rs

@@ -146,12 +146,12 @@ enum Trace {
         message: SpToHost,
     },
     ApobWriteError {
-        offset: u64,
+        offset: u32,
         #[count(children)]
         err: drv_hf_api::ApobWriteError,
     },
     ApobReadError {
-        offset: u64,
+        offset: u32,
         #[count(children)]
         err: drv_hf_api::ApobReadError,
     },
@@ -1035,32 +1035,9 @@ impl ServerImpl {
                 }
             }
             HostToSp::ApobBegin { length, algorithm } => {
-                // Decode into internal types, then call into `hf`
-                // XXX should bad hash algorithms or lengths lock the APOB?
-                use drv_hf_api::{ApobBeginError, ApobHash};
-                use host_sp_messages::ApobBeginResult;
-                Some(SpToHost::ApobBegin(match algorithm {
-                    0 => {
-                        if let Ok(d) = data.try_into() {
-                            let hash = ApobHash::Sha256(d);
-                            match self.hf.apob_begin(length, hash) {
-                                Ok(()) => ApobBeginResult::Ok,
-                                Err(ApobBeginError::NotImplemented) => {
-                                    ApobBeginResult::NotImplemented
-                                }
-                                Err(ApobBeginError::InvalidState) => {
-                                    ApobBeginResult::InvalidState
-                                }
-                                Err(ApobBeginError::BadDataLength) => {
-                                    ApobBeginResult::BadDataLength
-                                }
-                            }
-                        } else {
-                            ApobBeginResult::BadHashLength
-                        }
-                    }
-                    _ => ApobBeginResult::InvalidAlgorithm,
-                }))
+                Some(SpToHost::ApobBegin(Self::apob_begin(
+                    &self.hf, length, algorithm, data,
+                )))
             }
             HostToSp::ApobCommit => {
                 // Call into `hf` to do the work here
@@ -1118,6 +1095,43 @@ impl ServerImpl {
         Ok(())
     }
 
+    fn apob_begin(
+        hf: &HostFlash,
+        length: u64,
+        algorithm: u8,
+        data: &[u8],
+    ) -> host_sp_messages::ApobBeginResult {
+        // Decode into internal types, then call into `hf`
+        // XXX should bad hash algorithms or lengths lock the APOB?
+        use drv_hf_api::{ApobBeginError, ApobHash};
+        use host_sp_messages::ApobBeginResult;
+        let Ok(length) = u32::try_from(length) else {
+            return host_sp_messages::ApobBeginResult::BadDataLength;
+        };
+        match algorithm {
+            0 => {
+                if let Ok(d) = data.try_into() {
+                    let hash = ApobHash::Sha256(d);
+                    match hf.apob_begin(length, hash) {
+                        Ok(()) => ApobBeginResult::Ok,
+                        Err(ApobBeginError::NotImplemented) => {
+                            ApobBeginResult::NotImplemented
+                        }
+                        Err(ApobBeginError::InvalidState) => {
+                            ApobBeginResult::InvalidState
+                        }
+                        Err(ApobBeginError::BadDataLength) => {
+                            ApobBeginResult::BadDataLength
+                        }
+                    }
+                } else {
+                    ApobBeginResult::BadHashLength
+                }
+            }
+            _ => ApobBeginResult::InvalidAlgorithm,
+        }
+    }
+
     /// Write data to the bonus region of flash
     ///
     /// This does not take `&self` because we need to force a split borrow
@@ -1128,6 +1142,9 @@ impl ServerImpl {
     ) -> host_sp_messages::ApobDataResult {
         use drv_hf_api::ApobWriteError;
         use host_sp_messages::ApobDataResult;
+        let Ok(offset) = u32::try_from(offset) else {
+            return ApobDataResult::InvalidOffset;
+        };
         match hf.apob_write(offset, data) {
             Ok(()) => ApobDataResult::Ok,
             Err(err) => {
@@ -1162,6 +1179,14 @@ impl ServerImpl {
             );
             return;
         };
+        let Ok(offset) = u32::try_from(offset) else {
+            self.tx_buf.encode_response(
+                sequence,
+                &SpToHost::ApobRead(ApobReadResult::InvalidOffset),
+                |_buf| 0,
+            );
+            return;
+        };
         self.tx_buf.try_encode_response(
             sequence,
             &SpToHost::ApobRead(ApobReadResult::Ok),