X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Finode.c;h=745d81bb7d2c01e8276ed61b0d298f7134c235df;hb=db4915b4f7fc8f74958c4d1891dc69b76cbbe383;hp=3e92e4f2a7f75f508978081117f52fd3e88fc065;hpb=5b3aafc6c34c798f9ad74539f24c9b278e820163;p=bluesky.git diff --git a/bluesky/inode.c b/bluesky/inode.c index 3e92e4f..745d81b 100644 --- a/bluesky/inode.c +++ b/bluesky/inode.c @@ -42,8 +42,19 @@ void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime) if (inode->change_time == 0) inode->change_time = now; +#if 0 if (bluesky_options.writethrough_cache) bluesky_file_flush(inode, NULL); +#endif + + g_mutex_lock(inode->fs->lock); + bluesky_list_unlink(&inode->fs->unlogged_list, inode->unlogged_list); + inode->unlogged_list = bluesky_list_prepend(&inode->fs->unlogged_list, inode); + bluesky_list_unlink(&inode->fs->dirty_list, inode->dirty_list); + inode->dirty_list = bluesky_list_prepend(&inode->fs->dirty_list, inode); + 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); } /* Unfortunately a glib hash table is only guaranteed to be able to store @@ -76,6 +87,12 @@ BlueSkyFS *bluesky_new_fs(gchar *name) bluesky_fs_key_equal_func); fs->next_inum = BLUESKY_ROOT_INUM + 1; fs->store = bluesky_store_new("file"); + fs->flushd_lock = g_mutex_new(); + fs->locations = g_hash_table_new(bluesky_cloudlog_hash, + bluesky_cloudlog_equal); + + fs->log_state = g_new0(BlueSkyCloudLogState, 1); + fs->log_state->data = g_string_new(""); return fs; } @@ -87,6 +104,7 @@ BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store) BlueSkyFS *fs = bluesky_deserialize_superblock(data->data); if (fs != NULL) { fs->store = store; + fs->log = bluesky_log_new("journal"); g_print("Loaded filesystem superblock\n"); g_free(fs->name); fs->name = g_strdup(name); @@ -98,12 +116,14 @@ BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store) g_print("Initializing fresh filesystem\n"); BlueSkyFS *fs = bluesky_new_fs(name); fs->store = store; + fs->log = bluesky_log_new("journal"); BlueSkyInode *root = bluesky_new_inode(BLUESKY_ROOT_INUM, fs, BLUESKY_DIRECTORY); root->nlink = 1; root->mode = 0755; bluesky_insert_inode(fs, root); + bluesky_inode_update_ctime(root, TRUE); bluesky_inode_flush(fs, root); bluesky_superblock_flush(fs); @@ -120,14 +140,29 @@ void bluesky_inode_ref(BlueSkyInode *inode) void bluesky_inode_unref(BlueSkyInode *inode) { if (g_atomic_int_dec_and_test(&inode->refcount)) { - g_print("Reference count for inode %"PRIu64" dropped to zero.\n", - inode->inum); + if (bluesky_verbose) { + g_log("bluesky/inode", G_LOG_LEVEL_DEBUG, + "Reference count for inode %"PRIu64" dropped to zero.", + inode->inum); + } /* Sanity check: Is the inode clean? */ - if (inode->change_commit < inode->change_count) { - g_warning("Dropping inode which is not clean (commit %"PRIi64" < change %"PRIi64")\n", inode->change_commit, inode->change_count); + if (inode->change_commit < inode->change_count + || inode->accessed_list != NULL + || inode->unlogged_list != NULL + || inode->dirty_list != NULL) { + g_warning("Dropping inode which is not clean (commit %"PRIi64" < change %"PRIi64"; accessed_list = %p; dirty_list = %p)\n", inode->change_commit, inode->change_count, inode->accessed_list, inode->dirty_list); } + /* These shouldn't be needed, but in case the above warning fires and + * we delete the inode anyway, we ought to be sure the inode is not on + * any LRU list. */ + g_mutex_lock(inode->fs->lock); + bluesky_list_unlink(&inode->fs->accessed_list, inode->accessed_list); + bluesky_list_unlink(&inode->fs->dirty_list, inode->dirty_list); + bluesky_list_unlink(&inode->fs->unlogged_list, inode->unlogged_list); + g_mutex_unlock(inode->fs->lock); + /* Free file type specific data. It should be an error for there to be * dirty data to commit when the reference count has reaches zero. */ switch (inode->type) { @@ -274,10 +309,11 @@ void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode) /* Start writeback of an inode and all associated data. */ void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier) { + GList *log_items = NULL; BlueSkyFS *fs = inode->fs; if (inode->type == BLUESKY_REGULAR) - bluesky_file_flush(inode, barrier); + bluesky_file_flush(inode, barrier, &log_items); GString *buf = g_string_new(""); bluesky_serialize_inode(buf, inode); @@ -286,6 +322,35 @@ void bluesky_inode_start_sync(BlueSkyInode *inode, BlueSkyStoreAsync *barrier) char key[64]; sprintf(key, "inode-%016"PRIx64, inode->inum); + BlueSkyCloudLog *cloudlog = bluesky_cloudlog_new(fs); + cloudlog->type = LOGTYPE_INODE; + cloudlog->inum = inode->inum; + cloudlog->data = data; + bluesky_string_ref(data); + + if (inode->type == BLUESKY_REGULAR) { + for (int i = 0; i < inode->blocks->len; i++) { + BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); + if (b->type == BLUESKY_BLOCK_CACHED + || b->type == BLUESKY_BLOCK_REF) + { + BlueSkyCloudID id = bluesky_cloudlog_id_from_string(b->ref); + g_array_append_val(cloudlog->pointers, id); + } + } + } + + log_items = g_list_prepend(log_items, bluesky_cloudlog_sync(cloudlog)); + + bluesky_cloudlog_insert(cloudlog); + + /* Wait for all log items to be committed to disk. */ + while (log_items != NULL) { + BlueSkyLogItem *log_item = (BlueSkyLogItem *)log_items->data; + bluesky_log_item_finish(log_item); + log_items = g_list_delete_link(log_items, log_items); + } + BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store); async->op = STORE_OP_PUT; async->key = g_strdup(key); @@ -303,31 +368,47 @@ 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); + if (bluesky_verbose) { + 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); + 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) { - g_print("Completing fetch of inode %"PRIu64"...\n", inode->inum); + 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)) { - g_print(" failed to load inode, cleaning up\n"); + 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); @@ -344,6 +425,7 @@ void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum) 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); @@ -376,5 +458,5 @@ void bluesky_superblock_flush(BlueSkyFS *fs) bluesky_store_async_submit(async); bluesky_store_async_unref(async); - bluesky_store_sync(fs->store); + //bluesky_store_sync(fs->store); }