Some changes to support asynchronous fetching of inodes.

[bluesky.git] / bluesky / inode.c

diff --git a/bluesky/inode.c b/bluesky/inode.c
index 44ef63c..a052fb4 100644 (file)
--- a/bluesky/inode.c
+++ b/bluesky/inode.c
@@ -29,7 +29,8 @@ int64_t bluesky_get_current_time()
 
 /* Update an inode to indicate that a modification was made.  This increases
  * the change counter, updates the ctime to the current time, and optionally
- * updates the mtime.  inode must already be locked. */
+ * updates the mtime.  This also makes the inode contents subject to writeback
+ * to storage in the future.  inode must already be locked. */
 void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime)
 {
     int64_t now = bluesky_get_current_time();
@@ -37,6 +38,12 @@ void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime)
     inode->ctime = now;
     if (update_mtime)
         inode->mtime = now;
+
+    if (inode->change_time == 0)
+        inode->change_time = now;
+
+    if (bluesky_options.writethrough_cache)
+        bluesky_file_flush(inode, NULL);
 }
 
 /* Unfortunately a glib hash table is only guaranteed to be able to store
@@ -131,16 +138,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;
 
     switch (type) {
     case BLUESKY_REGULAR:
@@ -151,21 +154,30 @@ 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;
 }
 
 /* Retrieve an inode from the filesystem.  Eventually this will be a cache and
  * so we might need to go fetch the inode from elsewhere; for now all
- * filesystem state is stored here.  inode is returned locked with a reference
- * held. */
+ * filesystem state is stored here.  inode is returned with a reference held
+ * but not locked. */
 BlueSkyInode *bluesky_get_inode(BlueSkyFS *fs, uint64_t inum)
 {
     BlueSkyInode *inode = NULL;
@@ -197,7 +209,7 @@ void bluesky_insert_inode(BlueSkyFS *fs, BlueSkyInode *inode)
     g_hash_table_insert(fs->inodes, &inode->inum, inode);
 }
 
-/* Synchronize an inode to stable storage. */
+/* Deprecated: Synchronize an inode to stable storage. */
 void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode)
 {
     GString *buf = g_string_new("");
@@ -207,7 +219,37 @@ void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode)
     char key[64];
     sprintf(key, "inode-%016"PRIx64, inode->inum);
 
-    bluesky_store_put(fs->store, key, data);
+    BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
+    async->op = STORE_OP_PUT;
+    async->key = g_strdup(key);
+    async->data = data;
+    bluesky_store_async_submit(async);
+    bluesky_store_async_unref(async);
+}
+
+/* Start writeback of an inode and all associated data. */
+void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier)
+{
+    BlueSkyFS *fs = inode->fs;
+
+    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);
+
+    BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
+    async->op = STORE_OP_PUT;
+    async->key = g_strdup(key);
+    async->data = data;
+    bluesky_store_async_submit(async);
+    if (barrier != NULL)
+        bluesky_store_add_barrier(barrier, async);
+    bluesky_store_async_unref(async);
 }
 
 /* Fetch an inode from stable storage. */
@@ -219,10 +261,18 @@ void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum)
     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);
+    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);
     }
+
+    g_mutex_unlock(inode->lock);
+    bluesky_inode_unref(inode);
 }
 
 /* Synchronize filesystem superblock to stable storage. */
@@ -232,7 +282,12 @@ void bluesky_superblock_flush(BlueSkyFS *fs)
     bluesky_serialize_superblock(buf, fs);
     BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
 
-    g_print("Syncing superblock...\n");
+    BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
+    async->op = STORE_OP_PUT;
+    async->key = g_strdup("superblock");
+    async->data = data;
+    bluesky_store_async_submit(async);
+    bluesky_store_async_unref(async);
 
-    bluesky_store_put(fs->store, "superblock", data);
+    bluesky_store_sync(fs->store);
 }