[RFC PATCH 22/24] erofs: add skippable iters in Rust

Yiyang Wu
2024-09-16T13:57:22Z

This patch introduce self-owned skippable data iterators in Rust.
This iterators will be used to access extended attributes later.

Signed-off-by: Yiyang Wu <toolmanp@tlmp.cc>
---
fs/erofs/rust/erofs_sys/data/raw_iters.rs | 121 ++++++++++++++++++++++
1 file changed, 121 insertions(+)

diff --git a/fs/erofs/rust/erofs_sys/data/raw_iters.rs b/fs/erofs/rust/erofs_sys/data/raw_iters.rs
index 8f3bd250d252..f1ff0a251596 100644
--- a/fs/erofs/rust/erofs_sys/data/raw_iters.rs
+++ b/fs/erofs/rust/erofs_sys/data/raw_iters.rs
@@ -4,3 +4,124 @@
pub(crate) mod ref_iter;
mod traits;
pub(crate) use traits::*;
+
+use super::*;
+use alloc::boxed::Box;
+
+/// Represents a skippable continuous buffer iterator. This is used primarily for reading the
+/// extended attributes. Since the key-value is flattened out in its original format.
+pub(crate) struct SkippableContinuousIter<'a> {
+ iter: Box<dyn ContinuousBufferIter<'a> + 'a>,
+ data: RefBuffer<'a>,
+ cur: usize,
+}
+
+fn cmp_with_cursor_move(
+ lhs: &[u8],
+ rhs: &[u8],
+ lhs_cur: &mut usize,
+ rhs_cur: &mut usize,
+ len: usize,
+) -> bool {
+ let result = lhs[*lhs_cur..(*lhs_cur + len)] == rhs[*rhs_cur..(*rhs_cur + len)];
+ *lhs_cur += len;
+ *rhs_cur += len;
+ result
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) enum SkipCmpError {
+ PosixError(Errno),
+ NotEqual(Off),
+}
+
+impl From<Errno> for SkipCmpError {
+ fn from(e: Errno) -> Self {
+ SkipCmpError::PosixError(e)
+ }
+}
+
+impl<'a> SkippableContinuousIter<'a> {
+ pub(crate) fn try_new(
+ mut iter: Box<dyn ContinuousBufferIter<'a> + 'a>,
+ ) -> PosixResult<Option<Self>> {
+ if iter.eof() {
+ return Ok(None);
+ }
+ let data = iter.next().unwrap()?;
+ Ok(Some(Self { iter, data, cur: 0 }))
+ }
+ pub(crate) fn skip(&mut self, offset: Off) -> PosixResult<()> {
+ let dlen = self.data.content().len() - self.cur;
+ if offset as usize <= dlen {
+ self.cur += offset as usize;
+ } else {
+ self.cur = 0;
+ self.iter.advance_off(dlen as Off);
+ self.data = self.iter.next().unwrap()?;
+ }
+ Ok(())
+ }
+
+ pub(crate) fn read(&mut self, buf: &mut [u8]) -> PosixResult<()> {
+ let mut dlen = self.data.content().len() - self.cur;
+ let mut bcur = 0_usize;
+ let blen = buf.len();
+ if dlen != 0 && dlen >= blen {
+ buf.clone_from_slice(&self.data.content()[self.cur..(self.cur + blen)]);
+ self.cur += blen;
+ } else {
+ buf[bcur..(bcur + dlen)].copy_from_slice(&self.data.content()[self.cur..]);
+ bcur += dlen;
+ while bcur < blen {
+ self.cur = 0;
+ self.data = self.iter.next().unwrap()?;
+ dlen = self.data.content().len();
+ if dlen >= blen - bcur {
+ buf[bcur..].copy_from_slice(&self.data.content()[..(blen - bcur)]);
+ self.cur = blen - bcur;
+ return Ok(());
+ } else {
+ buf[bcur..(bcur + dlen)].copy_from_slice(self.data.content());
+ bcur += dlen;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ pub(crate) fn try_cmp(&mut self, buf: &[u8]) -> Result<(), SkipCmpError> {
+ let dlen = self.data.content().len() - self.cur;
+ let blen = buf.len();
+ let mut bcur = 0_usize;
+
+ if dlen != 0 && dlen >= blen {
+ if cmp_with_cursor_move(self.data.content(), buf, &mut self.cur, &mut bcur, blen) {
+ Ok(())
+ } else {
+ Err(SkipCmpError::NotEqual(bcur as Off))
+ }
+ } else {
+ if dlen != 0 {
+ let clen = dlen.min(blen);
+ if !cmp_with_cursor_move(self.data.content(), buf, &mut self.cur, &mut bcur, clen) {
+ return Err(SkipCmpError::NotEqual(bcur as Off));
+ }
+ }
+ while bcur < blen {
+ self.cur = 0;
+ self.data = self.iter.next().unwrap()?;
+ let dlen = self.data.content().len();
+ let clen = dlen.min(blen - bcur);
+ if !cmp_with_cursor_move(self.data.content(), buf, &mut self.cur, &mut bcur, clen) {
+ return Err(SkipCmpError::NotEqual(bcur as Off));
+ }
+ }
+
+ Ok(())
+ }
+ }
+ pub(crate) fn eof(&self) -> bool {
+ self.data.content().len() - self.cur == 0 && self.iter.eof()
+ }
+}
--
2.46.0