path: root/examples/c/ex_file_system.c

/*-
 * Public Domain 2014-2016 MongoDB, Inc.
 * Public Domain 2008-2014 WiredTiger, Inc.
 *
 * This is free and unencumbered software released into the public domain.
 *
 * Anyone is free to copy, modify, publish, use, compile, sell, or
 * distribute this software, either in source code form or as a compiled
 * binary, for any purpose, commercial or non-commercial, and by any
 * means.
 *
 * In jurisdictions that recognize copyright laws, the author or authors
 * of this software dedicate any and all copyright interest in the
 * software to the public domain. We make this dedication for the benefit
 * of the public at large and to the detriment of our heirs and
 * successors. We intend this dedication to be an overt act of
 * relinquishment in perpetuity of all present and future rights to this
 * software under copyright law.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * ex_file_system.c
 * 	demonstrates how to use the custom file system interface
 */

/*
 * Include WiredTiger internal functions: we need architecture portable locking
 * in this example, and we use the TAILQ_XXX functions to keep the code simple.
 *
 * Application-writers SHOULD NOT INCLUDE "wt_internal.h", the public WiredTiger
 * include files should be used instead:
 *
 *	#include <wiredtiger.h>
 *	#include <wiredtiger_ext.h>
 */
#include "wt_internal.h"

/*
 * This example code uses internal WiredTiger functions for portable locking.
 * We use #defines to clarify the meaning and ignore errors to simplify the
 * code.
 *
 * Application writers SHOULD NOT COPY THIS LOCKING CODE, it's special-case code
 * to make this example portable across platforms.
 */
#define	ALLOCATE_FILE_SYSTEM_LOCK(demo_fs)				\
	(void)__wt_spin_init(NULL, &(demo_fs)->lock, "demo file handle lock")
#define	DESTROY_FILE_SYSTEM_LOCK(wt_session, demo_fs)			\
	__wt_spin_destroy((WT_SESSION_IMPL *)(wt_session), &(demo_fs)->lock)
#define	LOCK_FILE_SYSTEM(wt_session, demo_fs)				\
	__wt_spin_lock((WT_SESSION_IMPL *)(wt_session), &(demo_fs)->lock)
#define	UNLOCK_FILE_SYSTEM(wt_session, demo_fs)				\
	__wt_spin_unlock(						\
	    (WT_SESSION_IMPL *)(wt_session), &(demo_fs)->lock)

/*
 * Example file system implementation, using memory buffers to represent files.
 */
typedef struct {
	WT_FILE_SYSTEM iface;

	/*
	 * WiredTiger performs schema and I/O operations in parallel, all file
	 * system and file handle access must be thread-safe. This example uses
	 * a single, global file system lock for simplicity; real applications
	 * might require finer granularity, for example, a single lock for the
	 * file system handle list and per-handle locks serializing I/O.
	 */
	WT_SPINLOCK lock;			/* Lock */

	int opened_file_count;
	int opened_unique_file_count;
	int closed_file_count;
	int read_ops;
	int write_ops;

	/* Queue of file handles */
	TAILQ_HEAD(demo_file_handle_qh, demo_file_handle) fileq;

	WT_EXTENSION_API *wtext;		/* Extension functions */

} DEMO_FILE_SYSTEM;

typedef struct demo_file_handle {
	WT_FILE_HANDLE iface;

	/*
	 * Add custom file handle fields after the interface.
	 */
	DEMO_FILE_SYSTEM *demo_fs;		/* Enclosing file system */

	TAILQ_ENTRY(demo_file_handle) q;	/* Queue of handles */
	uint32_t ref;				/* Reference count */

	char	*buf;				/* In-memory contents */
	size_t	 bufsize;			/* In-memory buffer size */

	size_t	 size;				/* Read/write data size */
} DEMO_FILE_HANDLE;

/*
 * Extension initialization function.
 */
#ifdef _WIN32
/*
 * Explicitly export this function so it is visible when loading extensions.
 */
__declspec(dllexport)
#endif
int demo_file_system_create(WT_CONNECTION *, WT_CONFIG_ARG *);

/*
 * Forward function declarations for file system API implementation
 */
static int demo_fs_open(WT_FILE_SYSTEM *, WT_SESSION *,
    const char *, WT_FS_OPEN_FILE_TYPE, uint32_t, WT_FILE_HANDLE **);
static int demo_fs_directory_list(WT_FILE_SYSTEM *, WT_SESSION *,
    const char *, const char *, char ***, uint32_t *);
static int demo_fs_directory_list_free(
    WT_FILE_SYSTEM *, WT_SESSION *, char **, uint32_t);
static int demo_fs_exist(WT_FILE_SYSTEM *, WT_SESSION *, const char *, bool *);
static int demo_fs_remove(
    WT_FILE_SYSTEM *, WT_SESSION *, const char *, uint32_t);
static int demo_fs_rename(
    WT_FILE_SYSTEM *, WT_SESSION *, const char *, const char *, uint32_t);
static int demo_fs_size(
    WT_FILE_SYSTEM *, WT_SESSION *, const char *, wt_off_t *);
static int demo_fs_terminate(WT_FILE_SYSTEM *, WT_SESSION *);

/*
 * Forward function declarations for file handle API implementation
 */
static int demo_file_close(WT_FILE_HANDLE *, WT_SESSION *);
static int demo_file_lock(WT_FILE_HANDLE *, WT_SESSION *, bool);
static int demo_file_read(
    WT_FILE_HANDLE *, WT_SESSION *, wt_off_t, size_t, void *);
static int demo_file_size(WT_FILE_HANDLE *, WT_SESSION *, wt_off_t *);
static int demo_file_sync(WT_FILE_HANDLE *, WT_SESSION *);
static int demo_file_truncate(WT_FILE_HANDLE *, WT_SESSION *, wt_off_t);
static int demo_file_write(
    WT_FILE_HANDLE *, WT_SESSION *, wt_off_t, size_t, const void *);

/*
 * Forward function declarations for internal functions
 */
static int demo_handle_remove(WT_SESSION *, DEMO_FILE_HANDLE *);
static DEMO_FILE_HANDLE *demo_handle_search(WT_FILE_SYSTEM *, const char *);

#define	DEMO_FILE_SIZE_INCREMENT	32768

/*
 * string_match --
 *      Return if a string matches a byte string of len bytes.
 */
static bool
byte_string_match(const char *str, const char *bytes, size_t len)
{
	return (strncmp(str, bytes, len) == 0 && (str)[(len)] == '\0');
}

/*
 * demo_file_system_create --
 *	Initialization point for demo file system
 */
int
demo_file_system_create(WT_CONNECTION *conn, WT_CONFIG_ARG *config)
{
	DEMO_FILE_SYSTEM *demo_fs;
	WT_CONFIG_ITEM k, v;
	WT_CONFIG_PARSER *config_parser;
	WT_EXTENSION_API *wtext;
	WT_FILE_SYSTEM *file_system;
	int ret = 0;

	wtext = conn->get_extension_api(conn);

	if ((demo_fs = calloc(1, sizeof(DEMO_FILE_SYSTEM))) == NULL) {
		(void)wtext->err_printf(wtext, NULL,
		    "demo_file_system_create: %s",
		    wtext->strerror(wtext, NULL, ENOMEM));
		return (ENOMEM);
	}
	demo_fs->wtext = wtext;
	file_system = (WT_FILE_SYSTEM *)demo_fs;

	/*
	 * Applications may have their own configuration information to pass to
	 * the underlying filesystem implementation. See the main function for
	 * the setup of those configuration strings; here we parse configuration
	 * information as passed in by main, through WiredTiger.
	 *
	 * Retrieve our configuration information, the "config" value.
	 */
	if ((ret = wtext->config_get(wtext, NULL, config, "config", &v)) != 0) {
		(void)wtext->err_printf(wtext, NULL,
		    "WT_EXTENSION_API.config_get: config: %s",
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}

	/* Open a WiredTiger parser on the "config" value. */
	if ((ret = wtext->config_parser_open(
	    wtext, NULL, v.str, v.len, &config_parser)) != 0) {
		(void)wtext->err_printf(wtext, NULL,
		    "WT_EXTENSION_API.config_parser_open: config: %s",
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}

	/* Step through our configuration values. */
	printf("Custom file system configuration\n");
	while ((ret = config_parser->next(config_parser, &k, &v)) == 0) {
		if (byte_string_match("config_string", k.str, k.len)) {
			printf("\t" "key %.*s=\"%.*s\"\n",
			    (int)k.len, k.str, (int)v.len, v.str);
			continue;
		}
		if (byte_string_match("config_value", k.str, k.len)) {
			printf("\t" "key %.*s=%" PRId64 "\n",
			    (int)k.len, k.str, v.val);
			continue;
		}
		ret = EINVAL;
		(void)wtext->err_printf(wtext, NULL,
		    "WT_CONFIG_PARSER.next: unexpected configuration "
		    "information: %.*s=%.*s: %s",
		    (int)k.len, k.str, (int)v.len, v.str,
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}

	/* Check for expected parser termination and close the parser. */
	if (ret != WT_NOTFOUND) {
		(void)wtext->err_printf(wtext, NULL,
		    "WT_CONFIG_PARSER.next: config: %s",
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}
	if ((ret = config_parser->close(config_parser)) != 0) {
		(void)wtext->err_printf(wtext, NULL,
		    "WT_CONFIG_PARSER.close: config: %s",
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}

	ALLOCATE_FILE_SYSTEM_LOCK(demo_fs);

	/* Initialize the in-memory jump table. */
	file_system->fs_directory_list = demo_fs_directory_list;
	file_system->fs_directory_list_free = demo_fs_directory_list_free;
	file_system->fs_exist = demo_fs_exist;
	file_system->fs_open_file = demo_fs_open;
	file_system->fs_remove = demo_fs_remove;
	file_system->fs_rename = demo_fs_rename;
	file_system->fs_size = demo_fs_size;
	file_system->terminate = demo_fs_terminate;

	if ((ret = conn->set_file_system(conn, file_system, NULL)) != 0) {
		(void)wtext->err_printf(wtext, NULL,
		    "WT_CONNECTION.set_file_system: %s",
		    wtext->strerror(wtext, NULL, ret));
		goto err;
	}
	return (0);

err:	free(demo_fs);
	/* An error installing the file system is fatal. */
	exit(1);
}

/*
 * demo_fs_open --
 *	fopen for our demo file system
 */
static int
demo_fs_open(WT_FILE_SYSTEM *file_system, WT_SESSION *session,
    const char *name, WT_FS_OPEN_FILE_TYPE file_type, uint32_t flags,
    WT_FILE_HANDLE **file_handlep)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	WT_EXTENSION_API *wtext;
	WT_FILE_HANDLE *file_handle;
	int ret = 0;

	(void)file_type;					/* Unused */
	(void)flags;						/* Unused */

	*file_handlep = NULL;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;
	demo_fh = NULL;
	wtext = demo_fs->wtext;

	LOCK_FILE_SYSTEM(session, demo_fs);
	++demo_fs->opened_file_count;

	/*
	 * First search the file queue, if we find it, assert there's only a
	 * single reference, we only support a single handle on any file.
	 */
	demo_fh = demo_handle_search(file_system, name);
	if (demo_fh != NULL) {
		if (demo_fh->ref != 0) {
			(void)wtext->err_printf(wtext, session,
			    "demo_fs_open: %s: file already open", name);
			ret = EBUSY;
			goto err;
		}

		demo_fh->ref = 1;

		*file_handlep = (WT_FILE_HANDLE *)demo_fh;

		UNLOCK_FILE_SYSTEM(session, demo_fs);
		return (0);
	}

	/* The file hasn't been opened before, create a new one. */
	if ((demo_fh = calloc(1, sizeof(DEMO_FILE_HANDLE))) == NULL) {
		ret = ENOMEM;
		goto err;
	}

	/* Initialize private information. */
	demo_fh->demo_fs = demo_fs;
	demo_fh->ref = 1;
	if ((demo_fh->buf = calloc(1, DEMO_FILE_SIZE_INCREMENT)) == NULL) {
		ret = ENOMEM;
		goto err;
	}
	demo_fh->bufsize = DEMO_FILE_SIZE_INCREMENT;
	demo_fh->size = 0;

	/* Initialize public information. */
	file_handle = (WT_FILE_HANDLE *)demo_fh;
	if ((file_handle->name = strdup(name)) == NULL) {
		ret = ENOMEM;
		goto err;
	}

	/*
	 * Setup the function call table for our custom file system. Set the
	 * function pointer to NULL where our implementation doesn't support
	 * the functionality.
	 */
	file_handle->close = demo_file_close;
	file_handle->fh_advise = NULL;
	file_handle->fh_extend = NULL;
	file_handle->fh_extend_nolock = NULL;
	file_handle->fh_lock = demo_file_lock;
	file_handle->fh_map = NULL;
	file_handle->fh_map_discard = NULL;
	file_handle->fh_map_preload = NULL;
	file_handle->fh_unmap = NULL;
	file_handle->fh_read = demo_file_read;
	file_handle->fh_size = demo_file_size;
	file_handle->fh_sync = demo_file_sync;
	file_handle->fh_sync_nowait = NULL;
	file_handle->fh_truncate = demo_file_truncate;
	file_handle->fh_write = demo_file_write;

	TAILQ_INSERT_HEAD(&demo_fs->fileq, demo_fh, q);
	++demo_fs->opened_unique_file_count;

	*file_handlep = file_handle;

	if (0) {
err:		free(demo_fh->buf);
		free(demo_fh);
	}

	UNLOCK_FILE_SYSTEM(session, demo_fs);
	return (ret);
}

/*
 * demo_fs_directory_list --
 *	Return a list of files in a given sub-directory.
 */
static int
demo_fs_directory_list(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, const char *directory,
    const char *prefix, char ***dirlistp, uint32_t *countp)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	size_t len, prefix_len;
	uint32_t allocated, count;
	int ret = 0;
	char *name, **entries;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	*dirlistp = NULL;
	*countp = 0;

	entries = NULL;
	allocated = count = 0;
	len = strlen(directory);
	prefix_len = prefix == NULL ? 0 : strlen(prefix);

	LOCK_FILE_SYSTEM(session, demo_fs);
	TAILQ_FOREACH(demo_fh, &demo_fs->fileq, q) {
		name = demo_fh->iface.name;
		if (strncmp(name, directory, len) != 0 ||
		    (prefix != NULL && strncmp(name, prefix, prefix_len) != 0))
			continue;

		/*
		 * Increase the list size in groups of 10, it doesn't
		 * matter if the list is a bit longer than necessary.
		 */
		if (count >= allocated) {
			entries = realloc(
			    entries, (allocated + 10) * sizeof(char *));
			if (entries == NULL) {
				ret = ENOMEM;
				goto err;
			}
			memset(entries + allocated * sizeof(char *),
			    0, 10 * sizeof(char *));
			allocated += 10;
		}
		entries[count++] = strdup(name);
	}

	*dirlistp = entries;
	*countp = count;

err:	UNLOCK_FILE_SYSTEM(session, demo_fs);
	if (ret == 0)
		return (0);

	if (entries != NULL) {
		while (count > 0)
			free(entries[--count]);
		free(entries);
	}

	return (ret);
}

/*
 * demo_fs_directory_list_free --
 *	Free memory allocated by demo_fs_directory_list.
 */
static int
demo_fs_directory_list_free(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, char **dirlist, uint32_t count)
{
	(void)file_system;
	(void)session;

	if (dirlist != NULL) {
		while (count > 0)
			free(dirlist[--count]);
		free(dirlist);
	}
	return (0);
}

/*
 * demo_fs_exist --
 *	Return if the file exists.
 */
static int
demo_fs_exist(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, const char *name, bool *existp)
{
	DEMO_FILE_SYSTEM *demo_fs;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	LOCK_FILE_SYSTEM(session, demo_fs);
	*existp = demo_handle_search(file_system, name) != NULL;
	UNLOCK_FILE_SYSTEM(session, demo_fs);

	return (0);
}

/*
 * demo_fs_remove --
 *	POSIX remove.
 */
static int
demo_fs_remove(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, const char *name, uint32_t flags)
{
	DEMO_FILE_SYSTEM *demo_fs;
	DEMO_FILE_HANDLE *demo_fh;
	int ret = 0;

	(void)flags;					/* Unused */

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	ret = ENOENT;
	LOCK_FILE_SYSTEM(session, demo_fs);
	if ((demo_fh = demo_handle_search(file_system, name)) != NULL)
		ret = demo_handle_remove(session, demo_fh);
	UNLOCK_FILE_SYSTEM(session, demo_fs);

	return (ret);
}

/*
 * demo_fs_rename --
 *	POSIX rename.
 */
static int
demo_fs_rename(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, const char *from, const char *to, uint32_t flags)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	char *copy;
	int ret = 0;

	(void)flags;					/* Unused */

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	LOCK_FILE_SYSTEM(session, demo_fs);
	if ((demo_fh = demo_handle_search(file_system, from)) == NULL)
		ret = ENOENT;
	else if ((copy = strdup(to)) == NULL)
		ret = ENOMEM;
	else {
		free(demo_fh->iface.name);
		demo_fh->iface.name = copy;
	}
	UNLOCK_FILE_SYSTEM(session, demo_fs);
	return (ret);
}

/*
 * demo_fs_size --
 *	Get the size of a file in bytes, by file name.
 */
static int
demo_fs_size(WT_FILE_SYSTEM *file_system,
    WT_SESSION *session, const char *name, wt_off_t *sizep)
{
	DEMO_FILE_SYSTEM *demo_fs;
	DEMO_FILE_HANDLE *demo_fh;
	int ret = 0;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	ret = ENOENT;
	LOCK_FILE_SYSTEM(session, demo_fs);
	if ((demo_fh = demo_handle_search(file_system, name)) != NULL)
		ret = demo_file_size((WT_FILE_HANDLE *)demo_fh, session, sizep);
	UNLOCK_FILE_SYSTEM(session, demo_fs);

	return (ret);
}

/*
 * demo_fs_terminate --
 *	Discard any resources on termination
 */
static int
demo_fs_terminate(WT_FILE_SYSTEM *file_system, WT_SESSION *session)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	int ret = 0, tret;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	while ((demo_fh = TAILQ_FIRST(&demo_fs->fileq)) != NULL)
		if ((tret =
		    demo_handle_remove(session, demo_fh)) != 0 && ret == 0)
			ret = tret;

	printf("Custom file system\n");
	printf("\t%d unique file opens\n", demo_fs->opened_unique_file_count);
	printf("\t%d files opened\n", demo_fs->opened_file_count);
	printf("\t%d files closed\n", demo_fs->closed_file_count);
	printf("\t%d reads, %d writes\n",
	    demo_fs->read_ops, demo_fs->write_ops);

	DESTROY_FILE_SYSTEM_LOCK(session, demo_fs);
	free(demo_fs);

	return (ret);
}

/*
 * demo_file_close --
 *	ANSI C close.
 */
static int
demo_file_close(WT_FILE_HANDLE *file_handle, WT_SESSION *session)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;

	demo_fh = (DEMO_FILE_HANDLE *)file_handle;
	demo_fs = demo_fh->demo_fs;

	LOCK_FILE_SYSTEM(session, demo_fs);
	if (--demo_fh->ref == 0)
		++demo_fs->closed_file_count;
	UNLOCK_FILE_SYSTEM(session, demo_fs);

	return (0);
}

/*
 * demo_file_lock --
 *	Lock/unlock a file.
 */
static int
demo_file_lock(WT_FILE_HANDLE *file_handle, WT_SESSION *session, bool lock)
{
	/* Locks are always granted. */
	(void)file_handle;					/* Unused */
	(void)session;						/* Unused */
	(void)lock;						/* Unused */
	return (0);
}

/*
 * demo_file_read --
 *	POSIX pread.
 */
static int
demo_file_read(WT_FILE_HANDLE *file_handle,
    WT_SESSION *session, wt_off_t offset, size_t len, void *buf)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	WT_EXTENSION_API *wtext;
	size_t off;
	int ret = 0;

	demo_fh = (DEMO_FILE_HANDLE *)file_handle;
	demo_fs = demo_fh->demo_fs;
	wtext = demo_fs->wtext;
	off = (size_t)offset;

	LOCK_FILE_SYSTEM(session, demo_fs);
	++demo_fs->read_ops;
	if (off < demo_fh->size) {
		if (len > demo_fh->size - off)
			len = demo_fh->size - off;
		memcpy(buf, (uint8_t *)demo_fh->buf + off, len);
	} else
		ret = EIO;		/* EOF */
	UNLOCK_FILE_SYSTEM(session, demo_fs);
	if (ret == 0)
		return (0);

	(void)wtext->err_printf(wtext, session,
	    "%s: handle-read: failed to read %zu bytes at offset %zu: %s",
	    demo_fh->iface.name, len, off, wtext->strerror(wtext, NULL, ret));
	return (ret);
}

/*
 * demo_file_size --
 *	Get the size of a file in bytes, by file handle.
 */
static int
demo_file_size(
    WT_FILE_HANDLE *file_handle, WT_SESSION *session, wt_off_t *sizep)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;

	demo_fh = (DEMO_FILE_HANDLE *)file_handle;
	demo_fs = demo_fh->demo_fs;

	LOCK_FILE_SYSTEM(session, demo_fs);
	*sizep = (wt_off_t)demo_fh->size;
	UNLOCK_FILE_SYSTEM(session, demo_fs);
	return (0);
}

/*
 * demo_file_sync --
 *	Ensure the content of the file is stable. This is a no-op in our
 *	memory backed file system.
 */
static int
demo_file_sync(WT_FILE_HANDLE *file_handle, WT_SESSION *session)
{
	(void)file_handle;					/* Unused */
	(void)session;						/* Unused */

	return (0);
}

/*
 * demo_buffer_resize --
 *	Resize the write buffer.
 */
static int
demo_buffer_resize(
    WT_SESSION *session, DEMO_FILE_HANDLE *demo_fh, wt_off_t offset)
{
	DEMO_FILE_SYSTEM *demo_fs;
	WT_EXTENSION_API *wtext;
	size_t off;
	void *p;

	demo_fs = demo_fh->demo_fs;
	wtext = demo_fs->wtext;
	off = (size_t)offset;

	/* Grow the buffer as necessary and clear any new space in the file. */
	if (demo_fh->bufsize >= off)
		return (0);

	if ((p = realloc(demo_fh->buf, off)) == NULL) {
		(void)wtext->err_printf(wtext, session,
		    "%s: failed to resize buffer",
		    demo_fh->iface.name, wtext->strerror(wtext, NULL, ENOMEM));
		return (ENOMEM);
	}
	memset((uint8_t *)p + demo_fh->bufsize, 0, off - demo_fh->bufsize);
	demo_fh->buf = p;
	demo_fh->bufsize = off;

	return (0);
}

/*
 * demo_file_truncate --
 *	POSIX ftruncate.
 */
static int
demo_file_truncate(
    WT_FILE_HANDLE *file_handle, WT_SESSION *session, wt_off_t offset)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	int ret = 0;

	demo_fh = (DEMO_FILE_HANDLE *)file_handle;
	demo_fs = demo_fh->demo_fs;

	LOCK_FILE_SYSTEM(session, demo_fs);
	if ((ret = demo_buffer_resize(session, demo_fh, offset)) == 0)
		demo_fh->size = (size_t)offset;
	UNLOCK_FILE_SYSTEM(session, demo_fs);
	return (ret);
}

/*
 * demo_file_write --
 *	POSIX pwrite.
 */
static int
demo_file_write(WT_FILE_HANDLE *file_handle, WT_SESSION *session,
    wt_off_t offset, size_t len, const void *buf)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;
	WT_EXTENSION_API *wtext;
	size_t off;
	int ret = 0;

	demo_fh = (DEMO_FILE_HANDLE *)file_handle;
	demo_fs = demo_fh->demo_fs;
	wtext = demo_fs->wtext;
	off = (size_t)offset;

	LOCK_FILE_SYSTEM(session, demo_fs);
	++demo_fs->write_ops;
	if ((ret = demo_buffer_resize(session, demo_fh,
	    offset + (wt_off_t)(len + DEMO_FILE_SIZE_INCREMENT))) == 0) {
		memcpy((uint8_t *)demo_fh->buf + off, buf, len);
		if (off + len > demo_fh->size)
			demo_fh->size = off + len;
	}
	UNLOCK_FILE_SYSTEM(session, demo_fs);
	if (ret == 0)
		return (0);

	(void)wtext->err_printf(wtext, session,
	    "%s: handle-write: failed to write %zu bytes at offset %zu: %s",
	    demo_fh->iface.name, len, off, wtext->strerror(wtext, NULL, ret));
	return (ret);
}

/*
 * demo_handle_remove --
 *	Destroy an in-memory file handle. Should only happen on remove or
 *	shutdown.
 */
static int
demo_handle_remove(WT_SESSION *session, DEMO_FILE_HANDLE *demo_fh)
{
	DEMO_FILE_SYSTEM *demo_fs;
	WT_EXTENSION_API *wtext;

	demo_fs = demo_fh->demo_fs;
	wtext = demo_fs->wtext;

	if (demo_fh->ref != 0) {
		(void)wtext->err_printf(wtext, session,
		    "demo_handle_remove: %s: file is currently open",
		    demo_fh->iface.name, wtext->strerror(wtext, NULL, EBUSY));
		return (EBUSY);
	}

	TAILQ_REMOVE(&demo_fs->fileq, demo_fh, q);

	/* Clean up private information. */
	free(demo_fh->buf);

	/* Clean up public information. */
	free(demo_fh->iface.name);

	free(demo_fh);

	return (0);
}

/*
 * demo_handle_search --
 *	Return a matching handle, if one exists.
 */
static DEMO_FILE_HANDLE *
demo_handle_search(WT_FILE_SYSTEM *file_system, const char *name)
{
	DEMO_FILE_HANDLE *demo_fh;
	DEMO_FILE_SYSTEM *demo_fs;

	demo_fs = (DEMO_FILE_SYSTEM *)file_system;

	TAILQ_FOREACH(demo_fh, &demo_fs->fileq, q)
		if (strcmp(demo_fh->iface.name, name) == 0)
			break;
	return (demo_fh);
}

static const char *home;

int
main(void)
{
	WT_CONNECTION *conn;
	WT_CURSOR *cursor;
	WT_SESSION *session;
	const char *key, *open_config, *uri;
	int i;
	int ret = 0;
	char kbuf[64];

	/*
	 * Create a clean test directory for this run of the test program if the
	 * environment variable isn't already set (as is done by make check).
	 */
	if (getenv("WIREDTIGER_HOME") == NULL) {
		home = "WT_HOME";
		ret = system("rm -rf WT_HOME && mkdir WT_HOME");
	} else
		home = NULL;

	/*! [WT_FILE_SYSTEM register] */
	/*
	 * Setup a configuration string that will load our custom file system.
	 * Use the special local extension to indicate that the entry point is
	 * in the same executable. Also enable early load for this extension,
	 * since WiredTiger needs to be able to find it before doing any file
	 * operations. Finally, pass in two pieces of configuration information
	 * to our initialization function as the "config" value.
	 */
	open_config = "create,log=(enabled=true),extensions=(local={"
	    "entry=demo_file_system_create,early_load=true,"
	    "config={config_string=\"demo-file-system\",config_value=37}"
	    "})";
	/* Open a connection to the database, creating it if necessary. */
	if ((ret = wiredtiger_open(home, NULL, open_config, &conn)) != 0) {
		fprintf(stderr, "Error connecting to %s: %s\n",
		    home == NULL ? "." : home, wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	/*! [WT_FILE_SYSTEM register] */

	if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0) {
		fprintf(stderr, "WT_CONNECTION.open_session: %s\n",
		    wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	uri = "table:fs";
	if ((ret = session->create(
	    session, uri, "key_format=S,value_format=S")) != 0) {
		fprintf(stderr, "WT_SESSION.create: %s: %s\n",
		    uri, wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	if ((ret = session->open_cursor(
	    session, uri, NULL, NULL, &cursor)) != 0) {
		fprintf(stderr, "WT_SESSION.open_cursor: %s: %s\n",
		    uri, wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	for (i = 0; i < 1000; ++i) {
		(void)snprintf(kbuf, sizeof(kbuf), "%010d KEY -----", i);
		cursor->set_key(cursor, kbuf);
		cursor->set_value(cursor, "--- VALUE ---");
		if ((ret = cursor->insert(cursor)) != 0) {
			fprintf(stderr, "WT_CURSOR.insert: %s: %s\n",
			    kbuf, wiredtiger_strerror(ret));
			return (EXIT_FAILURE);
		}
	}
	if ((ret = cursor->close(cursor)) != 0) {
		fprintf(stderr, "WT_CURSOR.close: %s\n",
		    wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	if ((ret = session->open_cursor(
	    session, uri, NULL, NULL, &cursor)) != 0) {
		fprintf(stderr, "WT_SESSION.open_cursor: %s: %s\n",
		    uri, wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}
	for (i = 0; i < 1000; ++i) {
		if ((ret = cursor->next(cursor)) != 0) {
			fprintf(stderr, "WT_CURSOR.insert: %s: %s\n",
			    kbuf, wiredtiger_strerror(ret));
			return (EXIT_FAILURE);
		}
		(void)snprintf(kbuf, sizeof(kbuf), "%010d KEY -----", i);
		if ((ret = cursor->get_key(cursor, &key)) != 0) {
			fprintf(stderr, "WT_CURSOR.get_key: %s\n",
			    wiredtiger_strerror(ret));
			return (EXIT_FAILURE);
		}
		if (strcmp(kbuf, key) != 0) {
			fprintf(stderr, "Key mismatch: %s, %s\n", kbuf, key);
			return (EXIT_FAILURE);
		}
	}
	if ((ret = cursor->next(cursor)) != WT_NOTFOUND) {
		fprintf(stderr,
		    "WT_CURSOR.insert: expected WT_NOTFOUND, got %s\n",
		    wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}

	if ((ret = conn->close(conn, NULL)) != 0) {
		fprintf(stderr, "Error closing connection to %s: %s\n",
		    home == NULL ? "." : home, wiredtiger_strerror(ret));
		return (EXIT_FAILURE);
	}

	return (EXIT_SUCCESS);
}