bluesky/cache.c

   1 /* Blue Sky: File Systems in the Cloud
   2  *
   3  * Copyright (C) 2009  The Regents of the University of California
   4  * Written by Michael Vrable <mvrable@cs.ucsd.edu>
   5  *
   6  * TODO: Licensing
   7  */
   8
   9 #include <stdint.h>
  10 #include <glib.h>
  11 #include <string.h>
  12 #include <inttypes.h>
  13
  14 #include "bluesky-private.h"
  15
  16 #define WRITEBACK_DELAY (5 * 1000000)
  17
  18 /* Filesystem caching and cache coherency. */
  19
  20 static void writeback_complete(gpointer a, gpointer i)
  21 {
  22     BlueSkyInode *inode = (BlueSkyInode *)i;
  23
  24     g_log("bluesky/flushd", G_LOG_LEVEL_DEBUG,
  25           "Writeback for inode %"PRIu64" complete", inode->inum);
  26
  27     g_mutex_lock(inode->lock);
  28
  29     inode->change_commit = inode->change_pending;
  30     if (inode->change_count == inode->change_commit) {
  31         /* If inode is no longer dirty... */
  32         inode->change_time = 0;
  33         inode->change_pending = 0;
  34     }
  35
  36     g_mutex_unlock(inode->lock);
  37 }
  38
  39 static void flushd_inode(gpointer key, gpointer value, gpointer user_data)
  40 {
  41     BlueSkyFS *fs = (BlueSkyFS *)user_data;
  42
  43     BlueSkyInode *inode = (BlueSkyInode *)value;
  44
  45     g_mutex_lock(inode->lock);
  46
  47     if (inode->change_count == inode->change_commit) {
  48         g_mutex_unlock(inode->lock);
  49         return;
  50     }
  51
  52     if (inode->change_pending) {
  53         /* Waiting for an earlier writeback to finish, so don't start a new
  54          * writeback yet. */
  55         g_mutex_unlock(inode->lock);
  56         return;
  57     }
  58
  59     uint64_t elapsed = bluesky_get_current_time() - inode->change_time;
  60     if (elapsed < WRITEBACK_DELAY) {
  61         /* Give a bit more time before starting writeback. */
  62         g_mutex_unlock(inode->lock);
  63         return;
  64     }
  65
  66     inode->change_pending = inode->change_count;
  67
  68     g_log("bluesky/flushd", G_LOG_LEVEL_DEBUG,
  69           "Starting flush of inode %"PRIu64, inode->inum);
  70
  71     /* Create a store barrier.  All operations part of the writeback will be
  72      * added to this barrier, so when the barrier completes we know that the
  73      * writeback is finished. */
  74     BlueSkyStoreAsync *barrier = bluesky_store_async_new(fs->store);
  75     barrier->op = STORE_OP_BARRIER;
  76
  77     bluesky_inode_start_sync(inode, barrier);
  78
  79     bluesky_store_async_add_notifier(barrier, writeback_complete, inode);
  80     bluesky_store_async_submit(barrier);
  81     bluesky_store_async_unref(barrier);
  82
  83     g_mutex_unlock(inode->lock);
  84 }
  85
  86 /* Scan through the cache for dirty data and start flushing it to stable
  87  * storage.  This does not guarantee that data is committed when it returns.
  88  * Instead, this can be called occasionally to ensure that dirty data is
  89  * gradually flushed. */
  90 void bluesky_flushd_invoke(BlueSkyFS *fs)
  91 {
  92     g_mutex_lock(fs->lock);
  93     g_hash_table_foreach(fs->inodes, flushd_inode, fs);
  94     g_mutex_unlock(fs->lock);
  95 }