Add very rudimentary eviction data blocks from the cache.

[bluesky.git] / bluesky / inode.c

diff --git a/bluesky/inode.c b/bluesky/inode.c
index 3c6fa3c..55781ca 100644 (file)
--- a/bluesky/inode.c
+++ b/bluesky/inode.c
@@ -92,6 +92,7 @@ BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store)
             fs->name = g_strdup(name);
             return fs;
         }
+        bluesky_string_unref(data);
     }
 
     g_print("Initializing fresh filesystem\n");
@@ -196,6 +197,10 @@ BlueSkyInode *bluesky_get_inode(BlueSkyFS *fs, uint64_t inum)
 
     if (inode != NULL) {
         bluesky_inode_ref(inode);
+
+        /* FIXME: We assume we can atomically update the in-memory access time
+         * without a lock. */
+        inode->access_time = bluesky_get_current_time();
     }
 
     g_mutex_unlock(fs->lock);
@@ -252,27 +257,68 @@ void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier)
     bluesky_store_async_unref(async);
 }
 
-/* Fetch an inode from stable storage. */
+/* Write back an inode and all associated data and wait for completion.  Inode
+ * should already be locked. */
+void bluesky_inode_do_sync(BlueSkyInode *inode)
+{
+    BlueSkyStoreAsync *barrier = bluesky_store_async_new(inode->fs->store);
+    barrier->op = STORE_OP_BARRIER;
+
+    g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+          "Synchronous writeback for inode %"PRIu64"...", inode->inum);
+    bluesky_inode_start_sync(inode, barrier);
+    bluesky_store_async_submit(barrier);
+    bluesky_store_async_wait(barrier);
+    bluesky_store_async_unref(barrier);
+    g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+          "Writeback for inode %"PRIu64" complete", inode->inum);
+}
+
+static void complete_inode_fetch(BlueSkyStoreAsync *async, BlueSkyInode *inode)
+{
+    g_print("Completing fetch of inode %"PRIu64"...\n", inode->inum);
+
+    if (async->result != 0
+        || !bluesky_deserialize_inode(inode, async->data->data))
+    {
+        g_print("    failed to load inode, cleaning up\n");
+        g_mutex_lock(inode->fs->lock);
+        g_hash_table_remove(inode->fs->inodes, &inode->inum);
+        g_mutex_unlock(inode->fs->lock);
+        bluesky_inode_unref(inode);
+    }
+
+    g_mutex_unlock(inode->lock);
+    bluesky_inode_unref(inode);
+}
+
+/* Fetch an inode from stable storage.  The fetch can be performed
+ * asynchronously: the in-memory inode is allocated, but not filled with data
+ * immediately.  It is kept locked until it has been filled in, so any users
+ * should try to acquire the lock on the inode before accessing any data.  The
+ * fs lock must be held. */
 void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum)
 {
     char key[64];
     sprintf(key, "inode-%016"PRIx64, inum);
-    BlueSkyRCStr *data = bluesky_store_get(fs->store, key);
-    if (data == NULL)
-        return;
 
     BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING);
-    bluesky_inode_ref(inode);
+    bluesky_inode_ref(inode);       // Extra ref held by fetching process
     g_mutex_lock(inode->lock);
     bluesky_insert_inode(fs, inode);
 
-    if (!bluesky_deserialize_inode(inode, data->data)) {
-        g_hash_table_remove(fs->inodes, &inode->inum);
-        bluesky_inode_unref(inode);
+    BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
+    async->op = STORE_OP_GET;
+    async->key = g_strdup(key);
+
+    bluesky_store_async_add_notifier(async, (GFunc)complete_inode_fetch, inode);
+    bluesky_store_async_submit(async);
+
+    if (bluesky_options.sync_inode_fetches) {
+        bluesky_store_async_wait(async);
     }
 
-    g_mutex_unlock(inode->lock);
-    bluesky_inode_unref(inode);
+    bluesky_store_async_unref(async);
 }
 
 /* Synchronize filesystem superblock to stable storage. */