Some test work with using Berkeley DB for a local disk cache.

Implement this at first by simply making it a new storage backend.  Later
we will have to make it a separate layer so we can stack a Berkeley DB
cache/write log with a remote storage option.

Some new format design notes.

Add another S3 benchmark tool.

More S3 benchmark work.

Add an S3 test script for range requests.

Add results from a simple test run of the multi:s3 backend.

Testing S3 with more object sizes.

More Amazon S3 test script updates.

Fix a possibel deadlock from synchronizing the superblock.

Add a "multi" storage backend which doubles all GET requests.

This can be used to test whether the performance with S3 improves when
making parallel requests to reduce latency.

Updates to script for testing multiple parallel fetches.

Testing of multiple requests in parallel.

Add a few more test scripts.

More trace analysis scripts.

Improve analysis of S3 packet traces.

Keep IP addresses with network measurements.

More S3 performance evaluation scripts.

Compile fix for directory renaming; use virtual host access method for S3.

More cloud storage performance-measurement scripts.

Directory reorganization.

Work on more tools for automating cloud storage performance measurement.

A few more Azure/analysis updates.

Another update to the Azure test code.

Start work on a test program to communicate with Windows Azure.

This could provide another backend for BlueSky, and it might be nice to at
least make a few benchmark measurements of Azure to complement the S3 ones.

Simple tool for analyzing a dump of a single S3 connection.

Will try to extract information about any delays in the transfers.

More playing with parsing of packet traces.

Extract window size values (and handle TCP window scaling).

More updates to S3 pipelining test.

It seems there is a bug in S3 with many pipelined requests that we are
triggering in testing:
http://developer.amazonwebservices.com/connect/thread.jspa?messageID=39907

Create a simple Python script for sending pipelined GET requests to S3.

S3 doesn't seem to respond properly to these yet.

Print flow identification in TCP parsing output.

Also fix a division-by-zero bug in computing bandwidth if no data is
transferred.

Some initial results of running the NFS replay code.

Fix a memory leak in the NFS-over-UDP code.

The TCP code still has a per-connection leak, but at least this should help
with the UDP per-request leak.

Enable real-time trace replay instead of maximum-speed replay mode.

Allow longer server names; fixes (temporarily) a buffer overflow.

Code fixes for TBBT.

Add two missing files from the TBBT import.

Import TBBT (NFS trace replay).

Code downloaded from http://www.ecsl.cs.sunysb.edu/TBBT/.

Merge git+ssh://root@c09-44.sysnet.ucsd.edu/scratch/bluesky

Add pcap dump parser for extracting S3 performance measurements.

More measurement results of S3 latency.

Add new results.

Commit some benchmark results of standard Samba.

Update needed dependencies for building Samba.

Cleanups while workign on Samba code.

Add some measurements of speed reading data from S3.

Initial work to use Berkeley DB for locally logging FS changes.

Not yet hooked up to anything else, but commit this now so the file doesn't
get lost.

Pull in updated tool for measuring S3 read performance.

Improve statistics gathered.

Add general statistics-gathering infrastructure.

Benchmark results to S3.

Add some more results.

Fix filesystem locking when creating a new inode.

Add warnings for failed storage operations.

Disable most debugging print messages; should help with performance.

Try to clean up the locking for LRU lists.

A few minor fixes.

Copy in a few more benchmark results.

Store benchmark results for native Linux NFS server.

Track number of unanswered RPC requests, for debugging.

Do not fill in a non-zero inode change_count until the inode is loaded.

Possible null pointer dereference fix.

Rework cache flushing logic--this version should work much better.

In-progress work on better cache flushing.

Add LRU lists for tracking inodes that are dirty/accessed.

Minor bugfix to pending store operation counts.

Fix a bug in committing of dirty inodes to stable storage.

Previously, if an inode changed while it was being committed, we would
stall all future commits.  Now allow those commits to proceed once the
first commit is done.

Better track latency of operations issued to S3.

Track the time from when the operation is sent to S3 as well, not just from
when it was submitted locally, as there may be some local queueing
happening.

Add very simple write throttling when caches fill up.

We ought to actively flush data when needed, but this is enough for some
basic testing.

Make dropping of inodes from cache more resistant to races.

Quick note on memory leak debugging under valgrind.

Inodes can now be dropped from the cache too, not just file blocks.

Track memory usage statistics for cached data.

Provide a simple configurable limit on the number of threads.

Primarily this is meant to make running under valgrind easier, since
valgrind can only handle so many threads.  By default leave the limit
unbounded (the old behavior).

Fix memory leak in bluesky_block_fetch.

Return success code from NFSv3 commit operations.

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.