fix: extent tree split

ext4_test/src/main.rs

@@ -1,4 +1,5 @@
 use ext4_rs::{Block, BlockDevice, Ext4, BLOCK_SIZE};
+use log::warn;
 use simple_logger::SimpleLogger;
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Seek, SeekFrom, Write};
@@ -22,6 +23,7 @@ impl BlockDevice for BlockFile {
     fn read_block(&self, block_id: u64) -> Block {
         let mut file = &self.0;
         let mut buffer = [0u8; BLOCK_SIZE];
+        // warn!("read_block {}", block_id);
         let _r = file.seek(SeekFrom::Start(block_id * BLOCK_SIZE as u64));
         let _r = file.read_exact(&mut buffer);
         Block::new(block_id, buffer)
@@ -29,6 +31,7 @@ impl BlockDevice for BlockFile {
 
     fn write_block(&self, block: &Block) {
         let mut file = &self.0;
+        // warn!("write_block {}", block.block_id);
         let _r = file.seek(SeekFrom::Start(block.block_id * BLOCK_SIZE as u64));
         let _r = file.write_all(&block.data);
     }
@@ -91,7 +94,7 @@ fn read_write_test(ext4: &mut Ext4) {
 }
 
 fn large_read_write_test(ext4: &mut Ext4) {
-    let wbuffer = vec![99u8; 1024 * 1024 * 2];
+    let wbuffer = vec![99u8; 1024 * 1024 * 16];
     let mut wfile = ext4.open("d3/f2", "w+", true).expect("open failed");
     ext4.write(&mut wfile, &wbuffer).expect("write failed");
 

src/ext4/extent.rs

@@ -189,33 +189,40 @@ impl Ext4 {
         let right_bid = self.alloc_block(inode_ref).unwrap();
         let mut right_block = self.block_device.read_block(right_bid);
         let mut right_node = ExtentNodeMut::from_bytes(&mut right_block.data);
-
+        
         // Insert the split half to right node
         right_node.init(0, 0);
-        for (i, extent) in split.iter().enumerate() {
-            *right_node.fake_extent_mut_at(i) = *extent;
+        for (i, fake_extent) in split.iter().enumerate() {
+            *right_node.fake_extent_mut_at(i) = *fake_extent;
         }
         right_node
             .header_mut()
             .set_entries_count(split.len() as u16);
-        // Create an extent index
+        // Create an extent index pointing to the right node
         let extent_index =
             ExtentIndex::new(right_node.extent_index_at(0).start_lblock(), right_bid);
-        right_block.sync_to_disk(self.block_device.clone());
 
         let res;
+        let parent_depth;
         if parent_pblock == 0 {
             // Parent is root
             let mut parent_node = inode_ref.inode.extent_node_mut();
+            parent_depth = parent_node.header().depth();
             res = parent_node.insert_extent_index(&extent_index, child_pos + 1);
             self.write_inode_without_csum(inode_ref);
         } else {
             // Parent is not root
             let mut parent_block = self.block_device.read_block(parent_pblock);
             let mut parent_node = ExtentNodeMut::from_bytes(&mut parent_block.data);
+            parent_depth = parent_node.header().depth();
             res = parent_node.insert_extent_index(&extent_index, child_pos + 1);
             parent_block.sync_to_disk(self.block_device.clone());
         }
+
+        // Right node is the child of parent, so its depth is 1 less than parent
+        right_node.header_mut().set_depth(parent_depth - 1);
+        right_block.sync_to_disk(self.block_device.clone());
+
         res
     }
 
@@ -232,20 +239,21 @@ impl Ext4 {
         let mut l_block = self.block_device.read_block(l_bid);
         let mut r_block = self.block_device.read_block(r_bid);
 
-        // Load root, left, right
+        // Load root, left, right nodes
         let mut root = inode_ref.inode.extent_node_mut();
         let mut left = ExtentNodeMut::from_bytes(&mut l_block.data);
         let mut right = ExtentNodeMut::from_bytes(&mut r_block.data);
 
-        // Copy the left half to left_node
-        left.init(0, 0);
+        // Copy the left half to left node
+        left.init(root.header().depth(), 0);
         for i in 0..root.header().entries_count() as usize {
             *left.fake_extent_mut_at(i) = *root.fake_extent_at(i);
         }
         left.header_mut()
             .set_entries_count(root.header().entries_count());
-        // Copy the right half to right_node
-        right.init(0, 0);
+
+        // Copy the right half to right node
+        right.init(root.header().depth(), 0);
         for (i, fake_extent) in split.iter().enumerate() {
             *right.fake_extent_mut_at(i) = *fake_extent;
         }