Migrate to latest versions of dependencies (#9)

Author: GodTamIt

.github/workflows/rust-build.yml

@@ -39,3 +39,6 @@ jobs:
 
       - name: Check formatting
         run: cargo fmt --check
+
+      - name: Run lints
+        run: cargo clippy -- -D clippy::all

Cargo.toml

@@ -2,18 +2,23 @@
 name = "btrfs-diskformat"
 version = "0.4.0"
 authors = ["Christopher Tam <[email protected]>"]
-edition = "2021"
+edition = "2024"
 description = "An implementation of the BTRFS disk format."
 readme = "README.md"
 repository = "https://github.com/GodTamIt/btrfs-diskformat"
 license = "BSD-2-Clause"
 keywords = ["btrfs", "filesystem", "diskformat"]
 categories = ["filesystem", "no-std"]
 
+[features]
+default = []
+alloc = ["zerocopy/alloc"]
+std = ["strum/std", "zerocopy/std"]
+
 [dependencies]
-byteorder = { version = "^1.4.3", default-features = false }
-bitflags = "^1.3"
-num_enum = { version = "^0.5", default-features = false }
+bitflags = "^2.9"
+num_enum = { version = "^0.7", default-features = false }
 static_assertions = "^1.1.0"
-strum = { version = "^0.23", features = ["derive"], default-features = false }
-zerocopy = "^0.4.0"
+strum = { version = "^0.27", features = ["derive"], default-features = false }
+zerocopy = { version = "^0.8", default-features = false }
+zerocopy-derive = "^0.8"

README.md

@@ -13,9 +13,15 @@ Clean-room implementation of the [btrfs] disk format in Rust.
 
 See the [LICENSE-BSD](LICENSE-BSD) file in this repository for more information.
 
+## Cargo Features
+
+- `alloc`: Enables allocation and the `alloc` feature in `zerocopy`.
+- `std`: By default, the crate is `no_std`. This enables `std` features from
+  the `zerocopy` and `strum` dependencies.
+
 ## Contributing
 
 Because this codebase is developed without knowledge of the Linux btrfs source code and is released under a more permissive license(s) than GPLv2, development is heavily dependent on information released on the [btrfs wiki] and reverse engineering the effects of operations made by `btrfs-progs` and other utilities. As a result, contributions to this codebase must strictly follow the same siloed approach.
 
 [btrfs]: https://btrfs.wiki.kernel.org/index.php/Main_Page
-[btrfs wiki]: https://btrfs.wiki.kernel.org/index.php/Main_Page
+[btrfs wiki]: https://btrfs.wiki.kernel.org/index.php/Main_Page

src/aliases.rs

@@ -44,7 +44,7 @@ pub type btrfs_dev_extent = DevExtent;
 // extent
 pub type btrfs_block_group_item = BlockGroupItem;
 pub type btrfs_extent_data_ref = ExtentDataRef;
-pub type btrfs_extent_inline_ref = ExtentInlineRef;
+pub type btrfs_extent_inline_ref = ExtentInlineRefHeader;
 pub type btrfs_shared_data_ref = SharedDataRef;
 
 pub const BTRFS_BLOCK_GROUP_DATA: u64 = AllocationType::DATA.bits();

src/chunk/chunk.rs

@@ -1,9 +1,10 @@
-use {
-    crate::Stripe,
-    byteorder::LE,
-    static_assertions::const_assert_eq,
-    zerocopy::{AsBytes, FromBytes, Unaligned, U16, U32, U64},
+use crate::Stripe;
+use static_assertions::const_assert_eq;
+use zerocopy::{
+    CastError, FromBytes as _,
+    little_endian::{U16 as U16LE, U32 as U32LE, U64 as U64LE},
 };
+use zerocopy_derive::*;
 
 /// This structure contains the mapping from a virtualized usable byte range within the backing
 /// storage to a set of one or more stripes on individual backing devices. In addition to the
@@ -13,40 +14,107 @@ use {
 /// many struct [`Stripe`] structures as specified in the [`num_stripes`] and [`sub_stripes`]
 /// fields.
 ///
+/// For the dynamically-sized version of this type with the stripes following, see [`ChunkDynamic`].
+///
 /// [`Stripe`]: crate::Stripe
 /// [`num_stripes`]: Chunk::num_stripes
 /// [`sub_stripes`]: Chunk::sub_stripes
-#[derive(Copy, Clone, Debug, AsBytes, FromBytes, Unaligned)]
+#[derive(Copy, Clone, Debug, Hash, IntoBytes, FromBytes, Unaligned, KnownLayout, Immutable)]
 #[repr(C, packed)]
 pub struct Chunk {
     /// The size of this chunk, in bytes.
-    pub length: U64<LE>,
+    pub length: U64LE,
+
+    /// The object ID of the root referencing this chunk. This is always the ID of an extent root.
+    pub owner: U64LE,
+
+    /// The replication stripe length.
+    pub stripe_len: U64LE,
+
+    /// Flags indicating allocation type and replication policy.
+    pub chunk_type: U64LE,
+
+    /// The optimal I/O alignment for this chunk.
+    pub io_align: U32LE,
+
+    /// The optimal I/O width for this chunk.
+    pub io_width: U32LE,
+
+    /// The minimal I/O size for this chunk.
+    pub sector_size: U32LE,
+
+    /// The number of replication stripes.
+    pub num_stripes: U16LE,
+
+    /// The number of sub-stripes. This is only used for RAID-10.
+    ///
+    /// This is 2 for RAID-10, and 1 for all other chunk types.
+    pub sub_stripes: U16LE,
+}
+const_assert_eq!(core::mem::size_of::<Chunk>(), 48);
+
+impl Chunk {
+    /// A convenience method for converting a [`Chunk`] into a [`ChunkDynamic`].
+    ///
+    /// For a safe version, use [`ChunkDynamic::ref_from_prefix_with_elems`].
+    ///
+    /// # Safety
+    /// This function is unsafe because it assumes that the bytes following the `Chunk` structure
+    /// are valid and contain the expected number of `Stripe` structures as specified by
+    /// `num_stripes`. If this assumption is violated, it may lead to undefined behavior.
+    pub unsafe fn into_dynamic(
+        &self,
+        num_stripes: usize,
+    ) -> Result<&ChunkDynamic, CastError<&[u8], ChunkDynamic>> {
+        // This is simple arithmetic, since this is a packed structure.
+        let expected_size =
+            core::mem::size_of::<Chunk>() + num_stripes * core::mem::size_of::<Stripe>();
+
+        // Safety: We assume the bytes for `num_stripes` after the `Chunk` structure are valid, as
+        // part of the contract of this function.
+        let bytes = unsafe {
+            core::slice::from_raw_parts(self as *const Chunk as *const u8, expected_size)
+        };
+
+        ChunkDynamic::ref_from_prefix_with_elems(bytes, num_stripes).map(|(chunk, _)| chunk)
+    }
+}
+
+/// This structure contains the mapping from a virtualized usable byte range within the backing
+/// storage to a set of one or more stripes on individual backing devices. In addition to the
+/// mapping, hints on optimal I/O parameters for this chunk. It is associated with `CHUNK_ITEM`.
+///
+/// For the constant-sized version of the type, see [`Chunk`].`
+#[derive(IntoBytes, FromBytes, Unaligned, KnownLayout, Immutable)]
+#[repr(C, packed)]
+pub struct ChunkDynamic {
+    /// The size of this chunk, in bytes.
+    pub length: U64LE,
 
     /// The object ID of the root referencing this chunk. This is always the ID of an extent root.
-    pub owner: U64<LE>,
+    pub owner: U64LE,
 
     /// The replication stripe length.
-    pub stripe_len: U64<LE>,
+    pub stripe_len: U64LE,
 
     /// Flags indicating allocation type and replication policy.
-    pub r#type: U64<LE>,
+    pub chunk_type: U64LE,
 
     /// The optimal I/O alignment for this chunk.
-    pub io_align: U32<LE>,
+    pub io_align: U32LE,
 
     /// The optimal I/O width for this chunk.
-    pub io_width: U32<LE>,
+    pub io_width: U32LE,
 
     /// The minimal I/O size for this chunk.
-    pub sector_size: U32<LE>,
+    pub sector_size: U32LE,
 
     /// The number of replication stripes.
-    pub num_stripes: U16<LE>,
+    pub num_stripes: U16LE,
 
     /// The number of sub-stripes. This is only used for RAID-10.
-    pub sub_stripes: U16<LE>,
+    pub sub_stripes: U16LE,
 
     /// The first of one or more stripes that map to device extents.
-    pub stripe: Stripe,
+    pub stripe: [Stripe],
 }
-const_assert_eq!(core::mem::size_of::<Chunk>(), 80);

src/chunk/mod.rs

@@ -1,3 +1,4 @@
+#[allow(clippy::module_inception)]
 mod chunk;
 mod stripe;
 

src/chunk/stripe.rs

@@ -1,25 +1,25 @@
-use {
-    crate::UuidBytes,
-    byteorder::LE,
-    static_assertions::const_assert_eq,
-    zerocopy::{AsBytes, FromBytes, Unaligned, U64},
-};
+use crate::UuidBytes;
+use static_assertions::const_assert_eq;
+use zerocopy::little_endian::U64 as U64LE;
+use zerocopy_derive::*;
 
 /// This structure is used to define the backing device storage that compose a
 /// [`Chunk`].
 ///
 /// [`Chunk`]: crate::Chunk
-#[derive(Copy, Clone, Debug, Hash, PartialEq, AsBytes, FromBytes, Unaligned)]
+#[derive(
+    Copy, Clone, Debug, Hash, PartialEq, IntoBytes, FromBytes, Unaligned, KnownLayout, Immutable,
+)]
 #[repr(C, packed)]
 pub struct Stripe {
     /// The ID of the device that contains this stripe.
-    pub devid: U64<LE>,
+    pub devid: U64LE,
 
     /// Location of the start of the stripe, in bytes.
     ///
     /// The length is determined by the `stripe_len` field of the associated
     /// `Chunk`.
-    pub offset: U64<LE>,
+    pub offset: U64LE,
 
     /// UUID of the device that contains this stripe.
     ///

src/core/dev_item.rs

@@ -1,46 +1,44 @@
-use {
-    crate::UuidBytes,
-    byteorder::LE,
-    static_assertions::const_assert_eq,
-    zerocopy::{AsBytes, FromBytes, Unaligned, U32, U64},
-};
+use crate::UuidBytes;
+use static_assertions::const_assert_eq;
+use zerocopy::little_endian::{U32 as U32LE, U64 as U64LE};
+use zerocopy_derive::*;
 
 /// Represents a complete block device.
-#[derive(Copy, Clone, Debug, AsBytes, FromBytes, Unaligned)]
+#[derive(Copy, Clone, Debug, Hash, IntoBytes, FromBytes, Unaligned, KnownLayout, Immutable)]
 #[repr(C, packed)]
 pub struct DevItem {
     /// The internal btrfs device ID.
     ///
     /// This should match the devid found in the filesystem's list of devices.
-    pub devid: U64<LE>,
+    pub devid: U64LE,
 
     /// The size of the device.
-    pub total_bytes: U64<LE>,
+    pub total_bytes: U64LE,
 
     /// The bytes in use by the filesystem on the device.
-    pub bytes_used: U64<LE>,
+    pub bytes_used: U64LE,
 
     /// The optimal I/O alignment for this device.
-    pub io_align: U32<LE>,
+    pub io_align: U32LE,
 
     /// The optimal I/O width for this device.
-    pub io_width: U32<LE>,
+    pub io_width: U32LE,
 
     /// The minimum I/O size for this device.
-    pub sector_size: U32<LE>,
+    pub sector_size: U32LE,
 
     /// The type and info for this device.
-    pub r#type: U64<LE>,
+    pub dev_type: U64LE,
 
     /// The expected generation for this device.
-    pub generation: U64<LE>,
+    pub generation: U64LE,
 
     /// The starting byte of this partition on the device, to allow for stripe
     /// alignment.
-    pub start_offset: U64<LE>,
+    pub start_offset: U64LE,
 
     /// Grouping information for allocation decisions.
-    pub dev_group: U32<LE>,
+    pub dev_group: U32LE,
 
     /// The seek speed of the device on a scale from 0 to 100, where 100 is the
     /// fastest.

src/core/inode_item.rs

@@ -1,61 +1,59 @@
-use {
-    crate::Time,
-    bitflags::bitflags,
-    byteorder::LE,
-    static_assertions::const_assert_eq,
-    zerocopy::{AsBytes, FromBytes, Unaligned, U32, U64},
-};
+use crate::Time;
+use bitflags::bitflags;
+use static_assertions::const_assert_eq;
+use zerocopy::little_endian::{U32 as U32LE, U64 as U64LE};
+use zerocopy_derive::*;
 
 /// Contains traditional inode data and attributes.
-#[derive(Copy, Clone, Debug, AsBytes, FromBytes, Unaligned)]
+#[derive(Copy, Clone, Debug, Hash, IntoBytes, FromBytes, Unaligned, KnownLayout, Immutable)]
 #[repr(C, packed)]
 pub struct InodeItem {
     // FIXME: add documentation!
-    pub generation: U64<LE>,
+    pub generation: U64LE,
 
     // FIXME: add documentation!
-    pub transid: U64<LE>,
+    pub transid: U64LE,
 
     /// The size of a file, in bytes.
-    pub size: U64<LE>,
+    pub size: U64LE,
 
     /// The size allocated to the file, in bytes.
     ///
     /// This is equal to the sum of all of the extent data for the inode.
     /// This is 0 for directories.
-    pub nbytes: U64<LE>,
+    pub nbytes: U64LE,
 
     /// This contains the byte offset of a block group when structure is a free space inode.
     ///
     /// This value is unused for normal inodes.
-    pub block_group: U64<LE>,
+    pub block_group: U64LE,
 
     /// Count of inode references for the inode.
     ///
     /// When used outside of a file tree, this value is 1.
-    pub nlink: U32<LE>,
+    pub nlink: U32LE,
 
     /// The user ID of the owner in Unix.
-    pub uid: U32<LE>,
+    pub uid: U32LE,
 
     /// The group ID of the group owner in Unix.
-    pub gid: U32<LE>,
+    pub gid: U32LE,
 
     /// The Unix protection mode.
-    pub mode: U32<LE>,
+    pub mode: U32LE,
 
     /// The device identifier (if a special file).
-    pub rdev: U64<LE>,
+    pub rdev: U64LE,
 
     /// Flags for the inode. See [InodeFlags] for values.
-    pub flags: U64<LE>,
+    pub flags: U64LE,
 
     /// A sequence number used for compatibility with NFS.
     ///
     /// This value is initialized to 0 and incremented each time [mtime] is updated.
     ///
     /// [mtime]: InodeItem::mtime
-    pub sequence: U64<LE>,
+    pub sequence: U64LE,
 
     pub _unused: [u64; 4],