mctp-estack: Make buffer sizes configurable

These can be set by environment variables at build time,
documented in mctp_estack::config

Some other limits have been increased.

Signed-off-by: Matt Johnston <[email protected]>

Author: mkj

mctp-estack/src/fragment.rs

@@ -10,7 +10,7 @@ use crate::fmt::{debug, error, info, trace, warn};
 
 use mctp::{Eid, Error, MsgType, Result, Tag, MCTP_HEADER_VERSION_1};
 
-use crate::{AppCookie, Header, HEADER_LEN};
+use crate::{AppCookie, Header, HEADER_LEN, MAX_MTU};
 
 #[derive(Debug)]
 pub struct Fragmenter {
@@ -47,6 +47,11 @@ impl Fragmenter {
         debug_assert!(typ.0 & 0x80 == 0, "IC bit's set in typ");
         debug_assert!(initial_seq & !mctp::MCTP_SEQ_MASK == 0);
         if mtu < HEADER_LEN+1 {
+            debug!("mtu too small");
+            return Err(Error::BadArgument);
+        }
+        if mtu > MAX_MTU {
+            debug!("mtu too large");
             return Err(Error::BadArgument);
         }
         // TODO other validity checks

mctp-estack/src/i2c.rs

@@ -10,6 +10,7 @@ use crate::fmt::{debug, error, info, trace, warn};
 
 use crate::{
     AppCookie, Fragmenter, MctpMessage, ReceiveHandle, SendOutput, Stack,
+    MAX_PAYLOAD,
 };
 use mctp::{Eid, Error, MsgType, Result, Tag};
 
@@ -21,15 +22,6 @@ const MCTP_I2C_HEADER: usize = 4;
 // bytecount is limited to u8, includes MCTP payload + 1 byte i2c source
 pub const MCTP_I2C_MAXMTU: usize = u8::MAX as usize - 1;
 
-/// Size of fixed transmit buffer. This is the maximum size of a MCTP message.
-///
-/// *TODO:* This will be replaced with a dynamically sized `send_message` buffer
-/// passed in.
-///
-/// Requires finding a replacement for `Vec` in `fill_msg` for `send_enqueue()`.
-/// Maybe heapless::VecView once it's in a release.
-pub const SENDBUF: usize = 1024;
-
 type MctpI2cHeader =
     libmctp::smbus_proto::MCTPSMBusHeader<[u8; MCTP_I2C_HEADER]>;
 
@@ -180,9 +172,7 @@ impl MctpI2cEncap {
 pub struct MctpI2cHandler {
     encap: MctpI2cEncap,
 
-    // TODO: replace with a &[u8] or similar so that we can avoid
-    // the const SENDBUF.
-    send_message: &'static mut Vec<u8, SENDBUF>,
+    send_message: &'static mut Vec<u8, MAX_PAYLOAD>,
     send_state: HandlerSendState,
 }
 
@@ -202,7 +192,7 @@ impl MctpI2cHandler {
     /// [`mctp_estack::Vec`](crate::Vec) can be used for API compatibility.
     pub fn new(
         own_addr: u8,
-        send_message: &'static mut Vec<u8, SENDBUF>,
+        send_message: &'static mut Vec<u8, MAX_PAYLOAD>,
     ) -> Self {
         Self {
             encap: MctpI2cEncap::new(own_addr),
@@ -300,7 +290,7 @@ impl MctpI2cHandler {
         fill_msg: F,
     ) -> Result<()>
     where
-        F: FnOnce(&mut Vec<u8, SENDBUF>) -> Option<()>,
+        F: FnOnce(&mut Vec<u8, MAX_PAYLOAD>) -> Option<()>,
     {
         if !self.is_send_idle() {
             return Err(Error::Other);

mctp-estack/src/lib.rs

@@ -17,6 +17,11 @@
 //! Applications can create [`router::RouterAsyncListener`] and [`router::RouterAsyncReqChannel`]
 //! instances to communicate over MCTP. Those implement the standard [`mctp` crate](mctp)
 //! async traits.
+//!
+//! ## Configuration
+//!
+//! `mctp-estack` uses fixed sizes to be suitable on no-alloc platforms.
+//! These can be configured at build time, see [`config`]
 
 #![cfg_attr(not(any(feature = "std", test)), no_std)]
 #![forbid(unsafe_code)]
@@ -33,6 +38,7 @@ use mctp::{Eid, MsgType, TagValue, Tag, Error, Result};
 
 mod fragment;
 mod reassemble;
+mod util;
 pub mod i2c;
 pub mod serial;
 pub mod usb;
@@ -44,11 +50,8 @@ use reassemble::Reassembler;
 pub use router::Router;
 
 use crate::fmt::*;
+pub(crate) use config::*;
 
-const FLOWS: usize = 8;
-
-const NUM_RECEIVE: usize = 4;
-const RECV_PAYLOAD: usize = 1032;
 
 /// Timeout for message reassembly.
 ///
@@ -68,6 +71,50 @@ pub const DEFERRED_TIMEOUT: u32 = 6000;
 /// See [`Stack::update()`].
 pub const TIMEOUT_INTERVAL: u32 = 100;
 
+pub(crate) const HEADER_LEN: usize = 4;
+
+/// Build-time configuration and defaults
+///
+/// To set a non-default value, set the `MCTP_ESTACK_...` environment variable
+/// during the build. Those variables can be set in the `[env]`
+/// section of `.cargo/config.toml`.
+pub mod config {
+    use crate::get_build_var;
+
+    /// Maximum size of a MCTP message payload in bytes, default 1032
+    ///
+    /// This does not include the MCTP type byte.
+    ///
+    /// Customise with `MCTP_ESTACK_MAX_MESSAGE` environment variable.
+    pub const MAX_PAYLOAD: usize = get_build_var!("MCTP_ESTACK_MAX_MESSAGE", 1032);
+
+    /// Number of concurrent receive messages, default 4
+    ///
+    /// The number of in-progress message reassemblies is limited to `NUM_RECEIVE`.
+    /// Total memory used for reassembly buffers is roughly
+    /// `MAX_PAYLOAD` * `NUM_RECEIVE` bytes.
+    ///
+    /// Customise with `MCTP_ESTACK_NUM_RECEIVE` environment variable.
+    /// Number of outstanding waiting responses, default 64
+    pub const NUM_RECEIVE: usize = get_build_var!("MCTP_ESTACK_NUM_RECEIVE", 4);
+    ///
+    /// After a message is sent with Tag Owner (TO) bit set, the stack will accept
+    /// response messages with the same tag and TO _unset_. `FLOWS` defines
+    /// the number of slots available for pending responses.
+    ///
+    /// Customise with `MCTP_ESTACK_FLOWS` environment variable.
+    /// Must be a power of two.
+    pub const FLOWS: usize = get_build_var!("MCTP_ESTACK_FLOWS", 64);
+
+    /// Maximum allowed MTU, default 255
+    ///
+    /// The largest MTU allowed for any link.
+    ///
+    /// Customise with `MCTP_ESTACK_MAX_MTU` environment variable.
+    pub const MAX_MTU: usize = get_build_var!("MCTP_ESTACK_MAX_MTU", 255);
+    const _: () = assert!(MAX_MTU >= crate::HEADER_LEN+1, "MAX_MTU too small");
+}
+
 #[derive(Debug)]
 struct Flow {
     // preallocated flows have None expiry
@@ -79,7 +126,6 @@ struct Flow {
 #[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
 pub struct AppCookie(pub usize);
 
-pub(crate) const HEADER_LEN: usize = 4;
 type Header = libmctp::base_packet::MCTPTransportHeader<[u8; HEADER_LEN]>;
 
 /// A handle to a received message.
@@ -103,8 +149,8 @@ pub struct Stack {
     // The buffer is kept outside of the Reassembler, in case it is borrowed
     // from other storage locations in future.
     // This is [Option<>] rather than Vec so that indices remain stable
-    // for the ReceiveHandle. Could use a LinearMap instead?
-    reassemblers: [Option<(Reassembler, Vec<u8, RECV_PAYLOAD>)>; NUM_RECEIVE],
+    // for the ReceiveHandle. Could use a Map instead?
+    reassemblers: [Option<(Reassembler, Vec<u8, MAX_PAYLOAD>)>; NUM_RECEIVE],
 
     /// monotonic time and counter.
     now: EventStamp,

mctp-estack/src/router.rs

@@ -14,7 +14,7 @@ use core::future::{poll_fn, Future};
 use core::pin::pin;
 
 use mctp::{Eid, Error, MsgType, Result, Tag, TagValue};
-use crate::{AppCookie, Fragmenter, ReceiveHandle, SendOutput, Stack, Header};
+use crate::{AppCookie, Fragmenter, ReceiveHandle, SendOutput, Stack, MAX_PAYLOAD, MAX_MTU};
 use crate::reassemble::Reassembler;
 
 use embassy_sync::zerocopy_channel::{Channel, Sender, Receiver};
@@ -100,7 +100,7 @@ pub struct PortTop<'a> {
 
     /// Temporary storage to flatten vectorised local sent messages
     // prior to fragmentation and queueing.
-    message: AsyncMutex<Vec<u8, MAX_MESSAGE>>,
+    message: AsyncMutex<Vec<u8, MAX_PAYLOAD>>,
 
     mtu: usize,
 }

mctp-estack/src/serial.rs

@@ -9,7 +9,7 @@
 use crate::fmt::{debug, error, info, trace, warn};
 
 use crate::{
-    AppCookie, MctpMessage, ReceiveHandle, SendOutput, Stack,
+    AppCookie, MctpMessage, ReceiveHandle, SendOutput, Stack, MAX_PAYLOAD,
 };
 use mctp::{Eid, Error, MsgType, Result, Tag};
 
@@ -33,7 +33,6 @@ const FRAMING_ESCAPE: u8 = 0x7d;
 const FLAG_ESCAPED: u8 = 0x5e;
 const ESCAPE_ESCAPED: u8 = 0x5d;
 
-const TXMSGBUF: usize = 1024;
 // 6 serial header/footer bytes, 0xff MCTP packet bytes
 const TXFRAGBUF: usize = 6 + 0xff;
 
@@ -59,7 +58,7 @@ pub struct MctpSerialHandler {
     // Last-seen byte count field
     rxcount: usize,
 
-    send_message: Vec<u8, TXMSGBUF>,
+    send_message: Vec<u8, MAX_PAYLOAD>,
     send_fragment: [u8; TXFRAGBUF]
 }
 
@@ -206,7 +205,7 @@ impl MctpSerialHandler {
     // Returns SendOutput::Complete or SendOutput::Error
     pub async fn send_fill<F>(&mut self, eid: Eid, typ: MsgType, tag: Option<Tag>,
         ic: bool, cookie: Option<AppCookie>, output: &mut impl Write, mctp: &mut Stack, fill_msg: F) -> SendOutput
-    where F: FnOnce(&mut Vec<u8, TXMSGBUF>) -> Option<()>,
+    where F: FnOnce(&mut Vec<u8, MAX_PAYLOAD>) -> Option<()>,
     {
         // Fetch the message from input
         self.send_message.clear();

mctp-estack/src/usb.rs

@@ -13,7 +13,7 @@
 
 use heapless::Vec;
 use crate::{
-    AppCookie, MctpMessage, ReceiveHandle, SendOutput, Stack,
+    AppCookie, MctpMessage, ReceiveHandle, SendOutput, Stack, MAX_PAYLOAD,
 };
 use mctp::{Eid, MsgType, Tag, Error, Result};
 
@@ -29,11 +29,8 @@ const HDR_LEN: usize = 4;
 const MCTP_USB_MTU_MAX: usize = u8::MAX as usize - HDR_LEN;
 const TX_XFER_SIZE: usize = 512;
 
-// Arbitrary limit
-const TX_MSG_SIZE: usize = 1024;
-
 pub struct MctpUsbHandler {
-    tx_msg: Vec<u8, TX_MSG_SIZE>,
+    tx_msg: Vec<u8, MAX_PAYLOAD>,
     tx_xfer: [u8; TX_XFER_SIZE],
 }
 
@@ -96,7 +93,7 @@ impl MctpUsbHandler {
         mctp: &mut Stack,
         fill_msg: F,
     ) -> SendOutput
-        where F: FnOnce(&mut Vec<u8, TX_MSG_SIZE>) -> Option<()>,
+        where F: FnOnce(&mut Vec<u8, MAX_PAYLOAD>) -> Option<()>,
     {
         self.tx_msg.clear();
         if fill_msg(&mut self.tx_msg).is_none() {

mctp-estack/src/util.rs

@@ -0,0 +1,21 @@
+/// Takes a `usize` from a build-time environment variable.
+///
+/// If unset, the default is used. Can be used in a const context.
+#[macro_export]
+macro_rules! get_build_var {
+    ($name:literal, $default:expr) => {
+        {
+            match option_env!($name) {
+                Some(v) => {
+                    let Ok(v) = usize::from_str_radix(v, 10) else {
+                        // concat! because const format_args isn't stable
+                        panic!(concat!("Bad value for environment variable ", $name));
+                    };
+                    v
+                }
+                None => $default
+            }
+        }
+    };
+}
+