ioctl: crate for performing board ioctls

Author: surban

.github/workflows/build.yml

@@ -25,6 +25,7 @@ jobs:
         run: |
           cargo fmt --check --manifest-path openemc-bootloader/Cargo.toml
           cargo fmt --check --manifest-path openemc-firmware/Cargo.toml
+          cargo fmt --check --manifest-path openemc-io/Cargo.toml
           cargo fmt --check --manifest-path openemc-log/Cargo.toml
           cargo fmt --check --manifest-path openemc-pack/Cargo.toml
           cargo fmt --check --manifest-path openemc-shared/Cargo.toml
@@ -33,6 +34,7 @@ jobs:
         run: |
           cd openemc-bootloader ; cargo clippy --quiet ; cd ..
           cd openemc-firmware ; cargo clippy --quiet ; cd ..
+          cd openemc-io ; cargo clippy --quiet ; cd ..
           cd openemc-log ; cargo clippy --quiet ; cd ..
           cd openemc-pack ; cargo clippy --quiet ; cd ..
           cd openemc-shared ; cargo clippy --quiet ; cd ..
@@ -41,6 +43,8 @@ jobs:
         run: cd openemc-bootloader ; cargo build --release --quiet
       - name: Build firmware
         run: cd openemc-firmware ; cargo build --release --quiet
+      - name: Build io
+        run: cd openemc-io ; cargo build --release --quiet        
       - name: Build logger
         run: cd openemc-log ; cargo build --release --quiet
       - name: Build packer

Cargo.lock

@@ -2,6 +2,7 @@
 members = [
     "board-io-test",
     "openemc-build",
+    "openemc-io",
     "openemc-log",
     "openemc-pack",
     "xtask",

Cargo.toml

@@ -5,5 +5,5 @@ license = "GPL-3.0"
 edition = "2021"
 
 [dependencies]
+openemc-io = { path = "../openemc-io" }
 rand = "0.10"
-nix = { version = "0.31", features = ["ioctl"] }

board-io-test/Cargo.toml

@@ -3,26 +3,11 @@
 //! For use with STM Nucleo-F103RB example board (`stm_nucleo_f103rb.rs`).
 //!
 
-use nix::ioctl_readwrite;
+use openemc_io::{OpenEmc, OpenEmcIoctlError};
 use rand::prelude::*;
-use std::{
-    fs::File,
-    io::{Read, Write},
-    os::fd::AsRawFd,
-};
+use std::io::{Read, Write};
 
-const OPENEMC_MAX_DATA_SIZE: usize = 32;
-const OPENEMC_IOC_MAGIC: u8 = 0xEC;
-
-#[repr(C)]
-struct OpenemcIoctlData {
-    len: u8,
-    data: [u8; OPENEMC_MAX_DATA_SIZE],
-}
-
-ioctl_readwrite!(openemc_board_ioctl, OPENEMC_IOC_MAGIC, 0, OpenemcIoctlData);
-
-fn io_test(openemc: &mut File) {
+fn io_test(openemc: &mut OpenEmc) {
     let mut test_data = vec![0u8; 32];
     rand::rng().fill(test_data.as_mut_slice());
 
@@ -43,37 +28,30 @@ fn io_test(openemc: &mut File) {
     println!("IO test done");
 }
 
-fn ioctl_test(openemc: &mut File) {
+fn ioctl_test(openemc: &mut OpenEmc) {
     println!("ioctl test");
 
     let mut test_data = vec![0u8; 32];
     rand::rng().fill(test_data.as_mut_slice());
 
-    let mut ioctl_data = OpenemcIoctlData { len: 30, data: [0u8; OPENEMC_MAX_DATA_SIZE] };
-    ioctl_data.data[..30].copy_from_slice(&test_data[..30]);
-
-    let ret = unsafe { openemc_board_ioctl(openemc.as_raw_fd(), &mut ioctl_data) };
-    assert!(ret.is_ok(), "ioctl failed");
-    assert_eq!(ret.unwrap(), 25, "ioctl return value mismatch");
-    assert_eq!(ioctl_data.len, 25, "ioctl response length mismatch");
+    let result = openemc.ioctl(&test_data[..30]).unwrap();
+    assert_eq!(result.len(), 25, "ioctl response length mismatch");
 
     let expected: Vec<_> = test_data.iter().map(|v| v.wrapping_add(1)).collect();
-    assert_eq!(&ioctl_data.data[..25], &expected[..25], "ioctl data mismatch");
+    assert_eq!(&result[..25], &expected[..25], "ioctl data mismatch");
 
-    ioctl_data.len = 32;
-    ioctl_data.data.copy_from_slice(&test_data);
-    let ret = unsafe { openemc_board_ioctl(openemc.as_raw_fd(), &mut ioctl_data) };
-    assert!(ret.is_err(), "ioctl should have failed");
-    let errno = ret.unwrap_err() as i32;
-    assert_eq!(errno, 10, "wrong errno");
+    let result = openemc.ioctl(&test_data);
+    assert!(result.is_err(), "ioctl should have failed");
+    let err = result.unwrap_err();
+    let ioctl_err = err.get_ref().unwrap().downcast_ref::<OpenEmcIoctlError>().unwrap();
+    assert_eq!(ioctl_err.0, 10, "wrong errno");
 
     println!("ioctl test done");
 }
 
 fn main() {
     println!("Opening /dev/openemc");
-    let mut openemc =
-        File::options().read(true).write(true).open("/dev/openemc").expect("cannot open /dev/openemc");
+    let mut openemc = OpenEmc::new().expect("cannot open /dev/openemc");
 
     io_test(&mut openemc);
     ioctl_test(&mut openemc);

board-io-test/src/main.rs

@@ -0,0 +1,8 @@
+[package]
+name = "openemc-io"
+description = "OpenEMC board IO"
+license = "LGPL-3.0"
+edition = "2021"
+
+[dependencies]
+rustix = "1"

openemc-io/Cargo.toml

@@ -0,0 +1,80 @@
+//! OpenEMC board IO.
+
+use rustix::ioctl::{self, opcode, Opcode};
+use std::{fmt, fs::File, io};
+
+/// OpenEMC ioctl error.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OpenEmcIoctlError(pub u8);
+
+impl fmt::Display for OpenEmcIoctlError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "OpenEMC board ioctl error {}", self.0)
+    }
+}
+
+impl std::error::Error for OpenEmcIoctlError {}
+
+impl From<OpenEmcIoctlError> for io::Error {
+    fn from(e: OpenEmcIoctlError) -> Self {
+        io::Error::other(e)
+    }
+}
+
+const OPENEMC_IOC_MAGIC: u8 = 0xEC;
+
+#[repr(C)]
+struct OpenEmcIoctlData {
+    len: u8,
+    data: [u8; Self::MAX_DATA_SIZE],
+}
+
+impl OpenEmcIoctlData {
+    const MAX_DATA_SIZE: usize = 32;
+    const OPCODE: Opcode = opcode::read_write::<Self>(OPENEMC_IOC_MAGIC, 0);
+}
+
+/// OpenEMC access.
+#[derive(Debug)]
+pub struct OpenEmc(File);
+
+impl OpenEmc {
+    /// Maximum request size.
+    pub const MAX_REQ_SIZE: usize = OpenEmcIoctlData::MAX_DATA_SIZE;
+
+    /// Opens the OpenEMC board IO device.
+    pub fn new() -> io::Result<Self> {
+        Ok(Self(File::options().read(true).write(true).open("/dev/openemc")?))
+    }
+
+    /// Performs an OpenEMC board ioctl.
+    ///
+    /// `req` length must not exceed [`Self::MAX_REQ_SIZE`].
+    pub fn ioctl(&self, req: &[u8]) -> io::Result<Vec<u8>> {
+        assert!(req.len() <= OpenEmcIoctlData::MAX_DATA_SIZE, "OpenEMC ioctl request too big");
+
+        let mut ioc = OpenEmcIoctlData { len: req.len() as u8, data: [0; OpenEmcIoctlData::MAX_DATA_SIZE] };
+        ioc.data[..req.len()].copy_from_slice(req);
+
+        unsafe { ioctl::ioctl(&self.0, ioctl::Updater::<{ OpenEmcIoctlData::OPCODE }, _>::new(&mut ioc)) }
+            .map_err(|e| OpenEmcIoctlError(e.raw_os_error() as u8))?;
+
+        Ok(ioc.data[..ioc.len as usize].to_vec())
+    }
+}
+
+impl io::Read for OpenEmc {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+}
+
+impl io::Write for OpenEmc {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.0.flush()
+    }
+}

openemc-io/src/lib.rs

@@ -11,6 +11,7 @@ cd ..
 cargo +nightly fmt
 cargo +nightly fmt --manifest-path openemc-bootloader/Cargo.toml
 cargo +nightly fmt --manifest-path openemc-firmware/Cargo.toml
+cargo +nightly fmt --manifest-path openemc-io/Cargo.toml
 cargo +nightly fmt --manifest-path openemc-shared/Cargo.toml
 cargo +nightly fmt --manifest-path openemc-log/Cargo.toml
 cargo +nightly fmt --manifest-path openemc-pack/Cargo.toml