* to it. */
static int page_size = 0;
-BlueSkyRCStr *bluesky_log_map_object(BlueSkyLog *log,
- int log_seq, int log_offset, int log_size)
+static void cloudlog_fetch_complete(BlueSkyStoreAsync *async,
+ BlueSkyCacheFile *cachefile)
+{
+ g_print("Fetch of %s from cloud complete, status = %d\n",
+ async->key, async->result);
+
+ if (async->result < 0)
+ return;
+
+ g_mutex_lock(cachefile->lock);
+ char *pathname = g_strdup_printf("%s/%s", cachefile->log->log_directory,
+ cachefile->filename);
+ if (!g_file_set_contents(pathname, async->data->data, async->data->len,
+ NULL))
+ {
+ g_print("Error writing out fetched file to cache!\n");
+ }
+ g_free(pathname);
+ cachefile->fetching = FALSE;
+ cachefile->ready = TRUE;
+ g_cond_broadcast(cachefile->cond);
+ g_mutex_unlock(cachefile->lock);
+}
+
+/* Find the BlueSkyCacheFile object for the given journal or cloud log segment.
+ * Returns the object in the locked state. */
+BlueSkyCacheFile *bluesky_cachefile_lookup(BlueSkyFS *fs,
+ int clouddir, int log_seq)
{
if (page_size == 0) {
page_size = getpagesize();
}
- BlueSkyMmap *map;
+ BlueSkyLog *log = fs->log;
+
+ BlueSkyCacheFile *map;
g_mutex_lock(log->mmap_lock);
map = g_hash_table_lookup(log->mmap_cache, GINT_TO_POINTER(log_seq));
if (map == NULL) {
- char logname[64];
- g_snprintf(logname, sizeof(logname), "log-%08d", log_seq);
- int fd = openat(log->dirfd, logname, O_RDONLY);
+ char *logname;
+
+ // A request for a local log file
+ if (clouddir < 0) {
+ logname = g_strdup_printf("log-%08d", log_seq);
+ } else {
+ logname = g_strdup_printf("log-%08d-%08d", clouddir, log_seq);
+ }
+
+ /* TODO: stat() call */
+ map = g_new0(BlueSkyCacheFile, 1);
+ map->type = CLOUDLOG_JOURNAL;
+ map->lock = g_mutex_new();
+ g_mutex_lock(map->lock);
+ map->cond = g_cond_new();
+ map->filename = logname;
+ map->log_seq = log_seq;
+ map->log = log;
+ g_atomic_int_set(&map->refcount, 0);
+
+ g_hash_table_insert(log->mmap_cache, GINT_TO_POINTER(log_seq), map);
+
+ // If the log file is stored in the cloud, we may need to fetch it
+ if (clouddir >= 0) {
+ map->fetching = TRUE;
+ g_print("Starting fetch of %s from cloud\n", logname);
+ BlueSkyStoreAsync *async = bluesky_store_async_new(fs->store);
+ async->op = STORE_OP_GET;
+ async->key = g_strdup(logname);
+ bluesky_store_async_add_notifier(async,
+ (GFunc)cloudlog_fetch_complete,
+ map);
+ bluesky_store_async_submit(async);
+ bluesky_store_async_unref(async);
+ }
+ } else {
+ g_mutex_lock(map->lock);
+ }
+
+ g_mutex_unlock(log->mmap_lock);
+ return map;
+}
+
+BlueSkyRCStr *bluesky_log_map_object(BlueSkyFS *fs, int log_dir,
+ int log_seq, int log_offset, int log_size)
+{
+ if (page_size == 0) {
+ page_size = getpagesize();
+ }
+
+ BlueSkyLog *log = fs->log;
+ BlueSkyCacheFile *map = bluesky_cachefile_lookup(fs, log_dir, log_seq);
+
+ if (map == NULL) {
+ return NULL;
+ }
+
+ if (map->addr == NULL) {
+ while (!map->ready && map->fetching) {
+ g_print("Waiting for log segment to be fetched from cloud...\n");
+ g_cond_wait(map->cond, map->lock);
+ }
+
+ int fd = openat(log->dirfd, map->filename, O_RDONLY);
if (fd < 0) {
- fprintf(stderr, "Error opening logfile %s: %m\n", logname);
- g_mutex_unlock(log->mmap_lock);
+ fprintf(stderr, "Error opening logfile %s: %m\n", map->filename);
+ g_mutex_unlock(map->lock);
return NULL;
}
- map = g_new0(BlueSkyMmap, 1);
-
off_t length = lseek(fd, 0, SEEK_END);
- map->log_seq = log_seq;
map->addr = (const char *)mmap(NULL, length, PROT_READ, MAP_SHARED,
fd, 0);
map->len = length;
- map->log = log;
- g_atomic_int_set(&map->refcount, 0);
- g_hash_table_insert(log->mmap_cache, GINT_TO_POINTER(log_seq), map);
-
- g_print("Mapped log segment %d...\n", log_seq);
+ g_print("Re-mapped log segment %d...\n", log_seq);
close(fd);
}
g_mutex_unlock(log->mmap_lock);
- return bluesky_string_new_from_mmap(map, log_offset, log_size);
+ BlueSkyRCStr *str;
+ str = bluesky_string_new_from_mmap(map, log_offset, log_size);
+ g_mutex_unlock(map->lock);
+ return str;
}
-void bluesky_mmap_unref(BlueSkyMmap *mmap)
+void bluesky_mmap_unref(BlueSkyCacheFile *mmap)
{
if (mmap == NULL)
return;
if (g_atomic_int_dec_and_test(&mmap->refcount)) {
- /* There is a potential race condition here: the BlueSkyLog contains a
- * hash table of currently-existing BlueSkyMmap objects, which does not
- * hold a reference. Some other thread might grab a new reference to
- * this object after reading it from the hash table. So, before
- * destruction we need to grab the lock for the hash table, then check
- * the reference count again. If it is still zero, we can proceed with
- * object destruction. */
- BlueSkyLog *log = mmap->log;
- g_mutex_lock(log->mmap_lock);
+ g_mutex_lock(mmap->lock);
if (g_atomic_int_get(&mmap->refcount) > 0) {
- g_mutex_unlock(log->mmap_lock);
+ g_print("Unmapped log segment %d...\n", mmap->log_seq);
+ munmap((void *)mmap->addr, mmap->len);
+ mmap->addr = NULL;
return;
}
-
- g_hash_table_remove(log->mmap_cache, GINT_TO_POINTER(mmap->log_seq));
- munmap((void *)mmap->addr, mmap->len);
- g_free(mmap);
- g_mutex_unlock(log->mmap_lock);
+ g_mutex_unlock(mmap->lock);
}
}
projects / bluesky.git / blobdiff