ext4_journal: forcibly flush data to disk when stop journalling.

[lwext4.git] / lwext4 / ext4_bcache.h

diff --git a/lwext4/ext4_bcache.h b/lwext4/ext4_bcache.h
index d35e32b8a59f46d2cf365680145d7dda695da8ad..938f13bb3f0191bb5fc922e196c458fe63d06035 100644 (file)
--- a/lwext4/ext4_bcache.h
+++ b/lwext4/ext4_bcache.h
@@ -49,16 +49,10 @@ extern "C" {
 #include "queue.h"
 
 #define EXT4_BLOCK_ZERO()      \
-       {.uptodate = 0, .dirty = 0, .lb_id = 0, .data = 0}
+       {.lb_id = 0, .data = 0}
 
 /**@brief   Single block descriptor*/
 struct ext4_block {
-       /**@brief   Uptodate flag*/
-       bool uptodate;
-
-       /**@brief   Dirty flag*/
-       bool dirty;
-
        /**@brief   Logical block ID*/
        uint64_t lb_id;
 
@@ -69,6 +63,8 @@ struct ext4_block {
        uint8_t *data;
 };
 
+struct ext4_bcache;
+
 /**@brief   Single block descriptor*/
 struct ext4_buf {
        /**@brief   Flags*/
@@ -89,6 +85,9 @@ struct ext4_buf {
        /**@brief   Reference count table*/
        uint32_t refctr;
 
+       /**@brief   Whether or not buffer is on dirty list.*/
+       bool on_dirty_list;
+
        /**@brief   LBA tree node*/
        RB_ENTRY(ext4_buf) lba_node;
 
@@ -97,6 +96,19 @@ struct ext4_buf {
 
        /**@brief   Dirty list node*/
        SLIST_ENTRY(ext4_buf) dirty_node;
+
+       /**@brief   Callback routine after a disk-write operation.
+        * @param   bc block cache descriptor
+        * @param   buf buffer descriptor
+        * @param   standard error code returned by bdev->bwrite()
+        * @param   arg argument passed to this routine*/
+       void (*end_write)(struct ext4_bcache *bc,
+                         struct ext4_buf *buf,
+                         int res,
+                         void *arg);
+
+       /**@brief   argument passed to end_write() callback.*/
+       void *end_write_arg;
 };
 
 /**@brief   Block cache descriptor*/
@@ -117,6 +129,9 @@ struct ext4_bcache {
        /**@brief   Maximum referenced datablocks*/
        uint32_t max_ref_blocks;
 
+       /**@brief   The blockdev binded to this block cache*/
+       struct ext4_blockdev *bdev;
+
        /**@brief   A tree holding all bufs*/
        RB_HEAD(ext4_buf_lba, ext4_buf) lba_root;
 
@@ -127,9 +142,17 @@ struct ext4_bcache {
        SLIST_HEAD(ext4_buf_dirty, ext4_buf) dirty_list;
 };
 
+/**@brief buffer state bits
+ *
+ *  - BC♡UPTODATE: Buffer contains valid data.
+ *  - BC_DIRTY: Buffer is dirty.
+ *  - BC_FLUSH: Buffer will be immediately flushed,
+ *              when no one references it.
+ */
 enum bcache_state_bits {
        BC_UPTODATE,
-       BC_DIRTY
+       BC_DIRTY,
+       BC_FLUSH
 };
 
 #define ext4_bcache_set_flag(buf, b)    \
@@ -141,6 +164,22 @@ enum bcache_state_bits {
 #define ext4_bcache_test_flag(buf, b)    \
        (((buf)->flags & (1 << (b))) >> (b))
 
+static inline void ext4_bcache_set_dirty(struct ext4_buf *buf) {
+       ext4_bcache_set_flag(buf, BC_UPTODATE);
+       ext4_bcache_set_flag(buf, BC_DIRTY);
+}
+
+static inline void ext4_bcache_clear_dirty(struct ext4_buf *buf) {
+       ext4_bcache_clear_flag(buf, BC_UPTODATE);
+       ext4_bcache_clear_flag(buf, BC_DIRTY);
+}
+
+/**@brief   Increment reference counter of buf by 1.*/
+#define ext4_bcache_inc_ref(buf) ((buf)->refctr++)
+
+/**@brief   Decrement reference counter of buf by 1.*/
+#define ext4_bcache_dec_ref(buf) ((buf)->refctr--)
+
 /**@brief   Static initializer of block cache structure.*/
 #define EXT4_BCACHE_STATIC_INSTANCE(__name, __cnt, __itemsize)                 \
        static struct ext4_bcache __name = {                                   \
@@ -149,6 +188,29 @@ enum bcache_state_bits {
            .lru_ctr = 0,                                                      \
        }
 
+/**@brief   Insert buffer to dirty cache list
+ * @param   bc block cache descriptor
+ * @param   buf buffer descriptor */
+static inline void
+ext4_bcache_insert_dirty_node(struct ext4_bcache *bc, struct ext4_buf *buf) {
+       if (!buf->on_dirty_list) {
+               SLIST_INSERT_HEAD(&bc->dirty_list, buf, dirty_node);
+               buf->on_dirty_list = true;
+       }
+}
+
+/**@brief   Remove buffer to dirty cache list
+ * @param   bc block cache descriptor
+ * @param   buf buffer descriptor */
+static inline void
+ext4_bcache_remove_dirty_node(struct ext4_bcache *bc, struct ext4_buf *buf) {
+       if (buf->on_dirty_list) {
+               SLIST_REMOVE(&bc->dirty_list, buf, ext4_buf, dirty_node);
+               buf->on_dirty_list = false;
+       }
+}
+
+
 /**@brief   Dynamic initialization of block cache.
  * @param   bc block cache descriptor
  * @param   cnt items count in block cache