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     if (inode->change_count == inode->change_commit)
  46         return;
  47
  48     if (inode->change_pending) {
  49         /* Waiting for an earlier writeback to finish, so don't start a new
  50          * writeback yet. */
  51         return;
  52     }
  53
  54     uint64_t elapsed = bluesky_get_current_time() - inode->change_time;
  55     if (elapsed < WRITEBACK_DELAY) {
  56         /* Give a bit more time before starting writeback. */
  57         return;
  58     }
  59
  60     inode->change_pending = inode->change_count;
  61
  62     g_log("bluesky/flushd", G_LOG_LEVEL_DEBUG,
  63           "Starting flush of inode %"PRIu64, inode->inum);
  64
  65     /* Create a store barrier.  All operations part of the writeback will be
  66      * added to this barrier, so when the barrier completes we know that the
  67      * writeback is finished. */
  68     BlueSkyStoreAsync *barrier = bluesky_store_async_new(fs->store);
  69     barrier->op = STORE_OP_BARRIER;
  70
  71     bluesky_inode_start_sync(inode, barrier);
  72
  73     bluesky_store_async_add_notifier(barrier, writeback_complete, inode);
  74     bluesky_store_async_submit(barrier);
  75     bluesky_store_async_unref(barrier);
  76 }
  77
  78 /* Scan through the cache for dirty data and start flushing it to stable
  79  * storage.  This does not guarantee that data is committed when it returns.
  80  * Instead, this can be called occasionally to ensure that dirty data is
  81  * gradually flushed. */
  82 void bluesky_flushd_invoke(BlueSkyFS *fs)
  83 {
  84     g_log("bluesky/flushd", G_LOG_LEVEL_DEBUG,
  85           "Writeout process invoked");
  86
  87     g_mutex_lock(fs->lock);
  88     g_hash_table_foreach(fs->inodes, flushd_inode, fs);
  89     g_mutex_unlock(fs->lock);
  90 }