types: Make QdlChan BufRead

The Read trait serves us well for the USB backend, but the serial backend
doesn't provide incoming messages in packets. This becomes a problem when we're
doing <read/> as the response and data can come in the same channel.read().

Switch the trait to BufRead, to allow the implementation to peek at the data and
partially consume the channel.

Signed-off-by: Bjorn Andersson <bjorn.andersson@oss.qualcomm.com>

Author: quic-bjorande

qdl/src/serial.rs

@@ -2,28 +2,61 @@
 // Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 use anyhow::{Result, bail};
 use serial2::{self, SerialPort};
-use std::io::{Read, Write};
+use std::io::{BufRead, Read, Write};
 
 use crate::types::QdlReadWrite;
 
 pub struct QdlSerialConfig {
     serport: SerialPort,
+    buf: Vec<u8>,
+    pos: usize,
+    cap: usize,
 }
 
 // TODO: timeouts?
 impl Write for QdlSerialConfig {
     fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
         self.serport.write(buf)
     }
-
     fn flush(&mut self) -> Result<(), std::io::Error> {
         self.serport.flush()
     }
 }
 
 impl Read for QdlSerialConfig {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
-        self.serport.read(buf)
+    fn read(&mut self, out: &mut [u8]) -> Result<usize, std::io::Error> {
+        // Drain internal buffer first
+        if self.pos < self.cap {
+            let n = std::cmp::min(out.len(), self.cap - self.pos);
+            out[..n].copy_from_slice(&self.buf[self.pos..self.pos + n]);
+            self.pos += n;
+            return Ok(n);
+        }
+        // Otherwise, read directly from serial port
+        self.serport.read(out)
+    }
+}
+
+impl BufRead for QdlSerialConfig {
+    fn fill_buf(&mut self) -> Result<&[u8], std::io::Error> {
+        if self.pos >= self.cap {
+            self.pos = 0;
+            self.cap = 0;
+            if self.buf.is_empty() {
+                self.buf.resize(4096, 0);
+            }
+            match self.serport.read(&mut self.buf) {
+                Ok(n) => {
+                    self.cap = n;
+                }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(&self.buf[self.pos..self.cap])
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.pos = std::cmp::min(self.pos + amt, self.cap);
     }
 }
 
@@ -40,5 +73,10 @@ pub fn setup_serial_device(dev_path: Option<String>) -> Result<QdlSerialConfig>
         Ok(settings)
     })?;
 
-    Ok(QdlSerialConfig { serport })
+    Ok(QdlSerialConfig {
+        serport,
+        buf: Vec::new(),
+        pos: 0,
+        cap: 0,
+    })
 }

qdl/src/types.rs

@@ -2,7 +2,7 @@
 // Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 use std::{
     fmt::Display,
-    io::{ErrorKind, Read, Write},
+    io::{BufRead, ErrorKind, Read, Write},
     str::FromStr,
 };
 
@@ -87,13 +87,12 @@ impl Default for FirehoseConfiguration {
         }
     }
 }
-
-pub trait QdlChan: Read + Write {
+pub trait QdlChan: BufRead + Write {
     fn fh_config(&self) -> &FirehoseConfiguration;
     fn mut_fh_config(&mut self) -> &mut FirehoseConfiguration;
 }
 
-pub trait QdlReadWrite: Read + Write + Send + Sync {}
+pub trait QdlReadWrite: BufRead + Write + Send + Sync {}
 impl<T> QdlReadWrite for &mut T where T: QdlReadWrite + ?Sized {}
 
 pub struct QdlDevice<T>
@@ -127,6 +126,19 @@ where
     }
 }
 
+impl<T> std::io::BufRead for QdlDevice<T>
+where
+    T: QdlReadWrite + ?Sized,
+{
+    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
+        self.rw.fill_buf()
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.rw.consume(amt);
+    }
+}
+
 impl<T> QdlChan for QdlDevice<T>
 where
     T: QdlReadWrite + ?Sized,

qdl/src/usb.rs

@@ -3,7 +3,7 @@
 use anyhow::{Context, Result, bail};
 use rusb::{self, Device, DeviceHandle, GlobalContext};
 use std::{
-    io::{Error, ErrorKind, Read, Write},
+    io::{BufRead, Error, ErrorKind, Read, Write},
     time::Duration,
 };
 
@@ -13,6 +13,9 @@ pub struct QdlUsbConfig {
     dev_handle: rusb::DeviceHandle<GlobalContext>,
     in_ep: u8,
     out_ep: u8,
+    buf: Vec<u8>,
+    pos: usize,
+    cap: usize,
 }
 
 // TODO: timeouts?
@@ -27,15 +30,48 @@ impl Write for QdlUsbConfig {
         Ok(())
     }
 }
-
 impl Read for QdlUsbConfig {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+    fn read(&mut self, out: &mut [u8]) -> Result<usize, std::io::Error> {
+        // Drain internal buffer first
+        if self.pos < self.cap {
+            let n = std::cmp::min(out.len(), self.cap - self.pos);
+            out[..n].copy_from_slice(&self.buf[self.pos..self.pos + n]);
+            self.pos += n;
+            return Ok(n);
+        }
+        // Otherwise, read directly from USB
         self.dev_handle
-            .read_bulk(self.in_ep, buf, Duration::from_secs(10))
+            .read_bulk(self.in_ep, out, Duration::from_secs(10))
             .map_err(rusb_err_xlate)
     }
 }
 
+impl BufRead for QdlUsbConfig {
+    fn fill_buf(&mut self) -> Result<&[u8], std::io::Error> {
+        if self.pos >= self.cap {
+            self.pos = 0;
+            self.cap = 0;
+            if self.buf.is_empty() {
+                self.buf.resize(4096, 0);
+            }
+            match self
+                .dev_handle
+                .read_bulk(self.in_ep, &mut self.buf, Duration::from_secs(10))
+            {
+                Ok(n) => {
+                    self.cap = n;
+                }
+                Err(e) => return Err(rusb_err_xlate(e)),
+            }
+        }
+        Ok(&self.buf[self.pos..self.cap])
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.pos = std::cmp::min(self.pos + amt, self.cap);
+    }
+}
+
 impl QdlReadWrite for QdlUsbConfig {}
 
 const USB_VID_QCOM: u16 = 0x05c6;
@@ -122,11 +158,13 @@ pub fn setup_usb_device(serial_no: Option<String>) -> Result<QdlUsbConfig> {
     dev_handle
         .claim_interface(intf_desc.interface_number())
         .with_context(|| format!("Couldn't claim interface{}", intf_desc.interface_number()))?;
-
     Ok(QdlUsbConfig {
         dev_handle,
         in_ep,
         out_ep,
+        buf: Vec::new(),
+        pos: 0,
+        cap: 0,
     })
 }