X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Finode.c;h=0a6166b6ebe0a15b241351d2453cae5e829133d4;hb=HEAD;hp=e11bfeb3c0a8b898387f295ffdb4e146b9db93b4;hpb=0a021d1c28cff9cbaa4c127a837816f96dd37a27;p=bluesky.git diff --git a/bluesky/inode.c b/bluesky/inode.c index e11bfeb..0a6166b 100644 --- a/bluesky/inode.c +++ b/bluesky/inode.c @@ -3,7 +3,29 @@ * Copyright (C) 2009 The Regents of the University of California * Written by Michael Vrable * - * TODO: Licensing + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. */ #include @@ -14,6 +36,8 @@ #include "bluesky-private.h" +static void inode_fetch_task(gpointer a, gpointer b); + /* Core filesystem. Different proxies, such as the NFSv3 one, interface to * this, but the core actually tracks the data which is stored. So far we just * implement an in-memory filesystem, but eventually this will be state which @@ -93,13 +117,25 @@ BlueSkyFS *bluesky_new_fs(gchar *name) fs->log_state = g_new0(BlueSkyCloudLogState, 1); fs->log_state->data = g_string_new(""); + fs->log_state->latest_cleaner_seq_seen = -1; + fs->log_state->uploads_pending_lock = g_mutex_new(); + fs->log_state->uploads_pending_cond = g_cond_new(); + + bluesky_cloudlog_threads_init(fs); + fs->inode_fetch_thread_pool = g_thread_pool_new(inode_fetch_task, NULL, + bluesky_max_threads, + FALSE, NULL); return fs; } -BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store) +BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store, + const gchar *master_key) { BlueSkyFS *fs = bluesky_new_fs(name); + fs->master_key = g_strdup(master_key); + fs->keys = g_new(BlueSkyCryptKeys, 1); + bluesky_crypt_derive_keys(fs->keys, master_key); fs->store = store; fs->log = bluesky_log_new("journal"); fs->log->fs = fs; @@ -120,6 +156,8 @@ BlueSkyFS *bluesky_init_fs(gchar *name, BlueSkyStore *store) bluesky_inode_do_sync(root); } + bluesky_cleaner_thread_launch(fs); + return fs; } @@ -254,6 +292,30 @@ BlueSkyInode *bluesky_new_inode(uint64_t inum, BlueSkyFS *fs, return i; } +/* Issue a prefetch hint for an inode. This signals that the inode may be + * needed soon. Does not return any useful data. */ +void bluesky_inode_prefetch(BlueSkyFS *fs, uint64_t inum) +{ + BlueSkyInode *inode = NULL; + + g_mutex_lock(fs->lock); + inode = (BlueSkyInode *)g_hash_table_lookup(fs->inodes, &inum); + + if (inode != NULL) { + /* Inode is already available, no need for any prefetching... */ + g_mutex_unlock(fs->lock); + return; + } + + InodeMapEntry *entry = bluesky_inode_map_lookup(fs->inode_map, inum, 0); + if (entry != NULL) { + bluesky_cloudlog_prefetch(entry->item); + } + + g_mutex_unlock(fs->lock); + return; +} + /* Retrieve an inode from the filesystem. Eventually this will be a cache and * so we might need to go fetch the inode from elsewhere; for now all * filesystem state is stored here. inode is returned with a reference held @@ -344,11 +406,15 @@ void bluesky_inode_do_sync(BlueSkyInode *inode) } } -static void complete_inode_fetch(BlueSkyInode *inode) +static void inode_fetch_task(gpointer a, gpointer b) { + BlueSkyInode *inode = (BlueSkyInode *)a; + + bluesky_profile_set((BlueSkyProfile *)inode->private_data); + BlueSkyCloudLog *item = inode->committed_item; inode->committed_item = NULL; - g_print("Completing fetch of inode %"PRIu64"...", inode->inum); + g_print("Completing fetch of inode %"PRIu64"...\n", inode->inum); g_mutex_lock(item->lock); bluesky_cloudlog_fetch(item); @@ -378,15 +444,19 @@ void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum) if (entry == NULL) return; + /* Non-portable behavior: We take the inode lock here, and release it in + * the fetching thread. This works with the default Linux pthreads + * implementation but is not guaranteed. */ + BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING); inode->change_count = 0; bluesky_inode_ref(inode); // Extra ref held by fetching process g_mutex_lock(inode->lock); - bluesky_insert_inode(fs, inode); + inode->committed_item = entry->item; bluesky_cloudlog_ref(entry->item); + bluesky_insert_inode(fs, inode); - /* TODO: Thread pool or other better async method. */ - g_thread_create((GThreadFunc)complete_inode_fetch, - (gpointer)inode, FALSE, NULL); + inode->private_data = bluesky_profile_get(); + g_thread_pool_push(fs->inode_fetch_thread_pool, inode, NULL); }