Support for extents

Now the entry of index block of the file point to a extent which
contain 8 consecutive physical blocks instead of a single block.

Also modify the block allocator so we can allocate consecutive blocks
at once (also first fit).

Future work:
    A extent can contain up to `~(uint32_t) 0` blocks, so we may
    allocate more consecutive blocks for a extent with smarter block
    allocator and delayed allocation.

    Use extent tree to increase the number of extent a file can have.

Author: colinyoyo26

.clang-format

@@ -13,3 +13,6 @@ UseTab: Never
 IndentWidth: 4
 BreakBeforeBraces: Linux
 AccessModifierOffset: -4
+ForEachMacros:
+  - 'for_each_set_bit'
+  - 'for_each_set_bit_from'

Makefile

@@ -1,5 +1,5 @@
 obj-m += simplefs.o
-simplefs-objs := fs.o super.o inode.o file.o dir.o
+simplefs-objs := fs.o super.o inode.o file.o dir.o extent.o
 
 KDIR ?= /lib/modules/$(shell uname -r)/build
 

README.md

@@ -79,47 +79,74 @@ Each block is 4 KiB large.
 The superblock is the first block of the partition (block 0). It contains the partition's metadata, such as the number of blocks, number of inodes, number of free inodes/blocks, ...
 
 ### Inode store
-Contains all the inodes of the partition. The maximum number of inodes is equal to the number of blocks of the partition. Each inode contains 40 B of data: standard data such as file size and number of used blocks, as well as a simplefs-specific field called `index_block`. This block contains:
+Contains all the inodes of the partition. The maximum number of inodes is equal to the number of blocks of the partition. Each inode contains 72 B of data: standard data such as file size and number of used blocks, as well as a simplefs-specific union field contain `dir_block` and `ei_block`. This block contains:
   - for a directory: the list of files in this directory. A directory can contain at most 128 files, and filenames are limited to 28 characters to fit in a single block.
   ```
   inode
   +-----------------------+
   | i_mode = IFDIR | 0755 |            block 123
-  | index_block = 123 ----|-------->  +-----------+
+  | dir_block = 123 ----|-------->  +-----------+
   | i_size = 4 KiB        |         0 | 24 (foo)  |
-  | i_blockcs = 1         |           |-----------|
+  | i_blocks = 1          |           |-----------|
   +-----------------------+         1 | 45 (bar)  |
                                       |-----------|
-                                        ...
+                                      | ...       |
                                       |-----------|
                                   127 | 0         |
                                       +-----------+
   ```
-  - for a file: the list of blocks containing the actual data of this file. Since block IDs are stored as 32-bit values, at most 1024 links fit in a single block, limiting the size of a file to 4 MiB.
+  - for a file: the list of extents containing the actual data of this file. Since block IDs are stored as `sizeof(struct simplefs_extent)` bytes values, at most 341 links fit in a single block, limiting the size of a file to around 10.65 MiB (10912 KiB).
   ```
-  inode                                                block 94
-  +-----------------------+                           +--------+
-  | i_mode = IFDIR | 0644 |          block 93         |        |    block 99
-  | index_block = 93  ----|------>  +---------+       |        |   +--------+
-  | i_size = 10 KiB       |       0 | 94   ---|-----> +--------+   |        |
-  | i_blockcs = 4         |         |---------|                    |        |
-  +-----------------------+       1 | 99   ---|------------------> +--------+
-                                    |---------|
-                                  2 | 66   ---|----->  block 66
-                                    |---------|       +--------+
-                                      ...             |        |
-                                    |---------|       |        |
-                                127 | 0       |       +--------+
-                                    +---------+
+  inode                                                
+  +-----------------------+                           
+  | i_mode = IFDIR | 0644 |          block 93       
+  | ei_block = 93     ----|------>  +----------------+      
+  | i_size = 10 KiB       |       0 | ee_block  = 0  |     
+  | i_blocks = 25         |         | ee_len    = 8  |      extent 94 
+  +-----------------------+         | ee_start  = 94 |---> +--------+
+                                    |----------------|     |        |     
+                                  1 | ee_block  = 8  |     +--------+
+                                    | ee_len    = 8  |      extent 99
+                                    | ee_start  = 99 |---> +--------+ 
+                                    |----------------|     |        |
+                                  2 | ee_block  = 16 |     +--------+
+                                    | ee_len    = 8  |      extent 66 
+                                    | ee_start  = 66 |---> +--------+
+                                    |----------------|     |        |
+                                    | ...            |     +--------+
+                                    |----------------|  
+                                341 | ee_block  = 0  | 
+                                    | ee_len    = 0  |
+                                    | ee_start  = 0  |
+                                    +----------------+
   ```
+### Extent support
+The extent covers consecutive blocks, we allocate consecutive disk blocks for it at a single time. It is described by `struct simplefs_extent` which contains three members:
+- `ee_block`: first logical block extent covers.
+- `ee_len`: number of blocks covered by extent.
+- `ee_start`: first physical block extent covers.
+```
+struct simplefs_extent
+  +----------------+                           
+  | ee_block =  0  |    
+  | ee_len   =  200|              extent
+  | ee_start =  12 |-----------> +---------+
+  +----------------+    block 12 |         |
+                                 +---------+
+                              13 |         |
+                                 +---------+
+                                 | ...     |
+                                 +---------+
+                             211 |         |
+                                 +---------+
 
+```
 ## TODO
 
 - Bugs
     * Fail to support longer filename
     * Directory will be full if more than 128 files
     * Fail to show `.` and `..` with `ls -a` command
-- support for extents
 - journalling support
 
 ## License

bitmap.h

@@ -5,22 +5,27 @@
 #include "simplefs.h"
 
 /*
- * Return the first free bit (set to 1) in a given in-memory bitmap spanning
- * over multiple blocks and clear it.
- * Return 0 if no free bit found (we assume that the first bit is never free
- * because of the superblock and the root inode, thus allowing us to use 0 as an
- * error value).
+ * Return the first bit we found and clear the the following `len` consecutive
+ * free bit(s) (set to 1) in a given in-memory bitmap spanning over multiple
+ * blocks. Return 0 if no enough free bit(s) were found (we assume that the
+ * first bit is never free because of the superblock and the root inode, thus
+ * allowing us to use 0 as an error value).
  */
-static inline uint32_t get_first_free_bit(unsigned long *freemap,
-                                          unsigned long size)
+static inline uint32_t get_first_free_bits(unsigned long *freemap,
+                                           unsigned long size,
+                                           uint32_t len)
 {
-    uint32_t ino = find_first_bit(freemap, size);
-    if (ino == size)
-        return 0;
-
-    bitmap_clear(freemap, ino, 1);
-
-    return ino;
+    uint32_t bit, prev = 0, count = 0;
+    for_each_set_bit (bit, freemap, size) {
+        if (prev != bit - 1)
+            count = 0;
+        prev = bit;
+        if (++count == len) {
+            bitmap_clear(freemap, bit - len + 1, len);
+            return bit - len + 1;
+        }
+    }
+    return 0;
 }
 
 /*
@@ -29,54 +34,59 @@ static inline uint32_t get_first_free_bit(unsigned long *freemap,
  */
 static inline uint32_t get_free_inode(struct simplefs_sb_info *sbi)
 {
-    uint32_t ret = get_first_free_bit(sbi->ifree_bitmap, sbi->nr_inodes);
+    uint32_t ret = get_first_free_bits(sbi->ifree_bitmap, sbi->nr_inodes, 1);
     if (ret)
         sbi->nr_free_inodes--;
     return ret;
 }
 
 /*
- * Return an unused block number and mark it used.
- * Return 0 if no free block was found.
+ * Return `len` unused block(s) number and mark it used.
+ * Return 0 if no enough free block(s) were found.
  */
-static inline uint32_t get_free_block(struct simplefs_sb_info *sbi)
+static inline uint32_t get_free_blocks(struct simplefs_sb_info *sbi,
+                                       uint32_t len)
 {
-    uint32_t ret = get_first_free_bit(sbi->bfree_bitmap, sbi->nr_blocks);
+    uint32_t ret = get_first_free_bits(sbi->bfree_bitmap, sbi->nr_blocks, len);
     if (ret)
-        sbi->nr_free_blocks--;
+        sbi->nr_free_blocks -= len;
     return ret;
 }
 
-/* Mark the i-th bit in freemap as free (i.e. 1) */
-static inline int put_free_bit(unsigned long *freemap,
-                               unsigned long size,
-                               uint32_t i)
+
+/* Mark the `len` bit(s) from i-th bit in freemap as free (i.e. 1) */
+static inline int put_free_bits(unsigned long *freemap,
+                                unsigned long size,
+                                uint32_t i,
+                                uint32_t len)
 {
     /* i is greater than freemap size */
-    if (i > size)
+    if (i + len - 1 > size)
         return -1;
 
-    bitmap_set(freemap, i, 1);
+    bitmap_set(freemap, i, len);
 
     return 0;
 }
 
 /* Mark an inode as unused */
 static inline void put_inode(struct simplefs_sb_info *sbi, uint32_t ino)
 {
-    if (put_free_bit(sbi->ifree_bitmap, sbi->nr_inodes, ino))
+    if (put_free_bits(sbi->ifree_bitmap, sbi->nr_inodes, ino, 1))
         return;
 
     sbi->nr_free_inodes++;
 }
 
-/* Mark a block as unused */
-static inline void put_block(struct simplefs_sb_info *sbi, uint32_t bno)
+/* Mark len block(s) as unused */
+static inline void put_blocks(struct simplefs_sb_info *sbi,
+                              uint32_t bno,
+                              uint32_t len)
 {
-    if (put_free_bit(sbi->bfree_bitmap, sbi->nr_blocks, bno))
+    if (put_free_bits(sbi->bfree_bitmap, sbi->nr_blocks, bno, len))
         return;
 
-    sbi->nr_free_blocks++;
+    sbi->nr_free_blocks += len;
 }
 
 #endif /* SIMPLEFS_BITMAP_H */

dir.c

@@ -38,7 +38,7 @@ static int simplefs_iterate(struct file *dir, struct dir_context *ctx)
         return 0;
 
     /* Read the directory index block on disk */
-    bh = sb_bread(sb, ci->index_block);
+    bh = sb_bread(sb, ci->dir_block);
     if (!bh)
         return -EIO;
     dblock = (struct simplefs_dir_block *) bh->b_data;

extent.c

@@ -0,0 +1,24 @@
+#include <linux/fs.h>
+#include <linux/kernel.h>
+
+#include "simplefs.h"
+
+/*
+ * Search the extent which contain the target block.
+ * Retrun the first unused file index if not found.
+ * Return -1 if it is out of range.
+ * TODO: use binary search.
+ */
+uint32_t simplefs_ext_search(struct simplefs_file_ei_block *index,
+                             uint32_t iblock)
+{
+    uint32_t i;
+    for (i = 0; i < SIMPLEFS_MAX_EXTENTS; i++) {
+        uint32_t block = index->extents[i].ee_block;
+        uint32_t len = index->extents[i].ee_len;
+        if (index->extents[i].ee_start == 0 ||
+            (iblock >= block && iblock < block + len))
+            return i;
+    }
+    return -1;
+}

file.c

@@ -22,37 +22,50 @@ static int simplefs_file_get_block(struct inode *inode,
     struct super_block *sb = inode->i_sb;
     struct simplefs_sb_info *sbi = SIMPLEFS_SB(sb);
     struct simplefs_inode_info *ci = SIMPLEFS_INODE(inode);
-    struct simplefs_file_index_block *index;
+    struct simplefs_file_ei_block *index;
     struct buffer_head *bh_index;
     bool alloc = false;
     int ret = 0, bno;
+    uint32_t extent;
 
     /* If block number exceeds filesize, fail */
-    if (iblock >= SIMPLEFS_BLOCK_SIZE >> 2)
+    if (iblock >= SIMPLEFS_MAX_BLOCKS_PER_EXTENT * SIMPLEFS_MAX_EXTENTS)
         return -EFBIG;
 
-    /* Read index block from disk */
-    bh_index = sb_bread(sb, ci->index_block);
+    /* Read directory block from disk */
+    bh_index = sb_bread(sb, ci->dir_block);
     if (!bh_index)
         return -EIO;
-    index = (struct simplefs_file_index_block *) bh_index->b_data;
+    index = (struct simplefs_file_ei_block *) bh_index->b_data;
+
+    extent = simplefs_ext_search(index, iblock);
+    if (extent == -1) {
+        ret = -EFBIG;
+        goto brelse_index;
+    }
 
     /*
      * Check if iblock is already allocated. If not and create is true,
      * allocate it. Else, get the physical block number.
      */
-    if (index->blocks[iblock] == 0) {
+    if (index->extents[extent].ee_start == 0) {
         if (!create)
             return 0;
-        bno = get_free_block(sbi);
+        bno = get_free_blocks(sbi, 8);
         if (!bno) {
             ret = -ENOSPC;
             goto brelse_index;
         }
-        index->blocks[iblock] = bno;
+        index->extents[extent].ee_start = bno;
+        index->extents[extent].ee_len = 8;
+        index->extents[extent].ee_block =
+            extent ? index->extents[extent - 1].ee_block +
+                         index->extents[extent - 1].ee_len
+                   : 0;
         alloc = true;
     } else {
-        bno = index->blocks[iblock];
+        bno = index->extents[extent].ee_start + iblock -
+              index->extents[extent].ee_block;
     }
 
     /* Map the physical block to to the given buffer_head */
@@ -155,24 +168,33 @@ static int simplefs_write_end(struct file *file,
     if (nr_blocks_old > inode->i_blocks) {
         int i;
         struct buffer_head *bh_index;
-        struct simplefs_file_index_block *index;
+        struct simplefs_file_ei_block *index;
+        uint32_t first_ext;
 
         /* Free unused blocks from page cache */
         truncate_pagecache(inode, inode->i_size);
 
-        /* Read index block to remove unused blocks */
-        bh_index = sb_bread(sb, ci->index_block);
+        /* Read ei_block to remove unused blocks */
+        bh_index = sb_bread(sb, ci->ei_block);
         if (!bh_index) {
             pr_err("failed truncating '%s'. we just lost %lu blocks\n",
                    file->f_path.dentry->d_name.name,
                    nr_blocks_old - inode->i_blocks);
             goto end;
         }
-        index = (struct simplefs_file_index_block *) bh_index->b_data;
-
-        for (i = inode->i_blocks - 1; i < nr_blocks_old - 1; i++) {
-            put_block(SIMPLEFS_SB(sb), index->blocks[i]);
-            index->blocks[i] = 0;
+        index = (struct simplefs_file_ei_block *) bh_index->b_data;
+
+        first_ext = simplefs_ext_search(index, inode->i_blocks - 1);
+        /* Reserve unused block in last extent */
+        if (inode->i_blocks - 1 != index->extents[first_ext].ee_block)
+            first_ext++;
+
+        for (i = first_ext; i < SIMPLEFS_MAX_EXTENTS; i++) {
+            if (!index->extents[i].ee_start)
+                break;
+            put_blocks(SIMPLEFS_SB(sb), index->extents[i].ee_start,
+                       index->extents[i].ee_len);
+            memset(&index->extents[i], 0, sizeof(struct simplefs_extent));
         }
         mark_buffer_dirty(bh_index);
         brelse(bh_index);
@@ -193,4 +215,5 @@ const struct file_operations simplefs_file_ops = {
     .owner = THIS_MODULE,
     .read_iter = generic_file_read_iter,
     .write_iter = generic_file_write_iter,
+    .fsync = generic_file_fsync,
 };