erofs: introduce Rust implementation
Subsystems (3)
cover erofs: introduce Rust implementation
Greetings,
So here is a patchset to add Rust skeleton codes to the current EROFS implementation. The implementation is deeply inspired by the current C implementation, and it's based on a generic erofs_sys crate[1] written by me. The purpose is to potentially replace some of C codes to make to make full use of Rust's safety features and better optimization guarantees.
Many of the features (like compression inodes) still
fall back to C implementation because of my limited time and lack of Rust counterparts. However, the Extended Attributes work purely in Rust.
Some changes are done to the original C code.
1) Some of superblock operations are modified slightly to make sure memory allocation and deallocation are done correctly when interacting with Rust.
2) A new rust_helpers.c file is introduced to help Rust to deal with self-included EROFS API without exporting types that are not interpreted in Rust.
3) A new rust_bindings.h is introduced to provide Rust functions externs with the same function signature as Rust side so that C-side code can use the bindings easily.
4) CONFIG_EROFS_FS_RUST is added in dir.c, inode.c, super.c, data.c, and xattr.c to allow C code to be opt out and uses Rust implementation.
5) Some macros and function signatures are tweaked in internal.h with the compilation options.
Note that, since currently there is no mature Rust VFS implementation landed upstream, this patchset only uses C bindings internally and each unsafe operation is examined. This implementation only offers C-ABI-compatible functions impls and gets its exposed to original C implementation as either hooks or function pointers.
Also note that, this patchset only uses already-present self-included EROFS API and it uses as few C bindings generated from bindgen as possible, only inode, dentry, file and dir_context related are used, to be precise.
Since the EROFS community is pretty interested in giving Rust a try, I think this patchset will be a good start for Rust EROFS.
This patchset is based on the latest EROFS development tree. And the current codebase can also be found on my github repo[2].
[1]: https://github.com/ToolmanP/erofs-rs
[2]: https://github.com/ToolmanP/erofs-rs-linux
Yiyang Wu (24):
erofs: lift up erofs_fill_inode to global
erofs: add superblock data structure in Rust
erofs: add Errno in Rust
erofs: add xattrs data structure in Rust
erofs: add inode data structure in Rust
erofs: add alloc_helper in Rust
erofs: add data abstraction in Rust
erofs: add device data structure in Rust
erofs: add continuous iterators in Rust
erofs: add device_infos implementation in Rust
erofs: add map data structure in Rust
erofs: add directory entry data structure in Rust
erofs: add runtime filesystem and inode in Rust
erofs: add block mapping capability in Rust
erofs: add iter methods in filesystem in Rust
erofs: implement dir and inode operations in Rust
erofs: introduce Rust SBI to C
erofs: introduce iget alternative to C
erofs: introduce namei alternative to C
erofs: introduce readdir alternative to C
erofs: introduce erofs_map_blocks alternative to C
erofs: add skippable iters in Rust
erofs: implement xattrs operations in Rust
erofs: introduce xattrs replacement to C
fs/erofs/Kconfig | 10 + fs/erofs/Makefile | 4 + fs/erofs/data.c | 5 + fs/erofs/data_rs.rs | 63 +++ fs/erofs/dir.c | 2 + fs/erofs/dir_rs.rs | 57 ++ fs/erofs/inode.c | 10 +- fs/erofs/inode_rs.rs | 64 +++ fs/erofs/internal.h | 47 ++ fs/erofs/namei.c | 2 + fs/erofs/namei_rs.rs | 56 ++ fs/erofs/rust/erofs_sys.rs | 47 ++ fs/erofs/rust/erofs_sys/alloc_helper.rs | 35 ++ fs/erofs/rust/erofs_sys/data.rs | 70 +++ fs/erofs/rust/erofs_sys/data/backends.rs | 4 + .../erofs_sys/data/backends/uncompressed.rs | 39 ++ fs/erofs/rust/erofs_sys/data/raw_iters.rs | 127 +++++ .../rust/erofs_sys/data/raw_iters/ref_iter.rs | 131 +++++ .../rust/erofs_sys/data/raw_iters/traits.rs | 17 + fs/erofs/rust/erofs_sys/devices.rs | 75 +++ fs/erofs/rust/erofs_sys/dir.rs | 98 ++++ fs/erofs/rust/erofs_sys/errnos.rs | 191 +++++++ fs/erofs/rust/erofs_sys/inode.rs | 398 ++++++++++++++ fs/erofs/rust/erofs_sys/map.rs | 99 ++++ fs/erofs/rust/erofs_sys/operations.rs | 62 +++ fs/erofs/rust/erofs_sys/superblock.rs | 514 ++++++++++++++++++ fs/erofs/rust/erofs_sys/superblock/mem.rs | 94 ++++ fs/erofs/rust/erofs_sys/xattrs.rs | 272 +++++++++ fs/erofs/rust/kinode.rs | 76 +++ fs/erofs/rust/ksources.rs | 66 +++ fs/erofs/rust/ksuperblock.rs | 30 + fs/erofs/rust/mod.rs | 7 + fs/erofs/rust_bindings.h | 39 ++ fs/erofs/rust_helpers.c | 86 +++ fs/erofs/rust_helpers.h | 23 + fs/erofs/super.c | 51 +- fs/erofs/super_rs.rs | 59 ++ fs/erofs/xattr.c | 31 +- fs/erofs/xattr.h | 7 + fs/erofs/xattr_rs.rs | 106 ++++ 40 files changed, 3153 insertions(+), 21 deletions(-) create mode 100644 fs/erofs/data_rs.rs create mode 100644 fs/erofs/dir_rs.rs create mode 100644 fs/erofs/inode_rs.rs create mode 100644 fs/erofs/namei_rs.rs create mode 100644 fs/erofs/rust/erofs_sys.rs create mode 100644 fs/erofs/rust/erofs_sys/alloc_helper.rs create mode 100644 fs/erofs/rust/erofs_sys/data.rs create mode 100644 fs/erofs/rust/erofs_sys/data/backends.rs create mode 100644 fs/erofs/rust/erofs_sys/data/backends/uncompressed.rs create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters.rs create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters/ref_iter.rs create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters/traits.rs create mode 100644 fs/erofs/rust/erofs_sys/devices.rs create mode 100644 fs/erofs/rust/erofs_sys/dir.rs create mode 100644 fs/erofs/rust/erofs_sys/errnos.rs create mode 100644 fs/erofs/rust/erofs_sys/inode.rs create mode 100644 fs/erofs/rust/erofs_sys/map.rs create mode 100644 fs/erofs/rust/erofs_sys/operations.rs create mode 100644 fs/erofs/rust/erofs_sys/superblock.rs create mode 100644 fs/erofs/rust/erofs_sys/superblock/mem.rs create mode 100644 fs/erofs/rust/erofs_sys/xattrs.rs create mode 100644 fs/erofs/rust/kinode.rs create mode 100644 fs/erofs/rust/ksources.rs create mode 100644 fs/erofs/rust/ksuperblock.rs create mode 100644 fs/erofs/rust/mod.rs create mode 100644 fs/erofs/rust_bindings.h create mode 100644 fs/erofs/rust_helpers.c create mode 100644 fs/erofs/rust_helpers.h create mode 100644 fs/erofs/super_rs.rs create mode 100644 fs/erofs/xattr_rs.rs
Signature · 1 line
2.46.0
RFC PATCH 1/24 erofs: lift up erofs_fill_inode to global
Lift up erofs_fill_inode as a global symbol so that rust_helpers can use it for better compatibility.
--- fs/erofs/inode.c | 2 +- fs/erofs/internal.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)
fs/erofs/inode.c +1 -1
@@ -196,7 +196,7 @@ static int erofs_read_inode(struct inode *inode)return err; } -static int erofs_fill_inode (struct inode *inode) +int erofs_fill_inode (struct inode *inode) {struct erofs_inode *vi =EROFS_I (inode);int err;
fs/erofs/internal.h +1 -0
@@ -416,6 +416,7 @@ int erofs_map_blocks(struct inode *inode, struct erofs_map_blocks *map);void erofs_onlinefolio_init (struct folio *folio);void erofs_onlinefolio_split (struct folio *folio);void erofs_onlinefolio_end (struct folio *folio,int err); +int erofs_fill_inode (struct inode *inode);struct inode *erofs_iget (struct super_block *sb,erofs_nid_t nid); int erofs_getattr(struct mnt_idmap *idmap, const struct path *path, struct kstat *stat, u32 request_mask,
Signature · 1 line
2.46.0
RFC PATCH 2/24 erofs: add superblock data structure in Rust
In reply to Yiyang WuThis patch adds a compilable super_rs.rs and introduces superblock data structure in Rust. Note that this patch leaves C-side code untouched.
--- fs/erofs/Kconfig | 10 ++ fs/erofs/Makefile | 1 + fs/erofs/rust/erofs_sys.rs | 22 +++++ fs/erofs/rust/erofs_sys/superblock.rs | 132 ++++++++++++++++++++++++++ fs/erofs/rust/mod.rs | 4 + fs/erofs/super_rs.rs | 9 ++ 6 files changed, 178 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys.rs create mode 100644 fs/erofs/rust/erofs_sys/superblock.rs create mode 100644 fs/erofs/rust/mod.rs create mode 100644 fs/erofs/super_rs.rs
fs/erofs/Kconfig +10 -0
@@ -178,3 +178,13 @@ config EROFS_FS_PCPU_KTHREAD_HIPRI at higher priority. If unsure, say N. + +config EROFS_FS_RUST + bool "EROFS use RUST Replacement (EXPERIMENTAL)" + depends on EROFS_FS && RUST + help + This permits EROFS to use EXPERIMENTAL Rust implementation + for EROFS. This should be considered as an experimental + feature for now. + + If unsure, say N.
fs/erofs/Makefile +1 -0
@@ -9,3 +9,4 @@ erofs-$(CONFIG_EROFS_FS_ZIP_DEFLATE) += decompressor_deflate.o erofs-$(CONFIG_EROFS_FS_ZIP_ZSTD) += decompressor_zstd.o erofs-$(CONFIG_EROFS_FS_BACKED_BY_FILE) += fileio.o erofs-$(CONFIG_EROFS_FS_ONDEMAND) += fscache.o +erofs-$(CONFIG_EROFS_FS_RUST) += super_rs.o
fs/erofs/rust/erofs_sys.rs new file +22 -0
@@ -0,0 +1,22 @@ +#![allow(dead_code)] +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +//! A pure Rust implementation of the EROFS filesystem. +//! Technical Details are documented in the [EROFS Documentation](https://erofs.docs.kernel.org/en/latest/) + +// It's unavoidable to import alloc here. Since there are so many backends there and if we want to +// to use trait object to export Filesystem pointer. The alloc crate here is necessary. + +#[cfg(not( CONFIG_EROFS_FS = "y" ))] +extern crate alloc; + +/// Erofs requires block index to a 32 bit unsigned integer. +pub (crate )type Blk =u32 ; +/// Erofs requires normal offset to be a 64bit unsigned integer. +pub (crate )type Off =u64 ; +/// Erofs requires inode nid to be a 64bit unsigned integer. +pub (crate )type Nid =u64 ; +/// Erofs Super Offset to read the ondisk superblock +pub (crate )const EROFS_SUPER_OFFSET :Off =1024 ; +pub (crate )mod superblock;
fs/erofs/rust/erofs_sys/superblock.rs new file +132 -0
132 lines not on this page · raw message
fs/erofs/rust/mod.rs new file +4 -0
@@ -0,0 +1,4 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +pub (crate )mod erofs_sys;
fs/erofs/super_rs.rs new file +9 -0
@@ -0,0 +1,9 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +//! EROFS Rust Kernel Module Helpers Implementation +//! This is only for experimental purpose. Feedback is always welcome. + +#[allow(dead_code)] +#[allow(missing_docs)] +pub (crate )mod rust;
Signature · 1 line
2.46.0
RFC PATCH 3/24 erofs: add Errno in Rust
In reply to Yiyang WuIntroduce Errno to Rust side code. Note that in current Rust For Linux, Errnos are implemented as core::ffi::c_uint unit structs. However, EUCLEAN, a.k.a EFSCORRUPTED is missing from error crate.
Since the errno_base hasn't changed for over 13 years, This patch merely serves as a temporary workaround for the missing errno in the Rust For Linux.
--- fs/erofs/rust/erofs_sys.rs | 6 + fs/erofs/rust/erofs_sys/errnos.rs | 191 ++++++++++++++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/errnos.rs
fs/erofs/rust/erofs_sys.rs +6 -0
@@ -19,4 +19,10 @@pub (crate )type Nid =u64 ;/// Erofs Super Offset to read the ondisk superblock pub (crate )const EROFS_SUPER_OFFSET :Off =1024 ; +/// PosixResult as a type alias to kernel::error::Result +/// to avoid naming conflicts. +pub (crate )type PosixResult <T > =Result <T ,Errno >; + +pub (crate )mod errnos;pub (crate )mod superblock; +pub (crate )use errnos::Errno ;
fs/erofs/rust/erofs_sys/errnos.rs new file +191 -0
191 lines not on this page · raw message
Signature · 1 line
2.46.0
RFC PATCH 4/24 erofs: add xattrs data structure in Rust
In reply to Yiyang WuThis patch introduces on-disk and runtime data structure of Extended Attributes implementation in erofs_sys crate. This will be later used to implement the op handler.
--- fs/erofs/rust/erofs_sys.rs | 12 +++ fs/erofs/rust/erofs_sys/xattrs.rs | 124 ++++++++++++++++++++++++++++++ 2 files changed, 136 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/xattrs.rs
fs/erofs/rust/erofs_sys.rs +12 -0
@@ -25,4 +25,16 @@pub (crate )mod errnos;pub (crate )mod superblock; +pub (crate )mod xattrs;pub (crate )use errnos::Errno ; + +/// Helper macro to round up or down a number. +#[macro_export] +macro_rules! round { + (UP , $x: expr, $y: expr) => { + ($x + $y -1 ) / $y * $y + }; + (DOWN , $x: expr, $y: expr) => { + ($x / $y) * $y + }; +}
fs/erofs/rust/erofs_sys/xattrs.rs new file +124 -0
124 lines not on this page · raw message
Signature · 1 line
2.46.0
RFC PATCH 5/24 erofs: add inode data structure in Rust
In reply to Yiyang WuThis patch introduces the same on-disk erofs data structure in rust and also introduces multiple helpers for inode i_format and chunk_indexing and later can be used to implement map_blocks.
--- fs/erofs/rust/erofs_sys.rs | 1 + fs/erofs/rust/erofs_sys/inode.rs | 291 +++++++++++++++++++++++++++++++ 2 files changed, 292 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/inode.rs
fs/erofs/rust/erofs_sys.rs +1 -0
@@ -24,6 +24,7 @@pub (crate )type PosixResult <T > =Result <T ,Errno >;pub (crate )mod errnos; +pub (crate )mod inode;pub (crate )mod superblock;pub (crate )mod xattrs;pub (crate )use errnos::Errno ;
fs/erofs/rust/erofs_sys/inode.rs new file +291 -0
291 lines not on this page · raw message
Signature · 1 line
2.46.0
RFC PATCH 6/24 erofs: add alloc_helper in Rust
In reply to Yiyang WuIn normal rust, heap related operations are infallible meaning that they do not throw errors and Rust will panic in usermode instead. However in kernel, it will throw AllocError this module helps to bridge the gaps and returns Errno universally.
--- fs/erofs/rust/erofs_sys.rs | 1 + fs/erofs/rust/erofs_sys/alloc_helper.rs | 35 +++++++++++++++++++++++++ 2 files changed, 36 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/alloc_helper.rs
fs/erofs/rust/erofs_sys.rs +1 -0
@@ -23,6 +23,7 @@/// to avoid naming conflicts. pub (crate )type PosixResult <T > =Result <T ,Errno >; +pub (crate )mod alloc_helper;pub (crate )mod errnos;pub (crate )mod inode;pub (crate )mod superblock;
fs/erofs/rust/erofs_sys/alloc_helper.rs new file +35 -0
@@ -0,0 +1,35 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +/// This module provides helper functions for the alloc crate +/// Note that in linux kernel, the allocation is fallible however in userland it is not. +/// Since most of the functions depend on infallible allocation, here we provide helper functions +/// so that most of codes don't need to be changed. + +#[cfg( CONFIG_EROFS_FS = "y" )] +use kernel::prelude::*; + +#[cfg(not( CONFIG_EROFS_FS = "y" ))] +use alloc::vec; + +use super ::*; +use alloc::boxed::Box ; +use alloc::vec::Vec ; + +pub (crate )fn push_vec <T >(v: &mut Vec <T >, value:T ) ->PosixResult <()> { + v.push (value,GFP_KERNEL ) + .map_or_else (|_|Err (Errno ::ENOMEM ), |_|Ok (())) +} + +pub (crate )fn extend_from_slice <T :Clone >(v: &mut Vec <T >, slice: &[T ]) ->PosixResult <()> { + v.extend_from_slice (slice,GFP_KERNEL ) + .map_or_else (|_|Err (Errno ::ENOMEM ), |_|Ok (())) +} + +pub (crate )fn heap_alloc <T >(value:T ) ->PosixResult <Box <T >> { +Box ::new (value,GFP_KERNEL ).map_or_else (|_|Err (Errno ::ENOMEM ), |v|Ok (v)) +} + +pub (crate )fn vec_with_capacity <T :Default +Clone >(capacity:usize ) ->PosixResult <Vec <T >> { +Vec ::with_capacity (capacity,GFP_KERNEL ).map_or_else (|_|Err (Errno ::ENOMEM ), |v|Ok (v)) +}
Signature · 1 line
2.46.0
RFC PATCH 7/24 erofs: add data abstraction in Rust
In reply to Yiyang WuIntroduce Buffer, Source, Backend traits.
Implement Uncompressed Backend and RefBuffer to be used in future data operations.
--- fs/erofs/rust/erofs_sys.rs | 1 + fs/erofs/rust/erofs_sys/data.rs | 62 +++++++++++++++++++ fs/erofs/rust/erofs_sys/data/backends.rs | 4 ++ .../erofs_sys/data/backends/uncompressed.rs | 39 ++++++++++++ 4 files changed, 106 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/data.rs create mode 100644 fs/erofs/rust/erofs_sys/data/backends.rs create mode 100644 fs/erofs/rust/erofs_sys/data/backends/uncompressed.rs
fs/erofs/rust/erofs_sys.rs +1 -0
@@ -24,6 +24,7 @@pub (crate )type PosixResult <T > =Result <T ,Errno >;pub (crate )mod alloc_helper; +pub (crate )mod data;pub (crate )mod errnos;pub (crate )mod inode;pub (crate )mod superblock;
fs/erofs/rust/erofs_sys/data.rs new file +62 -0
62 lines not on this page · raw message
fs/erofs/rust/erofs_sys/data/backends.rs new file +4 -0
@@ -0,0 +1,4 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +pub (crate )mod uncompressed;
fs/erofs/rust/erofs_sys/data/backends/uncompressed.rs new file +39 -0
@@ -0,0 +1,39 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +use super ::super ::*; + +pub (crate )struct UncompressedBackend <T > +where +T :Source , +{ + source:T , +} + +impl <T >Backend for UncompressedBackend <T > +where +T :Source , +{ +fn fill (&self, data: &mut [u8 ], offset:Off ) ->PosixResult <u64 > { + self.source.fill (data, offset) + } + +fn as_buf <'a>(&'a self, offset:Off , len:Off ) ->PosixResult <RefBuffer <'a>> { + self.source.as_buf (offset, len) + } +} + +impl <T :Source >UncompressedBackend <T > { +pub (crate )fn new (source:T ) ->Self { +Self { source } + } +} + +impl <T >From <T >for UncompressedBackend <T > +where +T :Source , +{ +fn from (value:T ) ->Self { +Self ::new (value) + } +}
Signature · 1 line
2.46.0
RFC PATCH 8/24 erofs: add device data structure in Rust
In reply to Yiyang WuThis patch introduce device data structure in Rust. It can later support chunk based block maps.
--- fs/erofs/rust/erofs_sys.rs | 1 + fs/erofs/rust/erofs_sys/devices.rs | 28 ++++++++++++++++++++++++++++ 2 files changed, 29 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/devices.rs
fs/erofs/rust/erofs_sys.rs +1 -0
@@ -25,6 +25,7 @@pub (crate )mod alloc_helper;pub (crate )mod data; +pub (crate )mod devices;pub (crate )mod errnos;pub (crate )mod inode;pub (crate )mod superblock;
fs/erofs/rust/erofs_sys/devices.rs new file +28 -0
@@ -0,0 +1,28 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +use alloc::vec::Vec ; + +/// Device specification. +#[derive( Copy , Clone , Debug )] +pub (crate )struct DeviceSpec { +pub (crate ) tags: [u8 ;64 ], +pub (crate ) blocks:u32 , +pub (crate ) mapped_blocks:u32 , +} + +/// Device slot. +#[derive( Copy , Clone , Debug )] +#[repr( C )] +pub (crate )struct DeviceSlot { + tags: [u8 ;64 ], + blocks:u32 , + mapped_blocks:u32 , + reserved: [u8 ;56 ], +} + +/// Device information. +pub (crate )struct DeviceInfo { +pub (crate ) mask:u16 , +pub (crate ) specs:Vec <DeviceSpec >, +}
Signature · 1 line
2.46.0
RFC PATCH 9/24 erofs: add continuous iterators in Rust
In reply to Yiyang WuThis patch adds a special iterator that is capable of iterating over a memory region in the granularity of a common page. This can be later used to read device buffer or fast symlink.
--- fs/erofs/rust/erofs_sys/data.rs | 2 + fs/erofs/rust/erofs_sys/data/raw_iters.rs | 6 ++ .../rust/erofs_sys/data/raw_iters/ref_iter.rs | 68 +++++++++++++++++++ .../rust/erofs_sys/data/raw_iters/traits.rs | 13 ++++ 4 files changed, 89 insertions(+) create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters.rs create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters/ref_iter.rs create mode 100644 fs/erofs/rust/erofs_sys/data/raw_iters/traits.rs
fs/erofs/rust/erofs_sys/data.rs +2 -0
@@ -1,6 +1,8 @@// Copyright 2024 Yiyang Wu // SPDX-License-Identifier: MIT or GPL-2.0-or-later pub (crate )mod backends; +pub (crate )mod raw_iters; +use super ::superblock::*;use super ::*;/// Represent some sort of generic data source. This cound be file, memory or even network.
fs/erofs/rust/erofs_sys/data/raw_iters.rs new file +6 -0
@@ -0,0 +1,6 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +pub (crate )mod ref_iter; +mod traits; +pub (crate )use traits::*;
fs/erofs/rust/erofs_sys/data/raw_iters/ref_iter.rs new file +68 -0
68 lines not on this page · raw message
fs/erofs/rust/erofs_sys/data/raw_iters/traits.rs new file +13 -0
@@ -0,0 +1,13 @@ +// Copyright 2024 Yiyang Wu +// SPDX-License-Identifier: MIT or GPL-2.0-or-later + +use super ::super ::*; + +/// Represents a basic iterator over a range of bytes from data backends. +/// Note that this is skippable and can be used to move the iterator's cursor forward. +pub (crate )trait ContinuousBufferIter <'a>: +Iterator <Item =PosixResult <RefBuffer <'a>>> +{ +fn advance_off (&mut self, offset:Off ); +fn eof (&self) ->bool ; +}
Signature · 1 line
2.46.0
RFC PATCH 10/24 erofs: add device_infos implementation in Rust
In reply to Yiyang WuAdd device_infos implementation in rust. It will later be used to be put inside the SuperblockInfo. This mask and spec can later be used to chunk-based image file block mapping.
--- fs/erofs/rust/erofs_sys/devices.rs | 47 ++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
fs/erofs/rust/erofs_sys/devices.rs +47 -0
@@ -1,6 +1,10 @@// Copyright 2024 Yiyang Wu // SPDX-License-Identifier: MIT or GPL-2.0-or-later +use super ::alloc_helper::*; +use super ::data::raw_iters::*; +use super ::data::*; +use super ::*;use alloc::vec::Vec ;/// Device specification.
@@ -21,8 +25,51 @@ pub(crate) struct DeviceSlot { reserved: [u8; 56], } +impl From <[u8 ;128 ]>for DeviceSlot { +fn from (data: [u8 ;128 ]) ->Self { +Self { + tags: data[0 ..64 ].try_into ().unwrap (), + blocks: u32::from_le_bytes ([data[64 ], data[65 ], data[66 ], data[67 ]]), + mapped_blocks: u32::from_le_bytes ([data[68 ], data[69 ], data[70 ], data[71 ]]), + reserved: data[72 ..128 ].try_into ().unwrap (), + } + } +} +/// Device information. pub (crate )struct DeviceInfo {pub (crate ) mask:u16 ,pub (crate ) specs:Vec <DeviceSpec >, } + +pub (crate )fn get_device_infos <'a>( + iter: &mut (dyn ContinuousBufferIter <'a> + 'a), +) ->PosixResult <DeviceInfo > { +let mut specs =Vec ::new (); +for datain iter { +let buffer = data?; +let mut cur:usize =0 ; +let len = buffer.content ().len (); +while cur +128 <= len { +let slot_data: [u8 ;128 ] = buffer.content ()[cur..cur +128 ].try_into ().unwrap (); +let slot =DeviceSlot ::from (slot_data); + cur +=128 ; +push_vec ( + &mut specs, +DeviceSpec { + tags: slot.tags, + blocks: slot.blocks, + mapped_blocks: slot.mapped_blocks, + }, + )?; + } + } + +let mask =if specs.is_empty () { +0 + }else { + (1 << (specs.len ().ilog2 () +1 )) -1 + }; + +Ok (DeviceInfo { mask, specs }) +}
Signature · 1 line
2.46.0
Quoted 8 lines · Yiyang Wu via Linux-erofs
Greetings,
So here is a patchset to add Rust skeleton codes to the current EROFS implementation. The implementation is deeply inspired by the current C implementation, and it's based on a generic
erofs_syscrate[1] written by me. The purpose is to potentially replace some of C codes to make to make full use of Rust's safety features and better optimization guarantees.
Utterly sorry for my mistake.
I forgot CC the LKML when copying the mailing list so i interrupt the patch sending.
Just delete the first one and use the second patchset, and it should be OK.
Best Regards
Yiyang Wu,