Everything before initial synced list

Signed-off-by: Andrew Opalach <andrew@akon.city>

5 files changed, 64 insertions, 34 deletions

diff --git a/src/cache/backings/file.c b/src/cache/backings/file.c
index 4c5f344..153b1e4 100644
--- a/src/cache/backings/file.c
+++ b/src/cache/backings/file.c
@@ -1,6 +1,14 @@
+#include "../range.h"
+
 #include "file.h"
 #include "file_common.c"
 
+static void file_backing_lock(struct cch_backing *backing)
+{
+    struct cch_backing_file *file = (struct cch_backing_file *)backing;
+    aki_mutex_lock(&file->mutex);
+}
+
 static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
@@ -10,10 +18,11 @@ static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index
         al_assert(file->u.pointer == index);
     }
     if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
-        *size = file->size - index;
+        *size = AL_MAX(file->size - index, 0);
     }
     aki_file_write(&file->file, buf, *size);
     file->u.pointer += *size;
+    cch_backing_fill_range(&file->backing, index, *size);
     aki_mutex_unlock(&file->mutex);
 }
 
@@ -26,13 +35,19 @@ static void file_backing_read(struct cch_backing *backing, u8 *buf, off_t index,
         al_assert(file->u.pointer == index);
     }
     if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
-        *size = file->size - index;
+        *size = AL_MAX(file->size - index, 0);
     }
     aki_file_read(&file->file, buf, *size);
     file->u.pointer += *size;
     aki_mutex_unlock(&file->mutex);
 }
 
+static void file_backing_unlock(struct cch_backing *backing)
+{
+    struct cch_backing_file *file = (struct cch_backing_file *)backing;
+    aki_mutex_unlock(&file->mutex);
+}
+
 static void file_backing_resize(struct cch_backing *backing, size_t size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
@@ -49,6 +64,7 @@ static void file_backing_free(struct cch_backing **backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)*backing;
     aki_file_close(&file->file);
+    al_array_free(file->backing.available);
     al_free(file);
     *backing = NULL;
 }
@@ -56,15 +72,16 @@ static void file_backing_free(struct cch_backing **backing)
 struct cch_backing *cch_backing_file_create(str *path, size_t size)
 {
     struct cch_backing_file *file = al_alloc_object(struct cch_backing_file);
-    file->backing.mode = CCH_BACKING_READ;
+    file->backing.mode = CACHE_BACKING_READ;
+    file->backing.lock = file_backing_lock;
     file->backing.write = file_backing_write;
     file->backing.read = file_backing_read;
     file->backing.get_ptr = NULL;
-    file->backing.unlock = NULL;
-    file->backing.get_mmap = NULL;
+    file->backing.unlock = file_backing_unlock;
     file->backing.get_size_estimate = file_backing_get_size_estimate;
     file->backing.resize = file_backing_resize;
     file->backing.free = file_backing_free;
+    al_array_init(file->backing.available);
     if (!file_open_internal(file, path, size)) {
         al_free(file);
         return NULL;
diff --git a/src/cache/backings/file.h b/src/cache/backings/file.h
index 9794bbb..3f8437b 100644
--- a/src/cache/backings/file.h
+++ b/src/cache/backings/file.h
@@ -13,8 +13,8 @@ struct cch_backing_file {
     off_t size;
     off_t filesize;
     union {
-        void *map; // CCH_BACKING_MAPPED
-        off_t pointer; // CCH_BACKING_READ
+        void *map; // CACHE_BACKING_MAPPED
+        off_t pointer; // CACHE_BACKING_READ
     } u;
     struct aki_mutex mutex;
 };
diff --git a/src/cache/backings/file_common.c b/src/cache/backings/file_common.c
index 232580a..35322fd 100644
--- a/src/cache/backings/file_common.c
+++ b/src/cache/backings/file_common.c
@@ -14,6 +14,7 @@ static bool file_open_internal(struct cch_backing_file *file, str *path, size_t
     file->filesize = aki_file_get_filesize(&file->file);
     if (!size) {
         file->size = file->filesize;
+        cch_backing_fill_range(&file->backing, 0, file->size);
     } else {
         file->size = -1;
         if (file->filesize < (off_t)size) {
diff --git a/src/cache/backings/file_mapped.c b/src/cache/backings/file_mapped.c
index 4277c21..6c6fc94 100644
--- a/src/cache/backings/file_mapped.c
+++ b/src/cache/backings/file_mapped.c
@@ -1,14 +1,23 @@
+#include "../range.h"
+
 #include "file.h"
 #include "file_common.c"
 
+static void file_backing_lock(struct cch_backing *backing)
+{
+    struct cch_backing_file *file = (struct cch_backing_file *)backing;
+    aki_mutex_lock(&file->mutex);
+}
+
 static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
     aki_mutex_lock(&file->mutex);
-    if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
-        *size = file->size - index;
+    if (file->size >= 0 && index + (off_t)*size >= file->size) {
+        *size = AL_MAX(file->size - index, 0);
     }
     al_memcpy(file->u.map + index, buf, *size);
+    cch_backing_fill_range(&file->backing, index, *size);
     aki_mutex_unlock(&file->mutex);
 }
 
@@ -16,8 +25,8 @@ static u8 *file_backing_get_ptr(struct cch_backing *backing, off_t index, size_t
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
     aki_mutex_lock(&file->mutex);
-    if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
-        *size = file->size - index;
+    if (file->size >= 0 && index + (off_t)*size >= file->size) {
+        *size = AL_MAX(file->size - index, 0);
     }
     return (u8 *)(file->u.map + index);
 }
@@ -28,24 +37,15 @@ static void file_backing_unlock(struct cch_backing *backing)
     aki_mutex_unlock(&file->mutex);
 }
 
-static void *file_backing_get_mmap(struct cch_backing *backing)
-{
-    struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
-    void *map = file->u.map;
-    aki_mutex_unlock(&file->mutex);
-    return map;
-}
-
 static void file_backing_resize(struct cch_backing *backing, size_t size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
     aki_mutex_lock(&file->mutex);
     file->size = size;
     if ((off_t)size > file->filesize) {
-        // TODO: Unmap, truncate, map?
-        file->u.map = aki_file_mremap(&file->file, size, file->u.map);
+        aki_file_munmap(&file->file, file->u.map);
         aki_file_truncate(&file->file, size);
+        file->u.map = aki_file_mmap(&file->file);
         file->filesize = size;
     }
     aki_mutex_unlock(&file->mutex);
@@ -56,6 +56,7 @@ static void file_backing_free(struct cch_backing **backing)
     struct cch_backing_file *file = (struct cch_backing_file *)*backing;
     aki_file_munmap(&file->file, file->u.map);
     aki_file_close(&file->file);
+    al_array_free(file->backing.available);
     al_free(file);
     *backing = NULL;
 }
@@ -63,20 +64,20 @@ static void file_backing_free(struct cch_backing **backing)
 struct cch_backing *cch_backing_file_create(str *path, size_t size)
 {
     struct cch_backing_file *file = al_alloc_object(struct cch_backing_file);
-    file->backing.mode = CCH_BACKING_MAPPED;
+    file->backing.mode = CACHE_BACKING_MAPPED;
+    file->backing.lock = file_backing_lock;
     file->backing.write = file_backing_write;
     file->backing.read = NULL;
-    file->backing.get_mmap = file_backing_get_mmap;
     file->backing.get_ptr = file_backing_get_ptr;
     file->backing.unlock = file_backing_unlock;
     file->backing.get_size_estimate = file_backing_get_size_estimate;
     file->backing.resize = file_backing_resize;
     file->backing.free = file_backing_free;
-    if (!file_open_internal(file, path, size)) {
+    al_array_init(file->backing.available);
+    if (!file_open_internal(file, path, size) || !(file->u.map = aki_file_mmap(&file->file))) {
         al_free(file);
         return NULL;
     }
-    file->u.map = aki_file_mmap(&file->file);
     aki_mutex_init(&file->mutex);
     return (struct cch_backing *)file;
 }
diff --git a/src/cache/backings/memory.c b/src/cache/backings/memory.c
index 194d66c..1dca8f9 100644
--- a/src/cache/backings/memory.c
+++ b/src/cache/backings/memory.c
@@ -1,22 +1,31 @@
+#include "../range.h"
+
 #include "memory.h"
 
 static void ensure_alloced(struct cch_backing_memory *mem, size_t size)
 {
     if (size > mem->alloc) {
-        mem->data = al_realloc(mem->data, size);
-        mem->alloc = size;
+        mem->alloc = al_next_power_of_two(size);
+        mem->data = al_realloc(mem->data, mem->alloc);
     }
 }
 
+static void memory_backing_lock(struct cch_backing *backing)
+{
+    struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
+    aki_mutex_lock(&mem->mutex);
+}
+
 static void memory_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
     aki_mutex_lock(&mem->mutex);
-    if (mem->size >= 0 && index + ((off_t)*size) >= mem->size) {
-        *size = mem->size - index;
+    if (mem->size >= 0 && index + (off_t)*size >= mem->size) {
+        *size = AL_MAX(mem->size - index, 0);
     }
     ensure_alloced(mem, index + *size);
     al_memcpy(mem->data + index, buf, *size);
+    cch_backing_fill_range(&mem->backing, index, *size);
     aki_mutex_unlock(&mem->mutex);
 }
 
@@ -24,8 +33,8 @@ static u8 *memory_backing_get_ptr(struct cch_backing *backing, off_t index, size
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
     aki_mutex_lock(&mem->mutex);
-    if (mem->size >= 0 && index + ((off_t)*size) >= mem->size) {
-        *size = mem->size - index;
+    if (mem->size >= 0 && index + (off_t)*size >= mem->size) {
+        *size = AL_MAX(mem->size - index, 0);
     }
     return (u8 *)(mem->data + index);
 }
@@ -59,6 +68,7 @@ static void memory_backing_free(struct cch_backing **backing)
     struct cch_backing_memory *mem = (struct cch_backing_memory *)*backing;
     al_free(mem->data);
     aki_mutex_destroy(&mem->mutex);
+    al_array_free(mem->backing.available);
     al_free(mem);
     *backing = NULL;
 }
@@ -66,9 +76,9 @@ static void memory_backing_free(struct cch_backing **backing)
 struct cch_backing *cch_backing_memory_create(size_t size)
 {
     struct cch_backing_memory *mem = al_alloc_object(struct cch_backing_memory);
-    mem->backing.mode = CCH_BACKING_MAPPED;
+    mem->backing.mode = CACHE_BACKING_MAPPED;
+    mem->backing.lock = memory_backing_lock;
     mem->backing.write = memory_backing_write;
-    mem->backing.get_mmap = NULL;
     mem->backing.get_ptr = memory_backing_get_ptr;
     mem->backing.unlock = memory_backing_unlock;
     mem->backing.get_size_estimate = memory_backing_get_size_estimate;
@@ -78,5 +88,6 @@ struct cch_backing *cch_backing_memory_create(size_t size)
     mem->alloc = size;
     mem->size = -1;
     aki_mutex_init(&mem->mutex);
+    al_array_init(mem->backing.available);
     return (struct cch_backing *)mem;
 }