X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Finode.c;h=a568ae025891304690282eddd5bea4bc4c4810b3;hb=3175b881ccd14a39c4a206147cc99ecc80de3412;hp=0c745e86dd1658f7adde60a3a4dbd6af681de8ef;hpb=6443fe537efa35cdad192b2d35ea0398cce56c17;p=bluesky.git diff --git a/bluesky/inode.c b/bluesky/inode.c index 0c745e8..a568ae0 100644 --- 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(); @@ -40,6 +41,9 @@ void bluesky_inode_update_ctime(BlueSkyInode *inode, gboolean update_mtime) 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 @@ -134,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: @@ -154,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; @@ -200,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(""); @@ -218,6 +227,48 @@ void bluesky_inode_flush(BlueSkyFS *fs, BlueSkyInode *inode) 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; + + 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); +} + /* Fetch an inode from stable storage. */ void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum) { @@ -227,10 +278,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. */ @@ -240,8 +299,6 @@ 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");