fixup! feat: add 'allocated' flag to inode data block

Author: AdamStepan

src/inode.c

@@ -255,6 +255,7 @@ struct ex_inode *ex_inode_set(struct ex_inode *dir, const char *name,
 
     if (!entry_address) {
         info("unable to find space for inode in dirinode");
+        // XXX: allocate indirect block
         return NULL;
     }
 
@@ -644,6 +645,58 @@ int ex_inode_rename(struct ex_inode *from_inode, struct ex_inode *to_inode,
     return 0;
 }
 
+static inline int ex_indirect_block_is_allocated(struct ex_inode *i, size_t n) {
+    return i->blocks[n + EX_DIRECT_BLOCKS].address;
+}
+
+static inline int ex_indirect_block_out_of_range(size_t n) {
+    return n > EX_INDIRECT_BLOCKS;
+}
+
+static inline int ex_indirect_block_should_be_loaded(struct ex_block_iterator *it,
+                                             size_t indirect_block_no) {
+    return it->indirect_block_no != indirect_block_no || !it->indirect.data;
+}
+
+struct ex_inode_block ex_inode_block_iterate_indirect(struct ex_inode *inode,
+                                                      struct ex_block_iterator *it) {
+    assert(it->block_number >= EX_DIRECT_BLOCKS);
+
+    size_t indirect_block_no = (it->block_number - EX_DIRECT_BLOCKS) / EX_BLOCK_SIZE;
+    size_t block_idx = (it->block_number - EX_DIRECT_BLOCKS) % EX_BLOCK_SIZE;
+
+    if (ex_indirect_block_out_of_range(indirect_block_no) ||
+        !ex_indirect_block_is_allocated(inode, indirect_block_no)) {
+
+        it->last_block.address = EX_BLOCK_INVALID_ADDRESS;
+        it->last_block.data = NULL;
+        it->last_block.id = EX_BLOCK_INVALID_ID;
+
+        goto done;
+    }
+
+    if (ex_indirect_block_should_be_loaded(it, indirect_block_no)) {
+        size_t indirect_block_address = inode->blocks[indirect_block_no + EX_DIRECT_BLOCKS].address;
+        ssize_t readed = 0;
+        (void)ex_device_read_to_buffer(&readed, it->indirect_buffer,
+                                       indirect_block_address, EX_BLOCK_SIZE);
+        it->indirect.data = it->indirect_buffer;
+    }
+
+    // read the block
+    size_t block_address = it->indirect.data[block_idx];
+    // read the blocks data
+    ssize_t readed = 0;
+    (void)ex_device_read_to_buffer(&readed, it->buffer, block_address, EX_BLOCK_SIZE);
+
+    it->last_block.address = block_address;
+    it->last_block.id = it->block_number;
+    it->last_block.data = it->buffer;
+
+done:
+    return it->last_block;
+}
+
 struct ex_inode_block ex_inode_block_iterate(struct ex_inode *inode,
                                              struct ex_block_iterator *it) {
 
@@ -657,20 +710,18 @@ struct ex_inode_block ex_inode_block_iterate(struct ex_inode *inode,
                                    .address = EX_BLOCK_INVALID_ADDRESS};
 
     if (it->block_number >= EX_DIRECT_BLOCKS) {
-        goto done;
+        return ex_inode_block_iterate_indirect(inode, it);
     }
 
     block.address = inode->blocks[it->block_number].address;
     block.data = it->buffer;
+    block.id = it->block_number;
 
-    // XXX: add buffer into ex_block_iterator and use ex_device_read_to_buffer
-    //      handle read error
-    ssize_t readed = 0;
     // XXX: handle read error
+    ssize_t readed = 0;
     (void)ex_device_read_to_buffer(&readed, it->buffer,
                                    block.address, EX_BLOCK_SIZE);
 
-done:
     it->last_block = block;
     return block;
 }

src/inode.h

@@ -113,8 +113,13 @@ int ex_inode_has_perm(struct ex_inode *ino, ex_permission perm, gid_t gid, uid_t
 
 struct ex_block_iterator {
     struct ex_inode_block last_block;
+    struct ex_inode_block indirect;
+
     size_t block_number;
+    size_t indirect_block_no;
+
     char buffer[EX_BLOCK_SIZE];
+    char indirect_buffer[EX_BLOCK_SIZE];
 };
 
 struct ex_entry_iterator {