+}
+
+/* Start writeback of an inode and all associated data. */
+void bluesky_inode_start_sync(BlueSkyInode *inode)
+{
+ GList *log_items = NULL;
+
+ if (inode->type == BLUESKY_REGULAR)
+ bluesky_file_flush(inode, &log_items);
+
+ BlueSkyCloudLog *cloudlog = bluesky_serialize_inode(inode);
+
+ bluesky_cloudlog_unref(inode->committed_item);
+ inode->committed_item = cloudlog;
+
+ bluesky_cloudlog_sync(cloudlog);
+ bluesky_cloudlog_ref(cloudlog);
+ log_items = g_list_prepend(log_items, cloudlog);
+
+ /* Wait for all log items to be committed to disk. */
+ bluesky_log_finish_all(log_items);
+
+ /* Mark the inode as clean */
+ inode->change_commit = inode->change_count;
+ inode->change_time = 0;
+ g_mutex_lock(inode->fs->lock);
+ bluesky_list_unlink(&inode->fs->unlogged_list, inode->unlogged_list);
+ inode->unlogged_list = NULL;
+ g_mutex_unlock(inode->fs->lock);
+}
+
+/* Write back an inode and all associated data and wait for completion. Inode
+ * should already be locked. */
+void bluesky_inode_do_sync(BlueSkyInode *inode)
+{
+ if (bluesky_verbose) {
+ g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+ "Synchronous writeback for inode %"PRIu64"...", inode->inum);
+ }
+ bluesky_inode_start_sync(inode);
+ if (bluesky_verbose) {
+ g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+ "Writeback for inode %"PRIu64" complete", inode->inum);
+ }
+}
+
+static void complete_inode_fetch(BlueSkyStoreAsync *async, BlueSkyInode *inode)
+{
+ if (bluesky_verbose) {
+ g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+ "Completing fetch of inode %"PRIu64"...", inode->inum);
+ }
+
+ if (async->result != 0
+ || !bluesky_deserialize_inode(inode, async->data->data))
+ {
+ if (bluesky_verbose) {
+ g_log("bluesky/inode", G_LOG_LEVEL_DEBUG,
+ " failed to load inode, cleaning up");
+ }
+ g_mutex_lock(inode->fs->lock);
+ g_hash_table_remove(inode->fs->inodes, &inode->inum);
+ bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
+ inode->accessed_list = NULL;
+ g_mutex_unlock(inode->fs->lock);
+ bluesky_inode_unref(inode);
+ }
+
+ inode->access_time = bluesky_get_current_time();
+ g_mutex_lock(inode->fs->lock);
+ bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list);
+ inode->accessed_list = bluesky_list_prepend(&inode->fs->accessed_list, inode);
+ g_mutex_unlock(inode->fs->lock);
+
+ 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);
+
+ BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING);
+ inode->change_count = 0;
+ 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. */
+void bluesky_superblock_flush(BlueSkyFS *fs)
+{
+#if 0
+ GString *buf = g_string_new("");
+ bluesky_serialize_superblock(buf, fs);
+ BlueSkyRCStr *data = bluesky_string_new_from_gstring(buf);
+
+ 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_sync(fs->store);
+#endif