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 9b6160a..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");
@@ -138,17 +139,12 @@ uint64_t bluesky_fs_alloc_inode(BlueSkyFS *fs)
     return inum;
 }
 
-BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs,
-                                BlueSkyFileType type)
+/* Perform type-specification initialization of an inode.  Normally performed
+ * in bluesky_new_inode, but can be separated if an inode is created first,
+ * then deserialized. */
+void bluesky_init_inode(BlueSkyInode *i, BlueSkyFileType type)
 {
-    BlueSkyInode *i = g_new0(BlueSkyInode, 1);
-
-    i->lock = g_mutex_new();
-    i->refcount = 1;
     i->type = type;
-    i->fs = fs;
-    i->inum = inum;
-    i->change_count = 1;
 
     switch (type) {
     case BLUESKY_REGULAR:
@@ -159,13 +155,22 @@ BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs,
         i->dirhash = g_hash_table_new(g_str_hash, g_str_equal);
         i->dirhash_folded = g_hash_table_new(g_str_hash, g_str_equal);
         break;
-    case BLUESKY_BLOCK:
-    case BLUESKY_CHARACTER:
-    case BLUESKY_SYMLINK:
-    case BLUESKY_SOCKET:
-    case BLUESKY_FIFO:
+    default:
         break;
     }
+}
+
+BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs,
+                                BlueSkyFileType type)
+{
+    BlueSkyInode *i = g_new0(BlueSkyInode, 1);
+
+    i->lock = g_mutex_new();
+    i->refcount = 1;
+    i->fs = fs;
+    i->inum = inum;
+    i->change_count = 1;
+    bluesky_init_inode(i, type);
 
     return i;
 }
@@ -192,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);
@@ -228,13 +237,13 @@ void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier)
 {
     BlueSkyFS *fs = inode->fs;
 
+    if (inode->type == BLUESKY_REGULAR)
+        bluesky_file_flush(inode, barrier);
+
     GString *buf = g_string_new("");
     bluesky_serialize_inode(buf, inode);
     BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
 
-    if (inode->type == BLUESKY_REGULAR)
-        bluesky_file_flush(inode, barrier);
-
     char key[64];
     sprintf(key, "inode-%016"PRIx64, inode->inum);
 
@@ -248,19 +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_deserialize_inode(fs, data->data);
-    if (inode != NULL) {
-        bluesky_insert_inode(fs, inode);
+    BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING);
+    bluesky_inode_ref(inode);       // Extra ref held by fetching process
+    g_mutex_lock(inode->lock);
+    bluesky_insert_inode(fs, 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);
     }
+
+    bluesky_store_async_unref(async);
 }
 
 /* Synchronize filesystem superblock to stable storage. */