X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fcache.c;h=16e3d8162d21561974cd9e1f54a8ee153ba7d8ba;hb=9fbbecc6860f38fa83c122c7fd991ca11705278a;hp=b05baf8f5fe0e4d5f5677541864c0c52f5f8475a;hpb=c576372ed59370ff97a3bf2353ab477e4b744fac;p=bluesky.git diff --git a/bluesky/cache.c b/bluesky/cache.c index b05baf8..16e3d81 100644 --- a/bluesky/cache.c +++ b/bluesky/cache.c @@ -6,10 +6,20 @@ * TODO: Licensing */ +#define _GNU_SOURCE +#define _ATFILE_SOURCE + +#include #include +#include #include #include +#include #include +#include +#include +#include +#include #include "bluesky-private.h" @@ -225,8 +235,11 @@ static void drop_caches(BlueSkyInode *inode) * memory-mapped from log file or similar, so the kernel can drop this clean * data from memory for us and hence memory management isn't too important. * Mainly, we'll want to drop references to data that hasn't been accessed in a - * while so that it is possible to reclaim log segments on disk. */ -static void flushd_clean(BlueSkyFS *fs) + * while so that it is possible to reclaim log segments on disk. + * + * If aggressive is set, try much harder to drop data from the caches to free + * up space. */ +static void flushd_clean(BlueSkyFS *fs, int aggressive) { g_mutex_lock(fs->lock); @@ -241,7 +254,7 @@ static void flushd_clean(BlueSkyFS *fs) inode = fs->accessed_list.prev->data; uint64_t elapsed = bluesky_get_current_time() - inode->access_time; - if (elapsed < CACHE_DROP_DELAY) + if (elapsed < CACHE_DROP_DELAY && !aggressive) break; if (bluesky_verbose) { @@ -272,6 +285,106 @@ static void flushd_clean(BlueSkyFS *fs) g_mutex_unlock(fs->lock); } +/* Scan through all currently-stored files in the journal/cache and garbage + * collect old unused ones, if needed. */ +static void gather_cachefiles(gpointer key, gpointer value, gpointer user_data) +{ + GList **files = (GList **)user_data; + *files = g_list_prepend(*files, value); +} + +static gint compare_cachefiles(gconstpointer a, gconstpointer b) +{ + int64_t ta, tb; + + ta = ((BlueSkyCacheFile *)a)->atime; + tb = ((BlueSkyCacheFile *)b)->atime; + if (ta < tb) + return -1; + else if (ta > tb) + return 1; + else + return 0; +} + +void bluesky_cachefile_gc(BlueSkyFS *fs) +{ + GList *files = NULL; + + g_mutex_lock(fs->log->mmap_lock); + g_hash_table_foreach(fs->log->mmap_cache, gather_cachefiles, &files); + + /* Sort based on atime. The atime should be stable since it shouln't be + * updated except by threads which can grab the mmap_lock, which we already + * hold. */ + files = g_list_sort(files, compare_cachefiles); + + /* Walk the list of files, starting with the oldest, deleting files if + * possible until enough space has been reclaimed. */ + g_print("\nScanning cache: (total size = %d kB)\n", fs->log->disk_used); + while (files != NULL) { + BlueSkyCacheFile *cachefile = (BlueSkyCacheFile *)files->data; + /* Try to lock the structure, but if the lock is held by another thread + * 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; + if (bluesky_verbose) { + g_print("%s addr=%p mapcount=%d refcount=%d size=%d atime_age=%f", + cachefile->filename, cachefile->addr, cachefile->mapcount, + cachefile->refcount, cachefile->disk_used, age / 1e6); + if (cachefile->fetching) + g_print(" (fetching)"); + g_print("\n"); + } + + gboolean deletion_candidate = FALSE; + if (g_atomic_int_get(&fs->log->disk_used) + > bluesky_options.cache_size + && g_atomic_int_get(&cachefile->refcount) == 0 + && g_atomic_int_get(&cachefile->mapcount) == 0) + { + deletion_candidate = TRUE; + } + + /* Don't allow journal files to be reclaimed until all data is + * known to be durably stored in the cloud. */ + if (cachefile->type == CLOUDLOG_JOURNAL + && cachefile->log_seq >= fs->log->journal_watermark) + { + deletion_candidate = FALSE; + } + + if (deletion_candidate) { + if (bluesky_verbose) { + g_print(" ...deleting\n"); + } + if (unlinkat(fs->log->dirfd, cachefile->filename, 0) < 0) { + fprintf(stderr, "Unable to unlink journal %s: %m\n", + cachefile->filename); + } + + g_atomic_int_add(&fs->log->disk_used, -cachefile->disk_used); + g_hash_table_remove(fs->log->mmap_cache, cachefile->filename); + bluesky_rangeset_free(cachefile->items); + if (cachefile->prefetches != NULL) + bluesky_rangeset_free(cachefile->prefetches); + g_mutex_unlock(cachefile->lock); + g_mutex_free(cachefile->lock); + g_cond_free(cachefile->cond); + g_free(cachefile->filename); + g_free(cachefile); + } else { + g_mutex_unlock(cachefile->lock); + } + } + files = g_list_delete_link(files, files); + } + g_list_free(files); + g_print("\nEnding cache size: %d kB\n", fs->log->disk_used); + + g_mutex_unlock(fs->log->mmap_lock); +} + /* Run the flush daemon for a single iteration, though if it is already * executing returns immediately. */ static gpointer flushd_task(BlueSkyFS *fs) @@ -287,8 +400,17 @@ static gpointer flushd_task(BlueSkyFS *fs) flushd_dirty(fs); flushd_cloud(fs); - flushd_clean(fs); + flushd_clean(fs, 0); bluesky_cachefile_gc(fs); + + /* If running out of disk cache space, make another more aggressive pass to + * free up space. */ + if (g_atomic_int_get(&fs->log->disk_used) > bluesky_options.cache_size) { + g_print("Still short on disk space, trying again to free space...\n"); + flushd_clean(fs, 1); + bluesky_cachefile_gc(fs); + } + g_mutex_unlock(fs->flushd_lock); return NULL;