/* 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();
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
fs->name = g_strdup(name);
return fs;
}
+ bluesky_string_unref(data);
}
g_print("Initializing fresh filesystem\n");
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:
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;
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);
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("");
bluesky_store_async_unref(async);
}
-/* Fetch an inode from stable storage. */
+/* Start writeback of an inode and all associated data. */
+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);
+
+ 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);
+}
+
+/* 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. */
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");