Fully implement the journal type

This fills in the `Journal` struct and implements the rest of the
`Journal::load` method.

Author: nicholasbishop

src/journal.rs

@@ -7,36 +7,55 @@
 // except according to those terms.
 
 mod block_header;
-#[expect(unused)] // TODO
 mod block_map;
 mod commit_block;
 mod descriptor_block;
-#[expect(unused)] // TODO
 mod superblock;
 
-use crate::{Ext4, Ext4Error};
+use crate::error::Ext4Error;
+use crate::inode::Inode;
+use crate::Ext4;
+use block_map::{load_block_map, BlockMap};
+use superblock::JournalSuperblock;
 
 #[derive(Debug)]
 pub(crate) struct Journal {
-    // TODO: add journal data.
+    block_map: BlockMap,
 }
 
 impl Journal {
     /// Create an empty journal.
     pub(crate) fn empty() -> Self {
-        Self {}
+        Self {
+            block_map: BlockMap::new(),
+        }
     }
 
     /// Load a journal from the filesystem.
+    ///
+    /// If the filesystem has no journal, an empty journal is returned.
+    ///
+    /// Note: ext4 is all little-endian, except for the journal, which
+    /// is all big-endian.
     pub(crate) fn load(fs: &Ext4) -> Result<Self, Ext4Error> {
-        let Some(_journal_inode) = fs.0.superblock.journal_inode else {
+        let Some(journal_inode) = fs.0.superblock.journal_inode else {
             // Return an empty journal if this filesystem does not have
             // a journal.
             return Ok(Self::empty());
         };
 
-        // TODO: actually load the journal.
+        let journal_inode = Inode::read(fs, journal_inode)?;
+        let superblock = JournalSuperblock::load(fs, &journal_inode)?;
+        let block_map = load_block_map(fs, &superblock, &journal_inode)?;
 
-        Ok(Self {})
+        Ok(Self { block_map })
+    }
+
+    /// Map from an absolute block index to a block in the journal.
+    ///
+    /// If the journal does not contain a replacement for the input
+    /// block, the input block is returned.
+    pub(crate) fn map_block_index(&self, block_index: u64) -> u64 {
+        *self.block_map.get(&block_index).unwrap_or(&block_index)
     }
 }

src/lib.rs

@@ -303,6 +303,8 @@ impl Ext4 {
             })
         };
 
+        let block_index = self.0.journal.map_block_index(block_index);
+
         // The first 1024 bytes are reserved for non-filesystem
         // data. This conveniently allows for something like a null
         // pointer check.