Re: [External Mail][RFC PATCH 05/24] erofs: add inode data structure in Rust

Huang Jianan
2024-09-18T13:05:32Z

On 2024/9/16 21:56, Yiyang Wu via Linux-erofs wrote:
>
> This 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.
>
> Signed-off-by: Yiyang Wu <toolmanp@tlmp.cc>
> ---
> 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
>
> diff --git a/fs/erofs/rust/erofs_sys.rs b/fs/erofs/rust/erofs_sys.rs
> index 6f3c12665ed6..34267ec7772d 100644
> --- a/fs/erofs/rust/erofs_sys.rs
> +++ b/fs/erofs/rust/erofs_sys.rs
> @@ -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;
> diff --git a/fs/erofs/rust/erofs_sys/inode.rs b/fs/erofs/rust/erofs_sys/inode.rs
> new file mode 100644
> index 000000000000..1762023e97f8
> --- /dev/null
> +++ b/fs/erofs/rust/erofs_sys/inode.rs
> @@ -0,0 +1,291 @@
> +use super::xattrs::*;
> +use super::*;
> +use core::ffi::*;
> +use core::mem::size_of;
> +
> +/// Represents the compact bitfield of the Erofs Inode format.
> +#[repr(transparent)]
> +#[derive(Clone, Copy)]
> +pub(crate) struct Format(u16);
> +
> +pub(crate) const INODE_VERSION_MASK: u16 = 0x1;
> +pub(crate) const INODE_VERSION_BIT: u16 = 0;
> +
> +pub(crate) const INODE_LAYOUT_BIT: u16 = 1;
> +pub(crate) const INODE_LAYOUT_MASK: u16 = 0x7;
> +
> +/// Helper macro to extract property from the bitfield.
> +macro_rules! extract {
> + ($name: expr, $bit: expr, $mask: expr) => {
> + ($name >> $bit) & ($mask)
> + };
> +}
> +
> +/// The Version of the Inode which represents whether this inode is extended or compact.
> +/// Extended inodes have more infos about nlinks + mtime.
> +/// This is documented in https://erofs.docs.kernel.org/en/latest/core_ondisk.html#inodes
> +#[repr(C)]
> +#[derive(Clone, Copy)]
> +pub(crate) enum Version {
> + Compat,
> + Extended,
> + Unknown,
> +}
> +
> +/// Represents the data layout backed by the Inode.
> +/// As Documented in https://erofs.docs.kernel.org/en/latest/core_ondisk.html#inode-data-layouts
> +#[repr(C)]
> +#[derive(Clone, Copy, PartialEq)]
> +pub(crate) enum Layout {
> + FlatPlain,
> + CompressedFull,
> + FlatInline,
> + CompressedCompact,
> + Chunk,
> + Unknown,
> +}
> +
> +#[repr(C)]
> +#[allow(non_camel_case_types)]
> +#[derive(Clone, Copy, Debug, PartialEq)]
> +pub(crate) enum Type {
> + Regular,
> + Directory,
> + Link,
> + Character,
> + Block,
> + Fifo,
> + Socket,
> + Unknown,
> +}
> +
> +/// This is format extracted from i_format bit representation.
> +/// This includes various infos and specs about the inode.
> +impl Format {
> + pub(crate) fn version(&self) -> Version {
> + match extract!(self.0, INODE_VERSION_BIT, INODE_VERSION_MASK) {
> + 0 => Version::Compat,
> + 1 => Version::Extended,
> + _ => Version::Unknown,
> + }
> + }
> +
> + pub(crate) fn layout(&self) -> Layout {
> + match extract!(self.0, INODE_LAYOUT_BIT, INODE_LAYOUT_MASK) {
> + 0 => Layout::FlatPlain,
> + 1 => Layout::CompressedFull,
> + 2 => Layout::FlatInline,
> + 3 => Layout::CompressedCompact,
> + 4 => Layout::Chunk,
> + _ => Layout::Unknown,
> + }
> + }
> +}
> +
> +/// Represents the compact inode which resides on-disk.
> +/// This is documented in https://erofs.docs.kernel.org/en/latest/core_ondisk.html#inodes
> +#[repr(C)]
> +#[derive(Clone, Copy)]
> +pub(crate) struct CompactInodeInfo {
> + pub(crate) i_format: Format,
> + pub(crate) i_xattr_icount: u16,
> + pub(crate) i_mode: u16,
> + pub(crate) i_nlink: u16,
> + pub(crate) i_size: u32,
> + pub(crate) i_reserved: [u8; 4],
> + pub(crate) i_u: [u8; 4],
> + pub(crate) i_ino: u32,
> + pub(crate) i_uid: u16,
> + pub(crate) i_gid: u16,
> + pub(crate) i_reserved2: [u8; 4],
> +}
> +
> +/// Represents the extended inode which resides on-disk.
> +/// This is documented in https://erofs.docs.kernel.org/en/latest/core_ondisk.html#inodes
> +#[repr(C)]
> +#[derive(Clone, Copy)]
> +pub(crate) struct ExtendedInodeInfo {
> + pub(crate) i_format: Format,
> + pub(crate) i_xattr_icount: u16,
> + pub(crate) i_mode: u16,
> + pub(crate) i_reserved: [u8; 2],
> + pub(crate) i_size: u64,
> + pub(crate) i_u: [u8; 4],
> + pub(crate) i_ino: u32,
> + pub(crate) i_uid: u32,
> + pub(crate) i_gid: u32,
> + pub(crate) i_mtime: u64,
> + pub(crate) i_mtime_nsec: u32,
> + pub(crate) i_nlink: u32,
> + pub(crate) i_reserved2: [u8; 16],
> +}
> +
> +/// Represents the inode info which is either compact or extended.
> +#[derive(Clone, Copy)]
> +pub(crate) enum InodeInfo {
> + Extended(ExtendedInodeInfo),
> + Compact(CompactInodeInfo),
> +}
> +
> +pub(crate) const CHUNK_BLKBITS_MASK: u16 = 0x1f;
> +pub(crate) const CHUNK_FORMAT_INDEX_BIT: u16 = 0x20;
> +
> +/// Represents on-disk chunk index of the file backing inode.
> +#[repr(C)]
> +#[derive(Clone, Copy, Debug)]
> +pub(crate) struct ChunkIndex {
> + pub(crate) advise: u16,
> + pub(crate) device_id: u16,
> + pub(crate) blkaddr: u32,
> +}
> +
> +impl From<[u8; 8]> for ChunkIndex {
> + fn from(u: [u8; 8]) -> Self {
> + let advise = u16::from_le_bytes([u[0], u[1]]);
> + let device_id = u16::from_le_bytes([u[2], u[3]]);
> + let blkaddr = u32::from_le_bytes([u[4], u[5], u[6], u[7]]);
> + ChunkIndex {
> + advise,
> + device_id,
> + blkaddr,
> + }
> + }
> +}
> +
> +/// Chunk format used for indicating the chunkbits and chunkindex.
> +#[repr(C)]
> +#[derive(Clone, Copy, Debug)]
> +pub(crate) struct ChunkFormat(pub(crate) u16);
> +
> +impl ChunkFormat {
> + pub(crate) fn is_chunkindex(&self) -> bool {
> + self.0 & CHUNK_FORMAT_INDEX_BIT != 0
> + }
> + pub(crate) fn chunkbits(&self) -> u16 {
> + self.0 & CHUNK_BLKBITS_MASK
> + }

It is recommended to add blank lines between code blocks. This problem
exists in many places in this patch set.

> +}
> +
> +/// Represents the inode spec which is either data or device.
> +#[derive(Clone, Copy, Debug)]
> +#[repr(u32)]
> +pub(crate) enum Spec {
> + Chunk(ChunkFormat),
> + RawBlk(u32),
> + Device(u32),
> + CompressedBlocks(u32),
> + Unknown,
> +}
> +
> +/// Convert the spec from the format of the inode based on the layout.
> +impl From<(&[u8; 4], Layout)> for Spec {
> + fn from(value: (&[u8; 4], Layout)) -> Self {
> + match value.1 {
> + Layout::FlatInline | Layout::FlatPlain => Spec::RawBlk(u32::from_le_bytes(*value.0)),
> + Layout::CompressedFull | Layout::CompressedCompact => {
> + Spec::CompressedBlocks(u32::from_le_bytes(*value.0))
> + }
> + Layout::Chunk => Self::Chunk(ChunkFormat(u16::from_le_bytes([value.0[0], value.0[1]]))),
> + // We don't support compressed inlines or compressed chunks currently.
> + _ => Spec::Unknown,
> + }
> + }
> +}
> +
> +/// Helper functions for Inode Info.
> +impl InodeInfo {
> + const S_IFMT: u16 = 0o170000;
> + const S_IFSOCK: u16 = 0o140000;
> + const S_IFLNK: u16 = 0o120000;
> + const S_IFREG: u16 = 0o100000;
> + const S_IFBLK: u16 = 0o60000;
> + const S_IFDIR: u16 = 0o40000;
> + const S_IFCHR: u16 = 0o20000;
> + const S_IFIFO: u16 = 0o10000;
> + const S_ISUID: u16 = 0o4000;
> + const S_ISGID: u16 = 0o2000;
> + const S_ISVTX: u16 = 0o1000;
> + pub(crate) fn ino(&self) -> u32 {
> + match self {
> + Self::Extended(extended) => extended.i_ino,
> + Self::Compact(compact) => compact.i_ino,
> + }
> + }
> +
> + pub(crate) fn format(&self) -> Format {
> + match self {
> + Self::Extended(extended) => extended.i_format,
> + Self::Compact(compact) => compact.i_format,
> + }
> + }
> +
> + pub(crate) fn file_size(&self) -> Off {
> + match self {
> + Self::Extended(extended) => extended.i_size,
> + Self::Compact(compact) => compact.i_size as u64,
> + }
> + }
> +
> + pub(crate) fn inode_size(&self) -> Off {
> + match self {
> + Self::Extended(_) => 64,
> + Self::Compact(_) => 32,

Self::Extended(_) => size_of::<ExtendedInodeInfo>() as Off,
Self::Compact(_) => size_of::<CompactInodeInfo>() as Off,

> + }
> + }
> +
> + pub(crate) fn spec(&self) -> Spec {
> + let mode = match self {
> + Self::Extended(extended) => extended.i_mode,
> + Self::Compact(compact) => compact.i_mode,
> + };
> +
> + let u = match self {
> + Self::Extended(extended) => &extended.i_u,
> + Self::Compact(compact) => &compact.i_u,
> + };
> +
> + match mode & 0o170000 {
> + 0o40000 | 0o100000 | 0o120000 => Spec::from((u, self.format().layout())),

match mode & Self::S_IFMT {
Self::S_IFDIR | Self::S_IFREG | Self::S_IFLNK => Spec::from((u,
self.format().layout())),

> + // We don't support device inodes currently.
> + _ => Spec::Unknown,
> + }
> + }
> +
> + pub(crate) fn inode_type(&self) -> Type {
> + let mode = match self {
> + Self::Extended(extended) => extended.i_mode,
> + Self::Compact(compact) => compact.i_mode,
> + };
> + match mode & Self::S_IFMT {
> + Self::S_IFDIR => Type::Directory, // Directory
> + Self::S_IFREG => Type::Regular, // Regular File
> + Self::S_IFLNK => Type::Link, // Symbolic Link
> + Self::S_IFIFO => Type::Fifo, // FIFO
> + Self::S_IFSOCK => Type::Socket, // Socket
> + Self::S_IFBLK => Type::Block, // Block
> + Self::S_IFCHR => Type::Character, // Character
> + _ => Type::Unknown,
> + }
> + }
> +
> + pub(crate) fn xattr_size(&self) -> Off {
> + match self {
> + Self::Extended(extended) => {

if extended.i_xattr_icount == 0 {
return 0;
}

to avoid subtract with overflow.

Thanks,
Jianan

> + size_of::<XAttrSharedEntrySummary>() as Off
> + + (size_of::<c_int>() as Off) * (extended.i_xattr_icount as Off - 1)
> + }
> + Self::Compact(_) => 0,
> + }
> + }
> +
> + pub(crate) fn xattr_count(&self) -> u16 {
> + match self {
> + Self::Extended(extended) => extended.i_xattr_icount,
> + Self::Compact(compact) => compact.i_xattr_icount,
> + }
> + }
> +}
> +
> +pub(crate) type CompactInodeInfoBuf = [u8; size_of::<CompactInodeInfo>()];
> +pub(crate) type ExtendedInodeInfoBuf = [u8; size_of::<ExtendedInodeInfo>()];
> +pub(crate) const DEFAULT_INODE_BUF: ExtendedInodeInfoBuf = [0; size_of::<ExtendedInodeInfo>()];
> --
> 2.46.0
>