// Rough size limit for a log segment. This is not a firm limit and there are
// no absolute guarantees on the size of a log segment.
-#define LOG_SEGMENT_SIZE (1 << 24)
+#define LOG_SEGMENT_SIZE (1 << 22)
+
+// Target amount of disk space to use for the journal and cache files, in
+// kilobytes.
+#define DISK_CACHE_SIZE_TARGET (64 * 1024)
#define HEADER_MAGIC 0x676f4c0a
#define FOOTER_MAGIC 0x2e435243
offset += sizeof(header) + sizeof(footer) + item->data->len;
- /* Since we have just written a new dirty object to the journal,
- * increment the count of live dirty objects in that journal file. The
- * count will be decremented when objects are deleted or written to the
- * cloud. */
- g_atomic_int_add(&log->current_log->dirty_refs, 1);
- item->dirty_journal = log->current_log;
-
/* Replace the log item's string data with a memory-mapped copy of the
* data, now that it has been written to the log file. (Even if it
* isn't yet on disk, it should at least be in the page cache and so
g_atomic_int_add(&cachefile->refcount, -1);
}
+static void cloudlog_fetch_complete(BlueSkyStoreAsync *async,
+ BlueSkyCacheFile *cachefile);
+
+static void cloudlog_fetch_start(BlueSkyCacheFile *cachefile)
+{
+ g_atomic_int_inc(&cachefile->refcount);
+ cachefile->fetching = TRUE;
+ g_print("Starting fetch of %s from cloud\n", cachefile->filename);
+ BlueSkyStoreAsync *async = bluesky_store_async_new(cachefile->fs->store);
+ async->op = STORE_OP_GET;
+ async->key = g_strdup(cachefile->filename);
+ bluesky_store_async_add_notifier(async,
+ (GFunc)cloudlog_fetch_complete,
+ cachefile);
+ bluesky_store_async_submit(async);
+ bluesky_store_async_unref(async);
+}
+
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");
+ if (async->result >= 0) {
+ 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;
+ } else {
+ g_print("Error fetching from cloud, retrying...\n");
+ cloudlog_fetch_start(cachefile);
}
- g_free(pathname);
- cachefile->fetching = FALSE;
- cachefile->ready = TRUE;
+
bluesky_cachefile_unref(cachefile);
g_cond_broadcast(cachefile->cond);
g_mutex_unlock(cachefile->lock);
BlueSkyLog *log = fs->log;
+ struct stat statbuf;
char logname[64];
int type;
g_mutex_lock(log->mmap_lock);
map = g_hash_table_lookup(log->mmap_cache, logname);
- if (map == NULL) {
- /* TODO: stat() call */
+ if (map == NULL
+ && type == CLOUDLOG_JOURNAL
+ && fstatat(log->dirfd, logname, &statbuf, 0) < 0) {
+ /* A stale reference to a journal file which doesn't exist any longer
+ * because it was reclaimed. Return NULL. */
+ } else if (map == NULL) {
+ g_print("Adding cache file %s\n", logname);
+
map = g_new0(BlueSkyCacheFile, 1);
- map->type = CLOUDLOG_JOURNAL;
+ map->fs = fs;
+ map->type = type;
map->lock = g_mutex_new();
map->type = type;
g_mutex_lock(map->lock);
g_hash_table_insert(log->mmap_cache, map->filename, map);
// If the log file is stored in the cloud, we may need to fetch it
- if (clouddir >= 0) {
- g_atomic_int_inc(&map->refcount);
- 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);
- }
+ if (clouddir >= 0)
+ cloudlog_fetch_start(map);
} else {
g_mutex_lock(map->lock);
}
g_mutex_unlock(log->mmap_lock);
- g_atomic_int_inc(&map->refcount);
+ if (map != NULL)
+ g_atomic_int_inc(&map->refcount);
return map;
}
* then we'll just skip the file on this pass. */
if (g_mutex_trylock(cachefile->lock)) {
int64_t age = bluesky_get_current_time() - cachefile->atime;
- g_print("%s addr=%p mapcount=%d refcount=%d dirty=%d atime_age=%f",
+ g_print("%s addr=%p mapcount=%d refcount=%d atime_age=%f",
cachefile->filename, cachefile->addr, cachefile->mapcount,
- cachefile->refcount, cachefile->dirty_refs, age / 1e6);
+ cachefile->refcount, age / 1e6);
if (cachefile->fetching)
g_print(" (fetching)");
g_print("\n");
- if (g_atomic_int_get(&cachefile->refcount) == 0
- && g_atomic_int_get(&cachefile->mapcount) == 0
- && g_atomic_int_get(&cachefile->dirty_refs) == 0)
+ if (g_atomic_int_get(&fs->log->disk_used) > DISK_CACHE_SIZE_TARGET
+ && g_atomic_int_get(&cachefile->refcount) == 0
+ && g_atomic_int_get(&cachefile->mapcount) == 0)
{
g_print(" ...deleting\n");
if (unlinkat(fs->log->dirfd, cachefile->filename, 0) < 0) {
cachefile->filename);
}
+ g_atomic_int_add(&fs->log->disk_used, -(cachefile->len / 1024));
g_hash_table_remove(fs->log->mmap_cache, cachefile->filename);
g_mutex_unlock(cachefile->lock);
g_mutex_free(cachefile->lock);
projects / bluesky.git / blobdiff