pldm-file: Implement DfClose

We should be able to close FileDescriptors to free up the host slot.

Signed-off-by: Jeremy Kerr <jk@codeconstruct.com.au>

Author: jk-ozlabs

pldm-file/examples/client.rs

@@ -3,8 +3,8 @@ use mctp::Eid;
 use mctp_linux::MctpLinuxAsyncReq;
 use pldm::control::requester::negotiate_transfer_parameters;
 use pldm_file::{
-    client::{df_open, df_properties, df_read},
-    proto::{DfOpenAttributes, DfProperty, FileIdentifier},
+    client::{df_close, df_open, df_properties, df_read},
+    proto::{DfCloseAttributes, DfOpenAttributes, DfProperty, FileIdentifier},
 };
 
 const EID: Eid = Eid(8);
@@ -41,6 +41,11 @@ fn main() -> Result<()> {
 
         println!("Read: {res:?}");
 
+        let attrs = DfCloseAttributes::empty();
+        let res = df_close(&mut req, fd, attrs).await;
+
+        println!("Close: {res:?}");
+
         Ok(())
     })
 }

pldm-file/src/client.rs

@@ -79,6 +79,36 @@ pub async fn df_open(
     Ok(FileDescriptor(ret.file_descriptor))
 }
 
+pub async fn df_close(
+    comm: &mut impl mctp::AsyncReqChannel,
+    fd: FileDescriptor,
+    attributes: DfCloseAttributes,
+) -> Result<()> {
+    let req = DfCloseReq {
+        file_descriptor: fd.0,
+        attributes: attributes.as_u16(),
+    };
+
+    let mut buf = [0; 4];
+    let l = req.to_slice(&mut buf).map_err(|_| PldmError::NoSpace)?;
+    let buf = &buf[..l];
+
+    let req = PldmRequest::new_borrowed(
+        PLDM_TYPE_FILE_TRANSFER,
+        Cmd::DfClose as u8,
+        buf,
+    );
+
+    let mut rx = [0; 10];
+    let resp = pldm_xfer_buf_async(comm, req, &mut rx).await?;
+
+    if resp.cc != 0 {
+        return Err(proto_error!("DfClose failed"));
+    }
+
+    Ok(())
+}
+
 const PART_SIZE: usize = 1024;
 
 /// Read a file from the host.

pldm-file/src/host.rs

@@ -122,6 +122,7 @@ impl<const N: usize> Responder<N> {
         let r = match cmd {
             Cmd::DfProperties => self.cmd_dfproperties(req, host),
             Cmd::DfOpen => self.cmd_dfopen(req, host),
+            Cmd::DfClose => self.cmd_dfclose(req, host),
             _ => {
                 trace!("unhandled command {cmd:?}");
                 Err(CCode::ERROR_UNSUPPORTED_PLDM_CMD.into())
@@ -264,6 +265,30 @@ impl<const N: usize> Responder<N> {
         Ok(resp)
     }
 
+    fn cmd_dfclose<'a>(
+        &mut self,
+        req: &'a PldmRequest<'a>,
+        _host: &mut impl Host,
+    ) -> Result<PldmResponse<'a>> {
+        let (rest, dfc) = DfCloseReq::from_bytes((&req.data, 0))?;
+
+        if !rest.0.is_empty() {
+            Err(CCode::ERROR_INVALID_LENGTH)?;
+        }
+
+        if dfc.attributes != 0 {
+            Err(file_ccode::ZEROLENGTH_NOT_ALLOWED)?;
+        }
+
+        self.files
+            .get_mut(dfc.file_descriptor as usize)
+            .ok_or(file_ccode::INVALID_FILE_DESCRIPTOR)? // valid?
+            .take()
+            .ok_or(file_ccode::INVALID_FILE_DESCRIPTOR)?; // open?
+
+        Ok(req.response())
+    }
+
     fn cmd_multipart_receive<'a, const T: usize>(
         &mut self,
         req: &'a PldmRequest<'a>,

pldm-file/src/proto.rs

@@ -60,6 +60,13 @@ pub enum DfOpenAttribute {
 
 pub type DfOpenAttributes = EnumSet<DfOpenAttribute>;
 
+#[derive(EnumSetType, Debug)]
+pub enum DfCloseAttribute {
+    DfCloseZeroLength = 0,
+}
+
+pub type DfCloseAttributes = EnumSet<DfCloseAttribute>;
+
 impl TryFrom<u32> for DfProperty {
     type Error = ();
 
@@ -92,3 +99,9 @@ pub struct DfOpenReq {
 pub struct DfOpenResp {
     pub file_descriptor: u16,
 }
+
+#[derive(DekuRead, DekuWrite)]
+pub struct DfCloseReq {
+    pub file_descriptor: u16,
+    pub attributes: u16,
+}