X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Ffile.c;h=4824dd842bdfb991e49c591f3b34d43ffbce192f;hb=a8a9f2181e2e16d24d812ea1e7a7c8af42f0d2f1;hp=8be3ea1cb78b393ac89e2abfffdefc4f5b04e726;hpb=f597cd5067ed36508118d2ecd29338e7b81f47e4;p=bluesky.git diff --git a/bluesky/file.c b/bluesky/file.c index 8be3ea1..4824dd8 100644 --- a/bluesky/file.c +++ b/bluesky/file.c @@ -31,11 +31,10 @@ void bluesky_block_touch(BlueSkyInode *inode, uint64_t i) switch (block->type) { case BLUESKY_BLOCK_ZERO: - g_print("Allocating zero block of size %zd\n", block_len); block->data = bluesky_string_new(g_malloc0(block_len), block_len); break; case BLUESKY_BLOCK_REF: - bluesky_block_fetch(inode->fs, block, NULL); + bluesky_block_fetch(inode, block, NULL); g_assert(block->type == BLUESKY_BLOCK_CACHED); /* Fall through */ case BLUESKY_BLOCK_CACHED: @@ -51,6 +50,9 @@ void bluesky_block_touch(BlueSkyInode *inode, uint64_t i) g_atomic_int_add(&inode->fs->cache_dirty, 1); block->type = BLUESKY_BLOCK_DIRTY; + if (block->cloudref != NULL) + bluesky_cloudlog_unref(block->cloudref); + block->cloudref = NULL; } /* Set the size of a file. This will truncate or extend the file as needed. @@ -62,7 +64,10 @@ void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size) if (size == inode->size) return; - g_print("Truncating file to %"PRIi64" bytes\n", size); + if (bluesky_verbose) { + g_log("bluesky/file", G_LOG_LEVEL_DEBUG, + "Truncating file to %"PRIi64" bytes", size); + } uint64_t blocks = (size + BLUESKY_BLOCK_SIZE - 1) / BLUESKY_BLOCK_SIZE; @@ -92,13 +97,13 @@ void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size) /* Delete blocks from a file. Must reclaim memory. */ for (guint i = inode->blocks->len; i < blocks; i++) { BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); - g_free(b->ref); if (b->type == BLUESKY_BLOCK_CACHED || b->type == BLUESKY_BLOCK_DIRTY) g_atomic_int_add(&inode->fs->cache_total, -1); if (b->type == BLUESKY_BLOCK_DIRTY) g_atomic_int_add(&inode->fs->cache_dirty, -1); bluesky_string_unref(b->data); + bluesky_cloudlog_unref(b->cloudref); } g_array_set_size(inode->blocks, blocks); } @@ -129,8 +134,6 @@ void bluesky_file_truncate(BlueSkyInode *inode, uint64_t size) void bluesky_file_write(BlueSkyInode *inode, uint64_t offset, const char *data, gint len) { - g_print("Write %d bytes at offset %"PRIi64"\n", len, offset); - g_return_if_fail(inode->type == BLUESKY_REGULAR); g_return_if_fail(offset < inode->size); g_return_if_fail(len <= inode->size - offset); @@ -159,8 +162,6 @@ void bluesky_file_write(BlueSkyInode *inode, uint64_t offset, void bluesky_file_read(BlueSkyInode *inode, uint64_t offset, char *buf, gint len) { - g_print("Read %d bytes at offset %"PRIi64"\n", len, offset); - if (len == 0 && offset <= inode->size) return; @@ -174,18 +175,23 @@ void bluesky_file_read(BlueSkyInode *inode, uint64_t offset, uint64_t start_block, end_block; start_block = offset / BLUESKY_BLOCK_SIZE; end_block = (offset + len - 1) / BLUESKY_BLOCK_SIZE; - g_print("Start prefetch on blocks %"PRIi64" .. %"PRIi64"\n", - start_block, end_block); + if (bluesky_verbose) { + g_log("bluesky/file", G_LOG_LEVEL_DEBUG, + "Start prefetch on blocks %"PRIi64" .. %"PRIi64, + start_block, end_block); + } for (uint64_t i = start_block; i <= end_block; i++) { BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); if (b->type == BLUESKY_BLOCK_REF) - bluesky_block_fetch(inode->fs, b, barrier); + bluesky_block_fetch(inode, b, barrier); } bluesky_store_async_submit(barrier); bluesky_store_async_wait(barrier); bluesky_store_async_unref(barrier); - g_print("Prefetch complete.\n"); + if (bluesky_verbose) { + g_log("bluesky/file", G_LOG_LEVEL_DEBUG, "Prefetch complete."); + } while (len > 0) { uint64_t block_num = offset / BLUESKY_BLOCK_SIZE; @@ -199,7 +205,7 @@ void bluesky_file_read(BlueSkyInode *inode, uint64_t offset, memset(buf, 0, bytes); break; case BLUESKY_BLOCK_REF: - bluesky_block_fetch(inode->fs, b, NULL); + bluesky_block_fetch(inode, b, NULL); /* Fall through */ case BLUESKY_BLOCK_CACHED: case BLUESKY_BLOCK_DIRTY: @@ -213,6 +219,7 @@ void bluesky_file_read(BlueSkyInode *inode, uint64_t offset, } } +#if 0 /* Read the given block from cloud-backed storage if the data is not already * cached. */ static void block_fetch_completion(BlueSkyStoreAsync *async, gpointer data) @@ -222,12 +229,25 @@ static void block_fetch_completion(BlueSkyStoreAsync *async, gpointer data) bluesky_string_unref(block->data); block->data = async->data; bluesky_string_ref(block->data); + + if (block->data == NULL) { + g_warning("Failed to fetch data block from store!\n"); + block->data = bluesky_string_new(g_malloc0(BLUESKY_BLOCK_SIZE), + BLUESKY_BLOCK_SIZE); + } + block->type = BLUESKY_BLOCK_CACHED; } +#endif -void bluesky_block_fetch(BlueSkyFS *fs, BlueSkyBlock *block, +void bluesky_block_fetch(BlueSkyInode *inode, BlueSkyBlock *block, BlueSkyStoreAsync *barrier) { + // TODO: Implement this + +#if 0 + BlueSkyFS *fs = inode->fs; + if (block->type != BLUESKY_BLOCK_REF) return; @@ -244,71 +264,72 @@ void bluesky_block_fetch(BlueSkyFS *fs, BlueSkyBlock *block, bluesky_store_async_unref(async); g_atomic_int_add(&fs->cache_total, 1); +#endif } /* Write the given block to cloud-backed storage and mark it clean. */ -void bluesky_block_flush(BlueSkyFS *fs, BlueSkyBlock *block, - BlueSkyStoreAsync *barrier) +void bluesky_block_flush(BlueSkyInode *inode, BlueSkyBlock *block, + GList **log_items) { + BlueSkyFS *fs = inode->fs; + if (block->type != BLUESKY_BLOCK_DIRTY) return; - BlueSkyRCStr *data = block->data; + if (block->cloudref != NULL) + bluesky_cloudlog_unref(block->cloudref); - GChecksum *csum = g_checksum_new(G_CHECKSUM_SHA256); - g_checksum_update(csum, (const guchar *)data->data, data->len); - gchar *name = g_strdup(g_checksum_get_string(csum)); + BlueSkyRCStr *data = block->data; - /* Store the file data asynchronously, and don't bother waiting for a - * response. */ - BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store); - async->op = STORE_OP_PUT; - async->key = g_strdup(name); + BlueSkyCloudLog *cloudlog = bluesky_cloudlog_new(fs); + cloudlog->type = LOGTYPE_DATA; + cloudlog->inum = inode->inum; + cloudlog->data = data; bluesky_string_ref(data); - async->data = data; - bluesky_store_async_submit(async); - if (barrier != NULL) - bluesky_store_add_barrier(barrier, async); - bluesky_store_async_unref(async); + bluesky_cloudlog_sync(cloudlog); + *log_items = g_list_prepend(*log_items, cloudlog); + bluesky_cloudlog_insert(cloudlog); - g_free(block->ref); - block->ref = name; + block->cloudref = cloudlog; + bluesky_cloudlog_ref(cloudlog); block->type = BLUESKY_BLOCK_CACHED; g_atomic_int_add(&fs->cache_dirty, -1); - - g_checksum_free(csum); } /* Flush all blocks in a file to stable storage. */ -void bluesky_file_flush(BlueSkyInode *inode, BlueSkyStoreAsync *barrier) +void bluesky_file_flush(BlueSkyInode *inode, GList **log_items) { g_return_if_fail(inode->type == BLUESKY_REGULAR); for (int i = 0; i < inode->blocks->len; i++) { BlueSkyBlock *b = &g_array_index(inode->blocks, BlueSkyBlock, i); - bluesky_block_flush(inode->fs, b, barrier); + bluesky_block_flush(inode, b, log_items); } } /* Drop clean data blocks for a file from cache. */ void bluesky_file_drop_cached(BlueSkyInode *inode) { +#if 0 g_return_if_fail(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) { - g_log("bluesky/cache", G_LOG_LEVEL_DEBUG, - "Dropping block %d of inode %"PRIu64" from cache", - i, inode->inum); + if (bluesky_verbose) { + g_log("bluesky/cache", G_LOG_LEVEL_DEBUG, + "Dropping block %d of inode %"PRIu64" from cache", + i, inode->inum); + g_log("bluesky/cache", G_LOG_LEVEL_DEBUG, + " (reference count was %d)", b->data->refcount); + } - g_log("bluesky/cache", G_LOG_LEVEL_DEBUG, - " (reference count was %d)", b->data->refcount); bluesky_string_unref(b->data); b->data = NULL; b->type = BLUESKY_BLOCK_REF; g_atomic_int_add(&inode->fs->cache_total, -1); } } +#endif }