X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fcloudlog.c;h=44799e3dfc366d8c7159d2d6342a398eb6f81d37;hb=75aed7ed122b11bbbe3814b6cc9bbacbf5d791c1;hp=ebbdeeba82d061f116724cee0110aa1e095c3999;hpb=9f0e2f7de7d919d6a83944f0e7fdbd07cb6c4189;p=bluesky.git diff --git a/bluesky/cloudlog.c b/bluesky/cloudlog.c index ebbdeeb..44799e3 100644 --- a/bluesky/cloudlog.c +++ b/bluesky/cloudlog.c @@ -268,6 +268,73 @@ BlueSkyCloudLog *bluesky_cloudlog_get(BlueSkyFS *fs, BlueSkyCloudID id) return item; } +/* Attempt to prefetch a cloud log item. This does not guarantee that it will + * be made available, but does make it more likely that a future call to + * bluesky_cloudlog_fetch will complete quickly. Item must be locked? */ +void bluesky_cloudlog_prefetch(BlueSkyCloudLog *item) +{ + if (item->data != NULL) + return; + + /* TODO: Some of the code here is duplicated with bluesky_log_map_object. + * Refactor to fix that. */ + BlueSkyFS *fs = item->fs; + BlueSkyCacheFile *map = NULL; + + /* First, check to see if the journal still contains a copy of the item and + * if so update the atime on the journal so it is likely to be kept around + * until we need it. */ + if ((item->location_flags | item->pending_write) & CLOUDLOG_JOURNAL) { + map = bluesky_cachefile_lookup(fs, -1, item->log_seq, TRUE); + if (map != NULL) { + map->atime = bluesky_get_current_time(); + bluesky_cachefile_unref(map); + g_mutex_unlock(map->lock); + return; + } + } + + item->location_flags &= ~CLOUDLOG_JOURNAL; + if (!(item->location_flags & CLOUDLOG_CLOUD)) + return; + + map = bluesky_cachefile_lookup(fs, + item->location.directory, + item->location.sequence, + FALSE); + if (map == NULL) + return; + + /* At this point, we have information about the log segment containing the + * item we need. If our item is already fetched, we have nothing to do + * except update the atime. If not, queue up a fetch of our object. */ + const BlueSkyRangesetItem *rangeitem; + rangeitem = bluesky_rangeset_lookup(map->items, + item->location.offset); + if (rangeitem == NULL) { + if (map->prefetches == NULL) + map->prefetches = bluesky_rangeset_new(); + + gchar *id = bluesky_cloudlog_id_to_string(item->id); + if (bluesky_verbose) + g_print("Need to prefetch %s\n", id); + g_free(id); + + bluesky_rangeset_insert(map->prefetches, + item->location.offset, + item->location.size, NULL); + + uint64_t start, length; + bluesky_rangeset_get_extents(map->prefetches, &start, &length); + if (bluesky_verbose) + g_print("Range to prefetch: %"PRIu64" + %"PRIu64"\n", + start, length); + } + + bluesky_cachefile_unref(map); + g_mutex_unlock(map->lock); +} + /* Ensure that a cloud log item is loaded in memory, and if not read it in. * TODO: Make asynchronous, and make this also fetch from the cloud. Right now * we only read from the log. Log item must be locked. */ @@ -276,6 +343,10 @@ void bluesky_cloudlog_fetch(BlueSkyCloudLog *log) if (log->data != NULL) return; + BlueSkyProfile *profile = bluesky_profile_get(); + if (profile != NULL) + bluesky_profile_add_event(profile, g_strdup_printf("Fetch log entry")); + /* There are actually two cases: a full deserialization if we have not ever * read the object before, and a partial deserialization where the metadata * is already in memory and we just need to remap the data. If the object @@ -283,55 +354,22 @@ void bluesky_cloudlog_fetch(BlueSkyCloudLog *log) * Once that is done, we can fall through the case of remapping the data * itself. */ if (log->type == LOGTYPE_UNKNOWN) { - bluesky_cloudlog_stats_update(log, -1); - BlueSkyRCStr *raw = NULL; - if ((log->location_flags | log->pending_write) & CLOUDLOG_JOURNAL) { - raw = bluesky_log_map_object(log->fs, -1, log->log_seq, - log->log_offset, log->log_size, FALSE); - } - - if (raw == NULL && (log->location_flags & CLOUDLOG_CLOUD)) { - log->location_flags &= ~CLOUDLOG_JOURNAL; - raw = bluesky_log_map_object(log->fs, - log->location.directory, - log->location.sequence, - log->location.offset, - log->location.size, - FALSE); - } - + BlueSkyRCStr *raw = bluesky_log_map_object(log, FALSE); g_assert(raw != NULL); bluesky_deserialize_cloudlog(log, raw->data, raw->len); bluesky_string_unref(raw); - bluesky_cloudlog_stats_update(log, 1); } /* At this point all metadata should be available and we need only remap * the object data. */ - - int offset; - if ((log->location_flags | log->pending_write) & CLOUDLOG_JOURNAL) { - bluesky_cloudlog_stats_update(log, -1); - offset = log->log_offset + sizeof(struct log_header); - log->data = bluesky_log_map_object(log->fs, -1, log->log_seq, - offset, log->data_size, TRUE); - bluesky_cloudlog_stats_update(log, 1); - } - - if (log->data == NULL && (log->location_flags & CLOUDLOG_CLOUD)) { - log->location_flags &= ~CLOUDLOG_JOURNAL; - bluesky_cloudlog_stats_update(log, -1); - offset = log->location.offset + sizeof(struct cloudlog_header); - log->data = bluesky_log_map_object(log->fs, log->location.directory, - log->location.sequence, - offset, log->data_size, TRUE); - bluesky_cloudlog_stats_update(log, 1); - } + log->data = bluesky_log_map_object(log, TRUE); if (log->data == NULL) { g_error("Unable to fetch cloudlog entry!"); } + if (profile != NULL) + bluesky_profile_add_event(profile, g_strdup_printf("Fetch complete")); g_cond_broadcast(log->cond); } @@ -351,6 +389,7 @@ BlueSkyCloudPointer bluesky_cloudlog_serialize(BlueSkyCloudLog *log, bluesky_cloudlog_serialize(ref, fs); } + /* FIXME: Ought lock to be taken earlier? */ g_mutex_lock(log->lock); bluesky_cloudlog_fetch(log); g_assert(log->data != NULL); @@ -447,6 +486,7 @@ static void cloudlog_flush_complete(BlueSkyStoreAsync *async, async2->op = STORE_OP_PUT; async2->key = g_strdup(async->key); async2->data = record->data; + async2->profile = async->profile; bluesky_string_ref(record->data); bluesky_store_async_submit(async2); bluesky_store_async_add_notifier(async2, @@ -519,10 +559,16 @@ void bluesky_cloudlog_encrypt(GString *segment, BlueSkyCryptKeys *keys) /* Make an decryption pass over a cloud log segment to decrypt items which were * encrypted. Also computes a list of all offsets which at which valid - * cloud log items are found and adds those offsets to items (if non-NULL). */ + * cloud log items are found and adds those offsets to items (if non-NULL). + * + * If allow_unauth is set to true, then allow a limited set of unauthenticated + * items that may have been rewritten by a file system cleaner. These include + * the checkpoint and inode map records only; other items must still pass + * authentication. */ void bluesky_cloudlog_decrypt(char *segment, size_t len, BlueSkyCryptKeys *keys, - BlueSkyRangeset *items) + BlueSkyRangeset *items, + gboolean allow_unauth) { char *data = segment; size_t remaining_size = len; @@ -536,9 +582,10 @@ void bluesky_cloudlog_decrypt(char *segment, size_t len, + GUINT32_FROM_LE(header->size3); if (item_size > remaining_size) break; - if (bluesky_crypt_block_decrypt(data, item_size, keys)) { + if (bluesky_crypt_block_decrypt(data, item_size, keys, allow_unauth)) { if (items != NULL) { - g_print(" data item at %zx\n", offset); + if (bluesky_verbose) + g_print(" data item at %zx\n", offset); bluesky_rangeset_insert(items, offset, item_size, GINT_TO_POINTER(TRUE)); }