When we add a new name, up all of the cache limits, because we're probably

2002-03-25  Not Zed  <NotZed@Ximian.com>

        * camel-text-index.c (text_index_add_name): When we add a new
        name, up all of the cache limits, because we're probably going to
        be adding more.
        (text_index_sync): Drop the cache limits back down again, we dont
        need them when looking words up.

        ** MERGE camel_index branch.

        * camel-text-index.[ch]: Added files i forgot to add (eep nearly
        lost all this work!)

        * camel-block-file.c (sync_nolock): Fix an infinite loop in syncing.

svn path=/trunk/; revision=16242

1 files changed, 1124 insertions, 0 deletions

diff --git a/camel/camel-block-file.c b/camel/camel-block-file.c
new file mode 100644
index 0000000000..0340f9ecdf
--- /dev/null
+++ b/camel/camel-block-file.c
@@ -0,0 +1,1124 @@
+/*
+ * Copyright (C) 2001 Ximian Inc.
+ *
+ * Authors: Michael Zucchi <notzed@ximian.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "e-util/e-msgport.h"
+
+#include "camel-block-file.h"
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+#endif
+
+#define d(x) /*(printf("%s(%d):%s: ",  __FILE__, __LINE__, __PRETTY_FUNCTION__),(x))*/
+
+#ifdef ENABLE_THREADS
+
+/* Locks must be obtained in the order defined */
+
+struct _CamelBlockFilePrivate {
+	/* We use the private structure to form our lru list from */
+	struct _CamelBlockFilePrivate *next;
+	struct _CamelBlockFilePrivate *prev;
+
+	struct _CamelBlockFile *base;
+
+	pthread_mutex_t root_lock; /* for modifying the root block */
+	pthread_mutex_t cache_lock; /* for refcounting, flag manip, cache manip */
+	pthread_mutex_t io_lock; /* for all io ops */
+};
+
+#define CAMEL_BLOCK_FILE_LOCK(kf, lock) (pthread_mutex_lock(&(kf)->priv->lock))
+#define CAMEL_BLOCK_FILE_TRYLOCK(kf, lock) (pthread_mutex_trylock(&(kf)->priv->lock))
+#define CAMEL_BLOCK_FILE_UNLOCK(kf, lock) (pthread_mutex_unlock(&(kf)->priv->lock))
+
+#define LOCK(x) pthread_mutex_lock(&x)
+#define UNLOCK(x) pthread_mutex_unlock(&x)
+
+static pthread_mutex_t block_file_lock = PTHREAD_MUTEX_INITIALIZER;
+
+#else
+#define CAMEL_BLOCK_FILE_LOCK(kf, lock)
+#define CAMEL_BLOCK_FILE_TRYLOCK(kf, lock)
+#define CAMEL_BLOCK_FILE_UNLOCK(kf, lock)
+#define LOCK(x)
+#define UNLOCK(x)
+#endif
+
+/* lru cache of block files */
+static EDList block_file_list = E_DLIST_INITIALISER(block_file_list);
+/* list to store block files that are actually intialised */
+static EDList block_file_active_list = E_DLIST_INITIALISER(block_file_active_list);
+static int block_file_count = 0;
+static int block_file_threshhold = 10;
+
+#define CBF_CLASS(o) ((CamelBlockFileClass *)(((CamelObject *)o)->classfuncs))
+
+static int sync_nolock(CamelBlockFile *bs);
+static int sync_block_nolock(CamelBlockFile *bs, CamelBlock *bl);
+
+static int
+block_file_validate_root(CamelBlockFile *bs)
+{
+	struct stat st;
+	CamelBlockRoot *br;
+
+	br = bs->root;
+
+	fstat(bs->fd, &st);
+
+	d(printf("Validate root:\n"));
+	d(printf("version: %.8s (%.8s)\n", bs->root->version, bs->version));
+	d(printf("block size: %d (%d)\n", br->block_size, bs->block_size));
+	d(printf("free: %d (%d add size < %d)\n", br->free, br->free / bs->block_size * bs->block_size, (int)st.st_size));
+	d(printf("last: %d (%d and size: %d)\n", br->free, br->free / bs->block_size * bs->block_size, (int)st.st_size));
+
+	if (br->last == 0
+	    || memcmp(bs->root->version, bs->version, 8) != 0
+	    || br->block_size != bs->block_size
+	    || (br->free % bs->block_size) != 0
+	    || (br->last % bs->block_size) != 0
+	    || fstat(bs->fd, &st) == -1
+	    || st.st_size != br->last
+	    || br->free > st.st_size
+	    || (br->flags & CAMEL_BLOCK_FILE_SYNC) == 0) {
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+block_file_init_root(CamelBlockFile *bs)
+{
+	CamelBlockRoot *br = bs->root;
+
+	memset(br, 0, bs->block_size);
+	memcpy(br->version, bs->version, 8);
+	br->last = bs->block_size;
+	br->flags = CAMEL_BLOCK_FILE_SYNC;
+	br->free = 0;
+	br->block_size = bs->block_size;
+
+	return 0;
+}
+
+static void
+camel_block_file_class_init(CamelBlockFileClass *klass)
+{
+	klass->validate_root = block_file_validate_root;
+	klass->init_root = block_file_init_root;
+}
+
+static guint
+block_hash_func(const void *v)
+{
+	return ((camel_block_t)v) >> CAMEL_BLOCK_SIZE_BITS;
+}
+
+static void
+camel_block_file_init(CamelBlockFile *bs)
+{
+	struct _CamelBlockFilePrivate *p;
+
+	bs->fd = -1;
+	bs->block_size = CAMEL_BLOCK_SIZE;
+	e_dlist_init(&bs->block_cache);
+	bs->blocks = g_hash_table_new((GHashFunc)block_hash_func, NULL);
+	/* this cache size and the text index size have been tuned for about the best
+	   with moderate memory usage.  Doubling the memory usage barely affects performance. */
+	bs->block_cache_limit = 256;
+
+	p = bs->priv = g_malloc0(sizeof(*bs->priv));
+	p->base = bs;
+
+#ifdef ENABLE_THREADS
+	pthread_mutex_init(&p->root_lock, NULL);
+	pthread_mutex_init(&p->cache_lock, NULL);
+	pthread_mutex_init(&p->io_lock, NULL);
+#endif
+
+	/* link into lru list */
+	LOCK(block_file_lock);
+	e_dlist_addhead(&block_file_list, (EDListNode *)p);
+
+#if 0
+	{
+		printf("dumping block list\n");
+		printf(" head = %p p = %p\n", block_file_list.head, p);
+		p = block_file_list.head;
+		while (p->next) {
+			printf(" '%s'\n", p->base->path);
+			p = p->next;
+		}
+	}
+#endif
+
+	UNLOCK(block_file_lock);
+}
+
+static void
+camel_block_file_finalise(CamelBlockFile *bs)
+{
+	CamelBlock *bl, *bn;
+	struct _CamelBlockFilePrivate *p;
+
+	p = bs->priv;
+
+	if (bs->root_block)
+		camel_block_file_sync(bs);
+
+	/* remove from lru list */
+	LOCK(block_file_lock);
+	if (bs->fd != -1)
+		block_file_count--;
+	e_dlist_remove((EDListNode *)p);
+	UNLOCK(block_file_lock);
+
+	bl = (CamelBlock *)bs->block_cache.head;
+	bn = bl->next;
+	while (bn) {
+		if (bl->refcount != 0)
+			g_warning("Block '%d' still referenced", bl->id);
+		g_free(bl);
+		bl = bn;
+		bn = bn->next;
+	}
+
+	if (bs->root_block)
+		camel_block_file_unref_block(bs, bs->root_block);
+	g_free(bs->path);
+	close(bs->fd);
+
+#ifdef ENABLE_THREADS
+	pthread_mutex_destroy(&p->io_lock);
+	pthread_mutex_destroy(&p->cache_lock);
+	pthread_mutex_destroy(&p->root_lock);
+#endif
+	g_free(p);
+}
+
+CamelType
+camel_block_file_get_type(void)
+{
+	static CamelType type = CAMEL_INVALID_TYPE;
+	
+	if (type == CAMEL_INVALID_TYPE) {
+		type = camel_type_register(camel_object_get_type(), "CamelBlockFile",
+					   sizeof (CamelBlockFile),
+					   sizeof (CamelBlockFileClass),
+					   (CamelObjectClassInitFunc) camel_block_file_class_init,
+					   NULL,
+					   (CamelObjectInitFunc) camel_block_file_init,
+					   (CamelObjectFinalizeFunc) camel_block_file_finalise);
+	}
+	
+	return type;
+}
+
+/* 'use' a block file for io */
+static int
+block_file_use(CamelBlockFile *bs)
+{
+	struct _CamelBlockFilePrivate *nw, *nn, *p = bs->priv;
+	CamelBlockFile *bf;
+	int err;
+
+	/* We want to:
+	    remove file from active list
+	    lock it
+
+	   Then when done:
+	    unlock it
+	    add it back to end of active list
+	*/
+
+	CAMEL_BLOCK_FILE_LOCK(bs, io_lock);
+
+	if (bs->fd != -1)
+		return 0;
+	else
+		d(printf("Turning block file online: %s\n", bs->path));
+
+	if ((bs->fd = open(bs->path, bs->flags, 0600)) == -1) {
+		err = errno;
+		CAMEL_BLOCK_FILE_UNLOCK(bs, io_lock);
+		errno = err;
+		return -1;
+	}
+
+	LOCK(block_file_lock);
+	e_dlist_remove((EDListNode *)p);
+	e_dlist_addtail(&block_file_active_list, (EDListNode *)p);
+
+	block_file_count++;
+
+	nw = (struct _CamelBlockFilePrivate *)block_file_list.head;
+	nn = nw->next;
+	while (block_file_count > block_file_threshhold && nn) {
+		/* We never hit the current blockfile here, as its removed from the list first */
+		bf = nw->base;
+		if (bf->fd != -1) {
+			/* Need to trylock, as any of these lock levels might be trying
+			   to lock the block_file_lock, so we need to check and abort if so */
+			if (CAMEL_BLOCK_FILE_TRYLOCK(bf, root_lock) == 0) {
+				if (CAMEL_BLOCK_FILE_TRYLOCK(bf, cache_lock) == 0) {
+					if (CAMEL_BLOCK_FILE_TRYLOCK(bf, io_lock) == 0) {
+						d(printf("[%d] Turning block file offline: %s\n", block_file_count-1, bf->path));
+						sync_nolock(bf);
+						close(bf->fd);
+						bf->fd = -1;
+						block_file_count--;
+						CAMEL_BLOCK_FILE_UNLOCK(bf, io_lock);
+					}
+					CAMEL_BLOCK_FILE_UNLOCK(bf, cache_lock);
+				}
+				CAMEL_BLOCK_FILE_UNLOCK(bf, root_lock);
+			}
+		}
+		nw = nn;
+		nn = nw->next;
+	}
+
+	UNLOCK(block_file_lock);
+
+	return 0;
+}
+
+static void
+block_file_unuse(CamelBlockFile *bs)
+{
+	LOCK(block_file_lock);
+	e_dlist_remove((EDListNode *)bs->priv);
+	e_dlist_addtail(&block_file_list, (EDListNode *)bs->priv);
+	UNLOCK(block_file_lock);
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, io_lock);
+}
+
+/*
+o = camel_cache_get(c, key);
+camel_cache_unref(c, key);
+camel_cache_add(c, key, o);
+camel_cache_remove(c, key);
+*/
+
+/**
+ * camel_block_file_new:
+ * @path: 
+ * @: 
+ * @block_size: 
+ * 
+ * Allocate a new block file, stored at @path.  @version contains an 8 character
+ * version string which must match the head of the file, or the file will be
+ * intitialised.
+ * 
+ * @block_size is currently ignored and is set to CAMEL_BLOCK_SIZE.
+ *
+ * Return value: The new block file, or NULL if it could not be created.
+ **/
+CamelBlockFile *camel_block_file_new(const char *path, int flags, const char version[8], size_t block_size)
+{
+	CamelBlockFile *bs;
+
+	bs = (CamelBlockFile *)camel_object_new(camel_block_file_get_type());
+	memcpy(bs->version, version, 8);
+	bs->path = g_strdup(path);
+	bs->flags = flags;
+
+	bs->root_block = camel_block_file_get_block(bs, 0);
+	if (bs->root_block == NULL) {
+		camel_object_unref((CamelObject *)bs);
+		return NULL;
+	}
+	camel_block_file_detach_block(bs, bs->root_block);
+	bs->root = (CamelBlockRoot *)&bs->root_block->data;
+
+	/* we only need these flags on first open */
+	bs->flags &= ~(O_CREAT|O_EXCL|O_TRUNC);
+
+	/* Do we need to init the root block? */
+	if (CBF_CLASS(bs)->validate_root(bs) == -1) {
+		d(printf("Initialise root block: %.8s\n", version));
+
+		CBF_CLASS(bs)->init_root(bs);
+		camel_block_file_touch_block(bs, bs->root_block);
+		if (block_file_use(bs) == -1) {
+			camel_object_unref((CamelObject *)bs);
+			return NULL;
+		}
+		if (sync_block_nolock(bs, bs->root_block) == -1
+		    || ftruncate(bs->fd, bs->root->last) == -1) {
+			block_file_unuse(bs);
+			camel_object_unref((CamelObject *)bs);
+			return NULL;
+		}
+		block_file_unuse(bs);
+	}
+
+	return bs;
+}
+
+int
+camel_block_file_rename(CamelBlockFile *bs, const char *path)
+{
+	int ret;
+	struct stat st;
+	int err;
+
+	CAMEL_BLOCK_FILE_LOCK(bs, io_lock);
+
+	ret = rename(bs->path, path);
+	if (ret == -1) {
+		/* Maybe the rename actually worked */
+		err = errno;
+		if (stat(path, &st) == 0
+		    && stat(bs->path, &st) == -1
+		    && errno == ENOENT)
+			ret = 0;
+		errno = err;
+	}
+
+	if (ret != -1) {
+		g_free(bs->path);
+		bs->path = g_strdup(path);
+	}
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, io_lock);
+
+	return ret;
+}
+
+/**
+ * camel_block_file_new_block:
+ * @bs: 
+ * 
+ * Allocate a new block, return a pointer to it.  Old blocks
+ * may be flushed to disk during this call.
+ * 
+ * Return value: The block, or NULL if an error occured.
+ **/
+CamelBlock *camel_block_file_new_block(CamelBlockFile *bs)
+{
+	CamelBlock *bl;
+
+	CAMEL_BLOCK_FILE_LOCK(bs, root_lock);
+
+	if (bs->root->free) {
+		bl = camel_block_file_get_block(bs, bs->root->free);
+		if (bl == NULL)
+			goto fail;
+		bs->root->free = ((camel_block_t *)bl->data)[0];
+	} else {
+		bl = camel_block_file_get_block(bs, bs->root->last);
+		if (bl == NULL)
+			goto fail;
+		bs->root->last += CAMEL_BLOCK_SIZE;
+	}
+
+	bs->root_block->flags |= CAMEL_BLOCK_DIRTY;
+
+	bl->flags |= CAMEL_BLOCK_DIRTY;
+	memset(bl->data, 0, CAMEL_BLOCK_SIZE);
+fail:
+	CAMEL_BLOCK_FILE_UNLOCK(bs, root_lock);
+
+	return bl;
+}
+
+/**
+ * camel_block_file_free_block:
+ * @bs: 
+ * @id: 
+ * 
+ * 
+ **/
+int camel_block_file_free_block(CamelBlockFile *bs, camel_block_t id)
+{
+	CamelBlock *bl;
+
+	bl = camel_block_file_get_block(bs, id);
+	if (bl == NULL)
+		return -1;
+
+	CAMEL_BLOCK_FILE_LOCK(bs, root_lock);
+
+	((camel_block_t *)bl->data)[0] = bs->root->free;
+	bs->root->free = bl->id;
+	bl->flags |= CAMEL_BLOCK_DIRTY;
+	camel_block_file_unref_block(bs, bl);
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, root_lock);
+
+	return 0;
+}
+
+/**
+ * camel_block_file_get_block:
+ * @bs: 
+ * @id: 
+ * 
+ * Retreive a block @id.
+ * 
+ * Return value: The block, or NULL if blockid is invalid or a file error
+ * occured.
+ **/
+CamelBlock *camel_block_file_get_block(CamelBlockFile *bs, camel_block_t id)
+{
+	CamelBlock *bl, *flush, *prev;
+
+	/* Sanity check: Dont allow reading of root block (except before its been read)
+	   or blocks with invalid block id's */
+	if ((bs->root == NULL && id != 0)
+	    || (bs->root != NULL && (id > bs->root->last || id == 0))
+	    || (id % bs->block_size) != 0) {
+		errno = EINVAL;
+		return NULL;
+	}
+
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	bl = g_hash_table_lookup(bs->blocks, (void *)id);
+
+	d(printf("Get  block %08x: %s\n", id, bl?"cached":"must read"));
+
+	if (bl == NULL) {
+		/* LOCK io_lock */
+		if (block_file_use(bs) == -1) {
+			CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+			return NULL;
+		}
+
+		bl = g_malloc0(sizeof(*bl));
+		bl->id = id;
+		if (lseek(bs->fd, id, SEEK_SET) == -1
+		    || read(bs->fd, bl->data, CAMEL_BLOCK_SIZE) == -1) {
+			block_file_unuse(bs);
+			CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+			g_free(bl);
+			return NULL;
+		}
+
+		bs->block_cache_count++;
+		g_hash_table_insert(bs->blocks, (void *)bl->id, bl);
+
+		/* flush old blocks */
+		flush = (CamelBlock *)bs->block_cache.tailpred;
+		prev = flush->prev;
+		while (bs->block_cache_count > bs->block_cache_limit && prev) {
+			if (flush->refcount == 0) {
+				if (sync_block_nolock(bs, flush) != -1) {
+					g_hash_table_remove(bs->blocks, (void *)flush->id);
+					e_dlist_remove((EDListNode *)flush);
+					g_free(flush);
+					bs->block_cache_count--;
+				}
+			}
+			flush = prev;
+			prev = prev->prev;
+		}
+		/* UNLOCK io_lock */
+		block_file_unuse(bs);
+	} else {
+		e_dlist_remove((EDListNode *)bl);
+	}
+
+	e_dlist_addhead(&bs->block_cache, (EDListNode *)bl);
+	bl->refcount++;
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+
+	d(printf("Got  block %08x\n", id));
+
+	return bl;
+}
+
+/**
+ * camel_block_file_detach_block:
+ * @bs: 
+ * @bl: 
+ * 
+ * Detatch a block from the block file's cache.  The block should
+ * be unref'd or attached when finished with.  The block file will
+ * perform no writes of this block or flushing of it if the cache
+ * fills.
+ **/
+void camel_block_file_detach_block(CamelBlockFile *bs, CamelBlock *bl)
+{
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	g_hash_table_remove(bs->blocks, (void *)bl->id);
+	e_dlist_remove((EDListNode *)bl);
+	bl->flags |= CAMEL_BLOCK_DETACHED;
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+}
+
+/**
+ * camel_block_file_attach_block:
+ * @bs: 
+ * @bl: 
+ * 
+ * Reattach a block that has been detached.
+ **/
+void camel_block_file_attach_block(CamelBlockFile *bs, CamelBlock *bl)
+{
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	g_hash_table_insert(bs->blocks, (void *)bl->id, bl);
+	e_dlist_addtail(&bs->block_cache, (EDListNode *)bl);
+	bl->flags &= ~CAMEL_BLOCK_DETACHED;
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+}
+
+/**
+ * camel_block_file_touch_block:
+ * @bs: 
+ * @bl: 
+ * 
+ * Mark a block as dirty.  The block will be written to disk if
+ * it ever expires from the cache.
+ **/
+void camel_block_file_touch_block(CamelBlockFile *bs, CamelBlock *bl)
+{
+	CAMEL_BLOCK_FILE_LOCK(bs, root_lock);
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	bl->flags |= CAMEL_BLOCK_DIRTY;
+
+	if ((bs->root->flags & CAMEL_BLOCK_FILE_SYNC) && bl != bs->root_block) {
+		d(printf("turning off sync flag\n"));
+		bs->root->flags &= ~CAMEL_BLOCK_FILE_SYNC;
+		bs->root_block->flags |= CAMEL_BLOCK_DIRTY;
+		camel_block_file_sync_block(bs, bs->root_block);
+	}
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+	CAMEL_BLOCK_FILE_UNLOCK(bs, root_lock);
+}
+
+/**
+ * camel_block_file_unref_block:
+ * @bs: 
+ * @bl: 
+ * 
+ * Mark a block as unused.  If a block is used it will not be
+ * written to disk, or flushed from memory.
+ *
+ * If a block is detatched and this is the last reference, the
+ * block will be freed.
+ **/
+void camel_block_file_unref_block(CamelBlockFile *bs, CamelBlock *bl)
+{
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	if (bl->refcount == 1 && (bl->flags & CAMEL_BLOCK_DETACHED))
+		g_free(bl);
+	else
+		bl->refcount--;
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+}
+
+static int
+sync_block_nolock(CamelBlockFile *bs, CamelBlock *bl)
+{
+	d(printf("Sync block %08x: %s\n", bl->id, (bl->flags & CAMEL_BLOCK_DIRTY)?"dirty":"clean"));
+
+	if (bl->flags & CAMEL_BLOCK_DIRTY) {
+		if (lseek(bs->fd, bl->id, SEEK_SET) == -1
+		    || write(bs->fd, bl->data, CAMEL_BLOCK_SIZE) != CAMEL_BLOCK_SIZE) {
+			return -1;
+		}
+		bl->flags &= ~CAMEL_BLOCK_DIRTY;
+	}
+
+	return 0;
+}
+
+static int
+sync_nolock(CamelBlockFile *bs)
+{
+	CamelBlock *bl, *bn;
+	int work = FALSE;
+
+	bl = (CamelBlock *)bs->block_cache.head;
+	bn = bl->next;
+	while (bn) {
+		if (bl->flags & CAMEL_BLOCK_DIRTY) {
+			work = TRUE;
+			if (sync_block_nolock(bs, bl) == -1)
+				return -1;
+			bl = bn;
+		}
+		bn = bn->next;
+	}
+
+	if (!work
+	    && (bs->root_block->flags & CAMEL_BLOCK_DIRTY) == 0
+	    && (bs->root->flags & CAMEL_BLOCK_FILE_SYNC) != 0)
+		return 0;
+
+	d(printf("turning on sync flag\n"));
+
+	bs->root->flags |= CAMEL_BLOCK_FILE_SYNC;
+
+	return sync_block_nolock(bs, bs->root_block);
+}
+
+/**
+ * camel_block_file_sync_block:
+ * @bs: 
+ * @bl: 
+ * 
+ * Flush a block to disk immediately.  The block will only
+ * be flushed to disk if it is marked as dirty (touched).
+ * 
+ * Return value: -1 on io error.
+ **/
+int camel_block_file_sync_block(CamelBlockFile *bs, CamelBlock *bl)
+{
+	int ret;
+
+	/* LOCK io_lock */
+	if (block_file_use(bs) == -1)
+		return -1;
+
+	ret = sync_block_nolock(bs, bl);
+
+	block_file_unuse(bs);
+
+	return ret;
+}
+
+/**
+ * camel_block_file_sync:
+ * @bs: 
+ * 
+ * Sync all dirty blocks to disk, including the root block.
+ * 
+ * Return value: -1 on io error.
+ **/
+int camel_block_file_sync(CamelBlockFile *bs)
+{
+	int ret;
+
+	CAMEL_BLOCK_FILE_LOCK(bs, root_lock);
+	CAMEL_BLOCK_FILE_LOCK(bs, cache_lock);
+
+	/* LOCK io_lock */
+	if (block_file_use(bs) == -1)
+		ret = -1;
+	else {
+		ret = sync_nolock(bs);
+		block_file_unuse(bs);
+	}
+
+	CAMEL_BLOCK_FILE_UNLOCK(bs, cache_lock);
+	CAMEL_BLOCK_FILE_UNLOCK(bs, root_lock);
+
+	return ret;
+}
+
+/* ********************************************************************** */
+
+struct _CamelKeyFilePrivate {
+	struct _CamelKeyFilePrivate *next;
+	struct _CamelKeyFilePrivate *prev;
+
+	struct _CamelKeyFile *base;
+
+#ifdef ENABLE_THREADS
+	pthread_mutex_t lock;
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_KEY_FILE_LOCK(kf, lock) (pthread_mutex_lock(&(kf)->priv->lock))
+#define CAMEL_KEY_FILE_TRYLOCK(kf, lock) (pthread_mutex_trylock(&(kf)->priv->lock))
+#define CAMEL_KEY_FILE_UNLOCK(kf, lock) (pthread_mutex_unlock(&(kf)->priv->lock))
+
+static pthread_mutex_t key_file_lock = PTHREAD_MUTEX_INITIALIZER;
+
+#else
+#define CAMEL_KEY_FILE_LOCK(kf, lock)
+#define CAMEL_KEY_FILE_TRYLOCK(kf, lock)
+#define CAMEL_KEY_FILE_UNLOCK(kf, lock)
+#endif
+
+/* lru cache of block files */
+static EDList key_file_list = E_DLIST_INITIALISER(key_file_list);
+static EDList key_file_active_list = E_DLIST_INITIALISER(key_file_active_list);
+static int key_file_count = 0;
+static int key_file_threshhold = 10;
+
+static void
+camel_key_file_class_init(CamelKeyFileClass *klass)
+{
+}
+
+static void
+camel_key_file_init(CamelKeyFile *bs)
+{
+	struct _CamelKeyFilePrivate *p;
+
+	p = bs->priv = g_malloc0(sizeof(*bs->priv));
+	p->base = bs;
+
+#ifdef ENABLE_THREADS
+	pthread_mutex_init(&p->lock, NULL);
+#endif
+
+	LOCK(key_file_lock);
+	e_dlist_addhead(&key_file_list, (EDListNode *)p);
+	UNLOCK(key_file_lock);
+}
+
+static void
+camel_key_file_finalise(CamelKeyFile *bs)
+{
+	struct _CamelKeyFilePrivate *p = bs->priv;
+
+	LOCK(key_file_lock);
+	e_dlist_remove((EDListNode *)p);
+	UNLOCK(key_file_lock);
+
+	if (bs->fp)
+		fclose(bs->fp);
+	g_free(bs->path);
+
+#ifdef ENABLE_THREADS
+	pthread_mutex_destroy(&p->lock);
+#endif
+
+	g_free(p);
+}
+
+CamelType
+camel_key_file_get_type(void)
+{
+	static CamelType type = CAMEL_INVALID_TYPE;
+	
+	if (type == CAMEL_INVALID_TYPE) {
+		type = camel_type_register(camel_object_get_type(), "CamelKeyFile",
+					   sizeof (CamelKeyFile),
+					   sizeof (CamelKeyFileClass),
+					   (CamelObjectClassInitFunc) camel_key_file_class_init,
+					   NULL,
+					   (CamelObjectInitFunc) camel_key_file_init,
+					   (CamelObjectFinalizeFunc) camel_key_file_finalise);
+	}
+	
+	return type;
+}
+
+/* 'use' a key file for io */
+static int
+key_file_use(CamelKeyFile *bs)
+{
+	struct _CamelKeyFilePrivate *nw, *nn, *p = bs->priv;
+	CamelKeyFile *bf;
+	int err, fd;
+	char *flag;
+
+	/* We want to:
+	    remove file from active list
+	    lock it
+
+	   Then when done:
+	    unlock it
+	    add it back to end of active list
+	*/
+
+	/* TODO: Check header on reset? */
+
+	CAMEL_KEY_FILE_LOCK(bs, lock);
+
+	if (bs->fp != NULL)
+		return 0;
+	else
+		d(printf("Turning key file online: '%s'\n", bs->path));
+
+	if ((bs->flags & O_ACCMODE) == O_RDONLY)
+		flag = "r";
+	else
+		flag = "a+";
+
+	if ((fd = open(bs->path, bs->flags, 0600)) == -1
+	    || (bs->fp = fdopen(fd, flag)) == NULL) {
+		err = errno;
+		close(fd);
+		CAMEL_KEY_FILE_UNLOCK(bs, lock);
+		errno = err;
+		return -1;
+	}
+
+	LOCK(key_file_lock);
+	e_dlist_remove((EDListNode *)p);
+	e_dlist_addtail(&key_file_active_list, (EDListNode *)p);
+
+	key_file_count++;
+
+	nw = (struct _CamelKeyFilePrivate *)key_file_list.head;
+	nn = nw->next;
+	while (key_file_count > key_file_threshhold && nn) {
+		/* We never hit the current keyfile here, as its removed from the list first */
+		bf = nw->base;
+		if (bf->fp != NULL) {
+			/* Need to trylock, as any of these lock levels might be trying
+			   to lock the key_file_lock, so we need to check and abort if so */
+			if (CAMEL_BLOCK_FILE_TRYLOCK(bf, lock) == 0) {
+				d(printf("Turning key file offline: %s\n", bf->path));
+				fclose(bf->fp);
+				bf->fp = NULL;
+				key_file_count--;
+				CAMEL_BLOCK_FILE_UNLOCK(bf, lock);
+			}
+		}
+		nw = nn;
+		nn = nw->next;
+	}
+
+	UNLOCK(key_file_lock);
+
+	return 0;
+}
+
+static void
+key_file_unuse(CamelKeyFile *bs)
+{
+	LOCK(key_file_lock);
+	e_dlist_remove((EDListNode *)bs->priv);
+	e_dlist_addtail(&key_file_list, (EDListNode *)bs->priv);
+	UNLOCK(key_file_lock);
+
+	CAMEL_KEY_FILE_UNLOCK(bs, lock);
+}
+
+/**
+ * camel_key_file_new:
+ * @path: 
+ * @flags: open flags
+ * @version[]: Version string (header) of file.  Currently
+ * written but not checked.
+ * 
+ * Create a new key file.  A linked list of record blocks.
+ * 
+ * Return value: A new key file, or NULL if the file could not
+ * be opened/created/initialised.
+ **/
+CamelKeyFile *
+camel_key_file_new(const char *path, int flags, const char version[8])
+{
+	CamelKeyFile *kf;
+	off_t last;
+	int err;
+
+	d(printf("New key file '%s'\n", path));
+
+	kf = (CamelKeyFile *)camel_object_new(camel_key_file_get_type());
+	kf->path = g_strdup(path);
+	kf->fp = NULL;
+	kf->flags = flags;
+	kf->last = 8;
+
+	if (key_file_use(kf) == -1) {
+		camel_object_unref((CamelObject *)kf);
+		kf = NULL;
+	} else {
+		fseek(kf->fp, 0, SEEK_END);
+		last = ftell(kf->fp);
+		if (last == 0) {
+			fwrite(version, 8, 1, kf->fp);
+			last += 8;
+		}
+		kf->last = last;
+
+		err = ferror(kf->fp);
+		key_file_unuse(kf);
+
+		/* we only need these flags on first open */
+		kf->flags &= ~(O_CREAT|O_EXCL|O_TRUNC);
+
+		if (err) {
+			camel_object_unref((CamelObject *)kf);
+			kf = NULL;
+		}
+	}
+
+	return kf;
+}
+
+int
+camel_key_file_rename(CamelKeyFile *kf, const char *path)
+{
+	int ret;
+	struct stat st;
+	int err;
+
+	CAMEL_KEY_FILE_LOCK(kf, lock);
+
+	ret = rename(kf->path, path);
+	if (ret == -1) {
+		/* Maybe the rename actually worked */
+		err = errno;
+		if (stat(path, &st) == 0
+		    && stat(kf->path, &st) == -1
+		    && errno == ENOENT)
+			ret = 0;
+		errno = err;
+	}
+
+	if (ret != -1) {
+		g_free(kf->path);
+		kf->path = g_strdup(path);
+	}
+
+	CAMEL_KEY_FILE_UNLOCK(kf, lock);
+
+	return ret;
+}
+
+/**
+ * camel_key_file_write:
+ * @kf: 
+ * @parent: 
+ * @len: 
+ * @records: 
+ * 
+ * Write a new list of records to the key file.
+ * 
+ * Return value: -1 on io error.  The key file will remain unchanged.
+ **/
+int
+camel_key_file_write(CamelKeyFile *kf, camel_block_t *parent, size_t len, camel_key_t *records)
+{
+	camel_block_t next;
+	guint32 size;
+	int ret = -1;
+
+	d(printf("write key %08x len = %d\n", *parent, len));
+
+	if (len == 0) {
+		d(printf(" new parent = %08x\n", *parent));
+		return 0;
+	}
+
+	/* LOCK */
+	if (key_file_use(kf) == -1)
+		return -1;
+
+	size = len;
+
+	/* FIXME: Use io util functions? */
+	next = kf->last;
+	fseek(kf->fp, kf->last, SEEK_SET);
+	fwrite(parent, sizeof(*parent), 1, kf->fp);
+	fwrite(&size, sizeof(size), 1, kf->fp);
+	fwrite(records, sizeof(records[0]), len, kf->fp);
+
+	if (ferror(kf->fp)) {
+		clearerr(kf->fp);
+	} else {
+		kf->last = ftell(kf->fp);
+		*parent = next;
+		ret = len;
+	}
+
+	/* UNLOCK */
+	key_file_unuse(kf);
+
+	d(printf(" new parent = %08x\n", *parent));
+
+	return ret;
+}
+
+/**
+ * camel_key_file_read:
+ * @kf: 
+ * @start: The record pointer.  This will be set to the next record pointer on success.
+ * @len: Number of records read, if != NULL.
+ * @records: Records, allocated, must be freed with g_free, if != NULL.
+ * 
+ * Read the next block of data from the key file.  Returns the number of
+ * records.
+ * 
+ * Return value: -1 on io error.
+ **/
+int
+camel_key_file_read(CamelKeyFile *kf, camel_block_t *start, size_t *len, camel_key_t **records)
+{
+	guint32 size;
+	long pos = *start;
+	camel_block_t next;
+	int ret = -1;
+
+	if (pos == 0)
+		return 0;
+
+	/* LOCK */
+	if (key_file_use(kf) == -1)
+		return -1;
+
+	if (fseek(kf->fp, pos, SEEK_SET) == -1
+	    || fread(&next, sizeof(next), 1, kf->fp) != 1
+	    || fread(&size, sizeof(size), 1, kf->fp) != 1
+	    || size > 1024) {
+		clearerr(kf->fp);
+		goto fail;
+	}
+
+	if (len)
+		*len = size;
+
+	if (records) {
+		camel_key_t *keys = g_malloc(size * sizeof(camel_key_t));
+
+		if (fread(keys, sizeof(camel_key_t), size, kf->fp) != size) {
+			g_free(keys);
+			goto fail;
+		}
+		*records = keys;
+	}
+
+	*start = next;
+
+	ret = 0;
+fail:
+	/* UNLOCK */
+	key_file_unuse(kf);
+
+	return ret;
+}