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.

Fix the S3Store get operation to handle arbitrarily-sized objects.

Allow storse to S3 to execute in the background, in parallel.

New BlueSky interface for implementing readdir.

Extra logging, begin defining BlueSky-specific error codes.

Do not pad the final block of a file with zeroes.

To accomplish this, a resize operation was added for reference-counted
strings.

Move encryption into S3 backend.

Include file reorganization.

Split BlueSky include files into public and private parts.

Actually sorting out what goes where still needs to be done.

Start work on a rename operation.  Not yet complete.

Remove some debugging log messages.

Add filesystem superblock serialization.

Also fix deserialization of case-folded directory entries.  Together, these
chagnes should allow a filesystem state to be reloaded properly.

Add high-resolution timekeeping functions (primarily for benchmarking).

Add case-insensitive lookup support to BlueSky core.

Make printf format specifiers 32/64-bit clean.

Cache coherence thoughts.

Miscellaneous fixes.

Minor CMake fix (delete redundant line).

Use and link to included libs3.

Include libs3 sources in the BlueSky tree.

This way we won't need to install it separately.  Not yet hooked into the
build system.

Add a little support for data writeback (not yet hooked up).

Commit unlinks to stable storage.

NFS file unlink operation.

Update filesystem locking rules (in progress).

NFSv3 mkdir.

Ensure file size is properly serialized/deserialized.

Directory deserialization and loading of inodes from stable store.

Proof-of-concept flushing of inodes to disk.

Allow crypto to be disabled (for local testing).

Drop unneeded HMAC implementation.

Add pluggable support for multiple storage backends.

Split handling of file data out of inode.c.

Directory serialization (but not deserialization).

Work to add inode serialization/deserialization routines.

Use GPLv3 license.

libs3 is GPLv3 licensed, as is Samba (if we use it for CIFS support).  For
compatibility, apply GPLv3 to our code as well.

Implement data decryption as well.

Encrypt data blocks being stored to S3.

NFSv3 SETATTR operation.

CMake build tweaks.

.gitignore updates for CMake.

Add missing file?

CMake reorganization.

Attempt at building with CMake.

.gitignore update: ignore binaries

Switch to refcounted strings for storing cached file blocks.

Add fetching of blocks from S3.

Implement flushing of file blocks to Amazon S3.

Right now many details are hardcoded.  Data can't be read back yet.  But it
implements some of the needed functionality.

Include libs3.h header file in our source.

Later, we'll want to properly find it in an installed location.

Link against libs3 for access to Amazon S3.

libs3 is licensed as GPLv3.

Start on a basic in-memory key/value store.

File read and write operations.

Update ctime/mtime on write.

Switch to 31-bit directory cookies and a separate hashtable for lookups.

Begin adding write support.

Right now we only change the file size, but don't actually store the data.

Fix up current time computation (ensure 64-bit math is used).

Properly fill in result code for lookups.

Remove debug message.

CREATE working (sort of).

Basic READDIR; not much tested.

LOOKUP operation.

Hook NFS proxy together with BlueSky core.