Eliminate a warning about symlink serialization that was false.

Refine lock acquisition order for renames.

Add UDP transport support to the NFS server.

SpecSFS seems to require basic UDP functionality.

specSFS requires Java.

Start fetch of all blocks in a read at the start of the read operation.

Do not signal barrier until all notifiers have run.

Only treat an async storage operation as finished when notifiers finish.

There's still a bit more work to be done with barriers, but this eliminates
some race conditions in some usages.

Partial work on parallel data fetches from S3 for large reads.

Currently causes crashes, but that might be related to a race condition
that needs fixing in the async storage layer..

Explicitly mount NFS using version 3 in microbenchmarks.

We only support version 3, so ask for that when mounting.  This can prevent
problems in mounting in some cases, so we don't return the proper error
messages when a client asks for a version we don't support.

Use s3cmd for cleaning up S3 storage accounts before benchmark runs.

Implement a synthetic benchmark for bulk reads of file data.

synclient: Issue read requests for files after lookups return.

Fix a typo in SunRPC decoding.

The code accidentally used = instead of == in a conditional, leading to
decode errors in RPC packet framing.

Allow larger reads and writes.

Support reads up to 1 MB now, instead of just 32 kB.

Fix required package list (need git-core, not git).

Do not start the RPC services until the filesystem is ready.

Fix for kvstore with default settings.

Store backends now consist of a type followed by extra information.

For example: "kv:storagehost.com:9000".  The other backends don't use this
yet but should be made to do so.

Make kvstore backend in BlueSky asynchronous.

Also, add synthetic delays to the kvstore server for latency testing.

More CMake tweaking.

Build system cleanup.

Link kvstore into main build system.

Values in the kvstore are raw byte arrays, not strings.

Hook John's kvstore up to the BlueSky implementation.

.gitignore updates, and deleting old build system files.

Reorganizing kvstore sources and switching build system to CMake.

Add John MucCullough's simple key/value storage server.

Do not drop data from cache immediately after a write.

Add very rudimentary eviction data blocks from the cache.

Hook synthetic NFS client into test script.

Fix for file storage backend.

Make storage backend selectable via environment variable.

Allow NFS lookup requests to better proceed in parallel.

After doing a directory lookup, drop the directory lock before fetching the
file inode.

Update synthetic RPC client to record timing.

For now, both it and readbench and effectively testing the time to look up
an inode, which should be a single fetch from S3.

.gitignore fix.

Work on a client for generating a synthetic stream of NFS operations.

This should provide another means of testing performance in addition to the
kernel NFS client.

.gitignore updates.

Add microbenchmarks to build system.

Add scripts for automatically testing reads at different settings.

Create a runtime option for sync/async frontend request handling.

SIGUSR1 causes nfsd to dump filesystem state now for debugging.

Work on a parallel read benchmark.

Leak cleanup.

Fix a deadlock and a few memory leaks.

Add inode prefetching support in NFS readdirplus.

Finish up asynchronous inode loading.

Let storage tuning options be set via environment variables.

This should make benchmarking runs easier.

Switch to CTR instead of CBC mode for encryption.

This should handle arbitrarily messages better.  Later we ought to switch
to something like EAX, so consider this change temporary.

Support for sync operations on an inode.

Flush file blocks to storage before the inode.

Otherwise, some blocks might not have been assigned a name and so
seriaizing the inode will lose data.

Ensure a reference to an async is held while it is locked.

Fixes a crash (assertion failure) with barriers where the barrier was
deallocated while it was still locked.

Clean up logging in storage layer.

Some changes to support asynchronous fetching of inodes.

Not 100% done yet, but almost there.

Implement multi-threaded request processing and locking for NFS.

Inodes are clean immediately after being read from storage.

NFS cache writeback is now invoked periodically by a timer.

Previously we didn't have timers set up and simply called the writeback
code after each operation (which could mean writeback wasn't invoked for
long stretches of time).

Bluesky core initializes a fresh filesystem, so no need to do so in nfsd.

Properly decrement inode refcounts when finishing a request.

Track each refcount increase made, and when the request is finally replied
to, drop those references.  In a few cases we manually drop references, but
this should be less error-prone if there are multiple possible return
paths.

Add a warning to catch possible refcounting bugs.

Not actually needed (was added to track down the corruption fixed in the
last changeset, which was unrelated), but probably worth keeping around.

Fix a nasty bug in the decryption code.

This was a typo but it led to various types of memory corruption; after
decrypting the returned string was marked as being larger than it should
have been--also meaning that the last bytes in the buffer were off in
unallocated space.

Track time to process each NFS RPC received.

Add support for dumping filesystem state for debugging purposes.

Remove some debugging messages.

Eliminate last static buffer in async_rpc_send_reply.

Remove most static variables in the NFS server functions.

Continuing rework for async RPC.

Now NFS server functions are responsible for sending a reply to the client
instead of returning a result to the RPC dispatch routine.  This will
allows the server functions to handle memory cleanup (instead of requiring
static data) and allows returns to be decoupled in time from when the
request arrives.

There is still some static data to clean up, but this moves us much closer
to allowing multiple requests in progress at once.

More async RPC work.

More cleanups to move RPC layer towards being asynchronous.

Fix for a segfault when resizing files.

If we only have a reference to a file block but have not read it in, we
don't actually know the size.  We maybe ought to have a better fix for this
later.

RPC header file cleanup.

Preparation for further reworking of the RPC system.

Rewrite NFS RPC dispatching.

The rpcgen-provided dispatching is inflexible, only allowing for a single
request to be handled at a time.  Rewrite it (add our own reading of RPC
packets off a TCP socket, calls to XDR decoding/encoding, etc.) so that we
can eventually support multi-threaded and asynchronous handling of
messages.

Quick tool for benchmarking write latency.

Add a new option to make caching writethrough instead of writeback.

Implement fsstat.

We don't return values that are very useful since there is no real size of
the filesystem to report, but do implement the procedure.

Improve NFS readdirplus to estimate response sizes.

It should now give a response closer to, but not larger than, the requested
size.

Work on NFS rmdir operation.

Mostly-working NFS rename support.

Silence some compiler warnings.

Preliminary NFS readdirplus support (not yet entirely to spec).

Include post-opeation file attributes for the NFS write operation.

Calculate size of symlinks.

Fix up logic for handling short data blocks.

This fixes a crash when there are writes that are not a multiple of the
block size.

Preliminary symlink/readlink support.

Attributes on symlinks are not yet properly set.

NFS link operation.

Minor cleanups.

Re-enable file and memory storage backends.

Track when cached file data is written out.

More work on writeback caching.

Initial work on proper writeback caching.

Drop some debugging messages.

A few bugfixes to the storage barrier support.

Work on a storage barrier operation.

The barrier completes when all of a set of operations has completed.

Some initial work to support delayed flushing of data.

More work on synchronous/asynchronous operations.

Allow operations to be made synchronous for benchmarking, and add in a
storage-wide sync() call.

Minor cleanup.

Add reference counting to asynchronous storage operations.

Rework the storage interface so that operations are asynchronous.

S3Store cleanup.

Just moving code around; no functional changes.

Better checks for non-existent inodes.

Clean up code using bluesky_string_from_gstring.