cmonctl: pick new mon on timeout

mon: fix get_latest

msg: non-destructively copy data buffers in set_data()

mds: use last_sent (not last_open) to untangle cap release races

If we use last_open, the client has to be smart about ignoring
MDS revocations after it sends a release request.  (Or, the MDS has
to somehow know the ack is for an old cap.)  Instead, just
serialize release over all cap messages sent to the client.  It may
make for a slightly chattier cap release in some cases, but those
cases should be very rare, and this is simpler.

mds: be more forgiving on EPurgeFinish

Inode may not be in cache because of purge_stray() avoiding
journaling it's intent to purge.  If that changes down the line,
add the assertion back.

osd: adjust build_prior any_up logic

We mark the pg 'down' unless there is at least one osd alive specifically
from the last epoch started.

kclient: silence down some warning

mds: fix an erroneous assertion (sage)

osd todos

osd: fix deadlock on map_lock vs peer_stat_lock

osd: remember past intervals instead of recalculating each time

This _vastly_ improves the speed of build_prior (and thus activate_map).
There is no need to recalculate this information each time as it is fully
dependent on _old_ OSDMaps, not current cluster state.

msgr: adjust mark_down locking to avoid possible race

cmonctl: reprobe every second

osd: clear_map_cache at end of activate_map

after we're done with it

osd: introduce map_lock RWLock, take read lock during heartbeat

This prevents a race between handle_osd_map updating the map while
heartbeat() is using it to ping peers.

Currently we take a write ref over the entirely to handle_osd_map; we may
be able to push that down a bit.

msgr: small cleanup

lockdep: force backtraces on specific mutexes

Maintaining backtraces is expensive to do for every acquisition.  Make a
per-mutex flag so that specific deadlocks can be tracked down.

osd: maintain a cache of past osd maps during repeering

It's expensive and stupid to load and reparse them for each PG.

osd: pause/unpause recovery thread while processing map

Otherwise bad things happen (everyone assumes *osdmap is static and
readable).

mds: journal updates _after_ predirty_parents (which adds parent context)

This ensures the dirlumps occur in an order that can be replayed
to reconstruct the hierarchy (ancestors first).

mds: remove bad assertion

Inode may still be dirty.  bah.

mds: mark inode clean only when purge is complete

Otherwise we confuse CDir dirty vs commit rules.

mds: only mark clean if dirty

mds: adjust purge_stray sequence; include explicit ino destroy

First purge the inode content.  Don't bother journaling our intent,
as that's implied by the fact that it's an unused stray.

Once purged, journal an event that destroys the inode and unlinks
the dentry.  Don't remove null dentry itself, as we still need to
update the stray dir... it will get removed when that is committed.

mds: avoid unnecessary issue_caps in file_eval

mds: fix placement of eval_stray call on caps release

mds: restructure purge_stray to remove inode objects, _then_ dentry

This ensures that any inode we are purging is referenced in the
hierarchy, since we do not destroy the stray dentry until it is
completely gone.

mds: mark and pin dentries while purging, so they don't get trimmed out from under us

Aslo avoid purging more than once.

Previously it was possible to drop the dentry from the cache while
it was being purged.

mon: commit large numbers of state values quickly

Write them all, then sync once at the end.

Also include some infrastructure for using the latest stashed value
to recover.  Don't use it yet, though.  The interaction with
keeping last_committed and latest stashed values in sync wrt a
failure between the two is a bit tricky.

mon: use generic stash mechism to manage latest version of paxos-managed object

kclient: use generic timeout/retry code for various monitor request types

kclient: pick new mon if statfs is unresponsive; clean up other retry code

streamtest: fix recursive locking

journal: detect size of raw block devices properly

osd: only trim pg log if pg contains complete set of osds

Eventually we may want to also impose some maximum pg log size.  At
some point the cost of the long log will approach the cost of
building a backlog...

osdmap: fix type conversions

crush: mention license.  minor cleanup

be quiet

Merge branch 'unstable' of ssh://ceph.newdream.net/git/ceph into unstable

kclient: fix small resource leak when mds is down on mount

csyn: fix msgr startup

kclient: whitespace

mon: standardize storage of monmap revisions

mon: indicate last_consumed state after writing "latest" full maps

Until then, we may need old incremental states.  This way paxos
won't discard them.

paxos: only trim old states if they've been "consumed" by PaxosService

Higher level state may depend on these items.  Only remove them
when its clear they are unneeded.

mon: fix mon injectargs

cmonctl: seed random number generator so we pick a truly random mds

mds: treat open requests as non-idempotent

The problem is that the reply contains a capability, and as such
is statefull and can't be lost.  Forwards by the MDS on behalf of
the client, however, introduce the possibility of multiple copies
or a request in flight if one of the MDSs fails, and the client
will drop any duplicate replies it receives.

Alternatively, the client could _also_ parse duplicate responses
(i.e. call fill_trace).  I'm not sure if that's a good idea.  In
any case, MDS forwarded requests are only really important for
dealing with flash flood scenarios on extremely large clusters,
so let's just set this aside for now.

mds todo

kclient: only kick requests when they may make progress

Kick requests if the mds they are waiting on
 - failed.  it may be possible to send the request elsewhere.
 - became active.

The rest of the time we are just spinning our wheels.

kclient: only submit mds request if mds is active

Wait until we get a new map instead.

osd: always pick new mon during boot

kclient: fix connect_seq on connect-side after connect

mds: keep inode multiversion if it has snapped old_inodes

Once old_inodes gets cleaned out (snaps deleted), we can return
to normalcy.

mon: pave way for more per-client mount info in monitor

Eventually we'll need some security stuff in here

mon: client mon stat, dump commands; add to cmonctl -w

msgr: include entity type in negotiation

This allows the accepting end to determine the policy it will use
on this connection, and return the correct LOSSY flag to the peer.

Also, some kclient simplification, cleanup.

And a connection ref count fix in process_accept().

msgr: lotsa cleanup, protocol change, fixes, etc.

msgr: various locking fixes

Fixes some deadlock problems.

We also avoid the use of newsd, and do a sync join() on the reader
thread when killing a pipe, to avoid leaking sockets.

Also fix a 'bad seq #' error due to the reader not rechecking the
pipe state after retaking the lock after reading some data.

msgr: zero msgr header

Clears up some valgrind warnings

thread: complain on bad join() calls

testmsgr: messenger tester

mds: multiversion inodes with multiple links, too

We may have remote links that get snapped.  They need to be able to
find the (single) anchored multiversion inode to get the correct
version.  (The anchor table isn't versioned.)

We'll need to go a step further than this and create snaprealms for
some of these too in order to handle inodes linked into multiple
realms.  But that needs backpointers first...

kclient: grab reference on inode before async operation

client: use separate locks for SafeCond completions

We can't reuse client_lock because it is already held when the completion
Context is called.

Revert "client: adjust objecter locking"

This reverts commit 1c70b1d8f62ad8d9eeef3a86ef36d8e6933c5702.

Actually, we need client_lock to protect access ot the objecter
and cache structures, as they have no internal locking.

Fix the safecond separately...

mds: cap may already be released in file_update_finish

There may be multiple release requests in the pipeline.  Not ideal,
but whatever.

Also, drop locks later.

mds: remove cap _after_ journaling update, at the same time we send the msg

There was an ordering problem that could come up when we prepared
a release message and removed the cap, but then didn't send it to
the client until after the update was journaled.  This could cause
us to remove the _next_ instance of the capability (from a
subseqent open) in certain circumstances.

Instead, wait until after we journal the update before removing
the client cap and sending the ack.  Since time has passed,
reverify the release request seq is still >= the last_open at
that time.  Introduce a helper to avoid duplicating code for the
case where no journaling is necessary and the cap is immediately
released in _do_cap_update.

mds: use null snap context for purge if no realm

The inode may be unlinked, e.g. when we are replaying a journaled
purge_inode EUpdate.  The snapc is not really important, as the
OSD will use the newer snapc it has for the object.  And we only
really care when we're purging the HEAD anyway.

osd: keep head_exists accurate

Also, create object on setattr if it doesn't yet exist.

And don't munge ZERO -> DELETE, at least for now.  What is the use case
for that, anyway?

filestore: implement touch

ebofs: implement touch

objectstore: introduce touch operation

Create an object if it doesn't exist.

kclient: some osd endianity fixes

kclient: fix symbol overshadowing

protocol, disk format change

osdmap: move offload from crush map into osdmap as osd_weight

dstart.sh: larger cluster

mds: fix replay lookup of snapshotted null dentries

Look up replayed dentry by dnLAST, not dnfirst, as we do with
primary and remote dentries, because that is how we identify
dentry instances in the timeline.

objecter: fix read scatter/gather

osd: pass at_version by reference, so that cloning works

mds: remove spurious warning

osd: ignore logs i don't expect without freaking out

We may get a log we didn't think we requested if the prior_set gets rebuilt
or our peering is restarted for some other reason.  Just ignore it, instead
of asserting.

osd: assert length on write, zero

objecter: whoops, do DELETE, not ZERO

osd: fix typo/bug when picking osd to pull missing object from

osd: fix missing vs lost counting idiocy

filestore: cope with zero-length attribute values

ebofs: cope with zero-length attribute values

osd: use modify flag to decide whether to take read fast path

kclient: fix up writes, reads for new op structure

Make sure osdc_readpages still returns bytes read, even though the
overall message result does not (pull it from the op.length).

Set MODIFY flag.

osd: MODIFY is a flag; fix up op_read

osd: simple higher-order append mutation

kclient: fix osd reply handler sanity check

objecter: destructively take ops[], bufferlist passed to read(), modify().

Small optimization.

mds: set path attr on directory objects

osd: object attr operations

objecter: tweaking interface

objecter: simplify objecter (no scatter/gather, generic ops vector)

osdc: avoid using objecter readx/writex