#include "ext4_config.h"
#include "ext4_bcache.h"
+#include "ext4_blockdev.h"
#include "ext4_debug.h"
#include "ext4_errno.h"
#include <string.h>
#include <stdlib.h>
-static int
-ext4_bcache_lba_compare(struct ext4_buf *a,
- struct ext4_buf *b)
+static int ext4_bcache_lba_compare(struct ext4_buf *a, struct ext4_buf *b)
{
- return a->lba - b->lba;
+ if (a->lba > b->lba)
+ return 1;
+ else if (a->lba < b->lba)
+ return -1;
+ return 0;
}
-static int
-ext4_bcache_lru_compare(struct ext4_buf *a,
- struct ext4_buf *b)
+static int ext4_bcache_lru_compare(struct ext4_buf *a, struct ext4_buf *b)
{
- return a->lru_id - b->lru_id;
+ if (a->lru_id > b->lru_id)
+ return 1;
+ else if (a->lru_id < b->lru_id)
+ return -1;
+ return 0;
}
RB_GENERATE_INTERNAL(ext4_buf_lba, ext4_buf, lba_node,
return EOK;
}
+void ext4_bcache_cleanup(struct ext4_bcache *bc)
+{
+ struct ext4_buf *buf, *tmp;
+ RB_FOREACH_SAFE(buf, ext4_buf_lba, &bc->lba_root, tmp) {
+ ext4_block_flush_buf(bc->bdev, buf);
+ ext4_bcache_drop_buf(bc, buf);
+ }
+}
+
int ext4_bcache_fini_dynamic(struct ext4_bcache *bc)
{
memset(bc, 0, sizeof(struct ext4_bcache));
return EOK;
}
+/**@brief:
+ *
+ * This is ext4_bcache, the module handling basic buffer-cache stuff.
+ *
+ * Buffers in a bcache are sorted by their LBA and stored in a
+ * RB-Tree(lba_root).
+ *
+ * Bcache also maintains another RB-Tree(lru_root) right now, where
+ * buffers are sorted by their LRU id.
+ *
+ * A singly-linked list is used to track those dirty buffers which are
+ * ready to be flushed. (Those buffers which are dirty but also referenced
+ * are not considered ready to be flushed.)
+ *
+ * When a buffer is not referenced, it will be stored in both lba_root
+ * and lru_root, while it will only be stored in lba_root when it is
+ * referenced.
+ */
+
static struct ext4_buf *
ext4_buf_alloc(struct ext4_bcache *bc, uint64_t lba)
{
if (!data)
return NULL;
- buf = malloc(sizeof(struct ext4_buf));
+ buf = calloc(1, sizeof(struct ext4_buf));
if (!buf) {
free(data);
return NULL;
}
- buf->flags = 0;
buf->lba = lba;
buf->data = data;
- buf->lru_id = 0;
- buf->refctr = 0;
- memset(&buf->lba_node, 0, sizeof(buf->lba_node));
- memset(&buf->lru_node, 0, sizeof(buf->lru_node));
- memset(&buf->dirty_node, 0, sizeof(buf->dirty_node));
+ buf->bc = bc;
return buf;
}
void ext4_bcache_drop_buf(struct ext4_bcache *bc, struct ext4_buf *buf)
{
- /*Cannot drop any referenced buffers.*/
- ext4_assert(!buf->refctr);
+ /* Warn on dropping any referenced buffers.*/
+ if (buf->refctr) {
+ ext4_dbg(DEBUG_BCACHE, DBG_WARN "Buffer is still referenced. "
+ "lba: %" PRIu64 ", refctr: %" PRIu32 "\n",
+ buf->lba, buf->refctr);
+ } else
+ RB_REMOVE(ext4_buf_lru, &bc->lru_root, buf);
RB_REMOVE(ext4_buf_lba, &bc->lba_root, buf);
- RB_REMOVE(ext4_buf_lru, &bc->lru_root, buf);
/*Forcibly drop dirty buffer.*/
if (ext4_bcache_test_flag(buf, BC_DIRTY))
- SLIST_REMOVE(&bc->dirty_list,
- buf,
- ext4_buf,
- dirty_node);
+ ext4_bcache_remove_dirty_node(bc, buf);
ext4_buf_free(buf);
bc->ref_blocks--;
}
-int ext4_bcache_alloc(struct ext4_bcache *bc, struct ext4_block *b,
- bool *is_new)
+void ext4_bcache_invalidate_lba(struct ext4_bcache *bc,
+ uint64_t from,
+ uint32_t cnt)
+{
+ uint64_t end = from + cnt - 1;
+ struct ext4_buf *tmp = ext4_buf_lookup(bc, from), *buf;
+ RB_FOREACH_FROM(buf, ext4_buf_lba, tmp) {
+ if (buf->lba > end)
+ break;
+
+ /* Clear both dirty and up-to-date flags. */
+ if (ext4_bcache_test_flag(buf, BC_DIRTY))
+ ext4_bcache_remove_dirty_node(bc, buf);
+
+ ext4_bcache_clear_dirty(buf);
+ }
+}
+
+struct ext4_buf *
+ext4_bcache_find_get(struct ext4_bcache *bc, struct ext4_block *b,
+ uint64_t lba)
{
- struct ext4_buf *buf = ext4_buf_lookup(bc, b->lb_id);
+ struct ext4_buf *buf = ext4_buf_lookup(bc, lba);
if (buf) {
+ /* If buffer is not referenced. */
if (!buf->refctr) {
+ /* Assign new value to LRU id and increment LRU counter
+ * by 1*/
buf->lru_id = ++bc->lru_ctr;
RB_REMOVE(ext4_buf_lru, &bc->lru_root, buf);
if (ext4_bcache_test_flag(buf, BC_DIRTY))
- SLIST_REMOVE(&bc->dirty_list,
- buf,
- ext4_buf,
- dirty_node);
+ ext4_bcache_remove_dirty_node(bc, buf);
}
- buf->refctr++;
- b->uptodate = ext4_bcache_test_flag(buf, BC_UPTODATE);
- b->dirty = false;
+ ext4_bcache_inc_ref(buf);
+
b->buf = buf;
b->data = buf->data;
+ }
+ return buf;
+}
+
+int ext4_bcache_alloc(struct ext4_bcache *bc, struct ext4_block *b,
+ bool *is_new)
+{
+ /* Try to search the buffer with exaxt LBA. */
+ struct ext4_buf *buf = ext4_bcache_find_get(bc, b, b->lb_id);
+ if (buf) {
*is_new = false;
return EOK;
}
+
+ /* We need to allocate one buffer.*/
buf = ext4_buf_alloc(bc, b->lb_id);
if (!buf)
return ENOMEM;
RB_INSERT(ext4_buf_lba, &bc->lba_root, buf);
+ /* One more buffer in bcache now. :-) */
bc->ref_blocks++;
- buf->refctr = 1;
+ /*Calc ref blocks max depth*/
+ if (bc->max_ref_blocks < bc->ref_blocks)
+ bc->max_ref_blocks = bc->ref_blocks;
+
+
+ ext4_bcache_inc_ref(buf);
+ /* Assign new value to LRU id and increment LRU counter
+ * by 1*/
buf->lru_id = ++bc->lru_ctr;
- b->uptodate = false;
- b->dirty = false;
+
b->buf = buf;
b->data = buf->data;
+
*is_new = true;
return EOK;
}
-int ext4_bcache_free(struct ext4_bcache *bc, struct ext4_block *b,
- uint8_t free_delay)
+int ext4_bcache_free(struct ext4_bcache *bc, struct ext4_block *b)
{
struct ext4_buf *buf = b->buf;
ext4_assert(buf->refctr);
/*Just decrease reference counter*/
- buf->refctr--;
-
- if (free_delay)
- bc->free_delay = free_delay;
-
- if (b->dirty) {
- ext4_bcache_set_flag(buf, BC_DIRTY);
- ext4_bcache_set_flag(buf, BC_UPTODATE);
- b->uptodate = true;
- }
- if (!b->uptodate)
- ext4_bcache_clear_flag(buf, BC_UPTODATE);
+ ext4_bcache_dec_ref(buf);
+ /* We are the last one touching this buffer, do the cleanups. */
if (!buf->refctr) {
RB_INSERT(ext4_buf_lru, &bc->lru_root, buf);
- if (ext4_bcache_test_flag(buf, BC_DIRTY))
- SLIST_INSERT_HEAD(&bc->dirty_list, buf, dirty_node);
+ /* This buffer is ready to be flushed. */
+ if (ext4_bcache_test_flag(buf, BC_DIRTY) &&
+ ext4_bcache_test_flag(buf, BC_UPTODATE)) {
+ if (bc->bdev->cache_write_back &&
+ !ext4_bcache_test_flag(buf, BC_FLUSH))
+ ext4_bcache_insert_dirty_node(bc, buf);
+ else {
+ ext4_block_flush_buf(bc->bdev, buf);
+ ext4_bcache_clear_flag(buf, BC_FLUSH);
+ }
+ }
- if (!ext4_bcache_test_flag(buf, BC_UPTODATE))
+ /* The buffer is invalidated...drop it. */
+ if (!ext4_bcache_test_flag(buf, BC_UPTODATE) ||
+ ext4_bcache_test_flag(buf, BC_TMP))
ext4_bcache_drop_buf(bc, buf);
}
b->lb_id = 0;
b->data = 0;
- b->uptodate = false;
- b->dirty = false;
return EOK;
}
return (bc->cnt <= bc->ref_blocks);
}
+
/**
* @}
*/
projects / lwext4.git / blobdiff