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

Author: AdamStepan

CMakeLists.txt

@@ -26,7 +26,6 @@ if (TESTS)
 endif()
 
 if (DEBUG)
-    add_compile_options(-ggdb)
     set(CMAKE_BUILD_TYPE Debug)
 endif()
 

src/inode.c

@@ -89,24 +89,23 @@ ex_status ex_inode_allocate_indirect_block(struct ex_inode *inode, size_t n) {
 
         debug("allocating parent inode: %zu", parent_block_no);
 
-        size_t address = ex_super_allocate_block();
-        // we were unable to allocate parent block, there is nothing
-        // we can do
-        if (address == EX_BLOCK_INVALID_ADDRESS) {
-            warning("unable to allocate block: %zu for inode: %zu",
+        struct ex_inode_block block;
+
+        if (ex_super_allocate_data_block(&block) != OK) {
+            warning("unable to allocate parent block: %zu for inode: (%lu)",
                     n, inode->number);
             return INODE_BLOCK_ALLOCATION_FAILED;
         }
 
-        debug("parent inode is at: %zu", address);
+        debug("parent inode is at: %zu", block.address);
 
-        inode->blocks[parent_block_no].address = address;
+        inode->blocks[parent_block_no].address = block.address;
         inode->blocks[parent_block_no].allocated = 1;
         inode->nblocks++;
 
         // clear the block space
         char empty[EX_BLOCK_SIZE] = {0};
-        ex_device_write(address, (char *)empty, sizeof(empty));
+        ex_device_write(block.address, (char *)empty, sizeof(empty));
 
         ex_inode_flush(inode);
     }
@@ -132,17 +131,17 @@ ex_status ex_inode_allocate_indirect_block(struct ex_inode *inode, size_t n) {
 
         debug("allocating new indirect block");
 
-        size_t address = ex_super_allocate_block();
-
-        if (address == EX_BLOCK_INVALID_ADDRESS) {
+        struct ex_inode_block block;
+        if (ex_super_allocate_data_block(&block) != OK) {
+            warning("unable to allocate new indirect block: %zu", n);
             return INODE_BLOCK_ALLOCATION_FAILED;
         }
 
         debug("block %zu in parent %zu is at (%zu)", block_off,
-                parent_block_no, address);
+                parent_block_no, block.address);
 
         parent_block[block_off].allocated = 1;
-        parent_block[block_off].address = address;
+        parent_block[block_off].address = block.address;
 
         ex_device_write(parent_block_address,
                         (char *)parent_block,
@@ -162,17 +161,17 @@ ex_status ex_inode_allocate_blocks(struct ex_inode *inode) {
 
     for (size_t i = 0; i < EX_DIRECT_BLOCKS; i++) {
 
-        struct ex_inode_block block;
+        struct ex_inode_block block_;
 
-        if ((status = ex_super_allocate_data_block(&block)) != OK) {
+        if ((status = ex_super_allocate_data_block(&block_)) != OK) {
             warning("failing to allocate nth (%lu) block", i);
             goto done;
         }
 
         struct ex_data_block *block = &inode->blocks[i];
 
         inode->nblocks += 1;
-        block->address = address;
+        block->address = block_.address;
         block->allocated = 1;
     }
 
@@ -649,6 +648,7 @@ ex_status ex_inode_unlink(struct ex_inode *dir, const char *name) {
     }
 
     entry->free = 1;
+    entry->name[0] = '-';
 
     ex_inode_flush(&inode);
     ex_dir_entry_flush(entry_address, entry);
@@ -718,6 +718,9 @@ ssize_t ex_inode_write(struct ex_inode *ino, size_t off, const char *data,
     size_t start_block_idx = off / EX_BLOCK_SIZE;
     size_t start_block_off = off % EX_BLOCK_SIZE;
 
+    info("start_block=%zu, start_block_off=%zu", start_block_idx, start_block_off);
+    info("max_blocks=%zu", ex_inode_max_blocks());
+
     if (start_block_idx >= ex_inode_max_blocks() ||
         (start_block_off + amount / EX_BLOCK_SIZE) >= ex_inode_max_blocks()) {
         return -1;
@@ -727,13 +730,16 @@ ssize_t ex_inode_write(struct ex_inode *ino, size_t off, const char *data,
         ino->size += (off + amount) - ino->size;
     }
 
+    // TODO
     block_address addr = ino->blocks[start_block_idx].address;
     char allocated = ino->blocks[start_block_idx].allocated;
 
     if (!allocated) {
-        // XXX: do allocation
+        warning("start block (%zu) is not allocated", start_block_idx);
     }
 
+    debug("writing to %zu", addr);
+
     ex_device_write(ino->address, (void *)ino, sizeof(struct ex_inode));
     ex_device_write(addr + start_block_off, data, amount);
 
@@ -864,7 +870,7 @@ struct ex_inode_block ex_inode_block_iterate_indirect(struct ex_inode *inode,
     // XXX: this is the end, my only friend, the end
     struct ex_data_block block = ((struct ex_data_block *)it->indirect.data)[block_idx];
 
-    debug("ba: %zu, aloc: %zu", block.address, block.allocated);
+    debug("ba: %zu, aloc: %i", block.address, (int)block.allocated);
 
     // block in the indirect block is not allocated
     if (!block.allocated) {

test/test_mkfs_device_size.c

@@ -23,7 +23,10 @@ void test_mkfs_device_size(void) {
 
     // the size of the super block an inode bitmap and a data bitmap rounded
     // to block size
-    size_t expected_device_size = 3 * EX_BLOCK_SIZE;
+    size_t expected_device_size = round_block(sizeof(struct ex_super_block));
+    expected_device_size += round_block(super_block->bitmap.size);
+    expected_device_size += round_block(super_block->inode_bitmap.size);
+
     // size for `ninodes` inodes
     expected_device_size += EX_BLOCK_SIZE * ninodes;
     // number of data blocks for `ninodes` inodes

test/test_write_max_size.c

@@ -9,12 +9,15 @@
 void test_write_max_size(void) {
     // create new device
     unlink(EX_DEVICE);
+
     ex_mkfs_test_init();
 
-    size_t max_size = EX_DIRECT_BLOCKS * EX_BLOCK_SIZE - 1;
-    char data[max_size];
+    size_t max_size = ex_inode_max_blocks() * EX_BLOCK_SIZE - 1;
+    // +1 because of EFBIG
+    char *data = malloc(max_size + 1);
+    g_assert(data);
 
-    memset(data, 'a', sizeof(data));
+    memset(data, 'a', max_size + 1);
 
     // create new file
     int rv = ex_create("/file", S_IRWXU, getgid(), getuid());