mds: carry RDCACHE|WRBUFFER through xlock.

kclient: fix fill_file_bits logic

ctime should be the max if we hold any wr caps, otherwise it's
the mds value, regardless of time_warp_seq (which does not modify
ctime).

mds: include projected ctime if _any_ other fields are projected

...or if client holds FILE_EXCL.

kclient: fix snap_rwsem link on non-existent cap release

kclient: some cleanup

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

kclient: fix gid setattr

mds: also verify in rename() that mds reintegrate/merge is valid

mds: do not reintegrate stray if target dentry is projected

Otherwise we break user semantics.  Remote parent might be
unlinking!  Then we move the file back into the position that
was just unlinked...

mds: look at issued(), not pending(), when putting cap on the rdcaps list

We want to be conservative in the MDS about dropping caps!  If the
client hasn't released a non-trimmable cap, we shouldn't expire
it.

mds: eval_cap_gather when trimming rdcaps

mds: look at inode locks to determine whether to expose stable or projected inode fields

And clean up the set_trace_dist() hacks.

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

kclient: some more sparse fixes

mds: fix uninitialized value in ceph_inode_holds_cap()

mds: fix inode version projected on open O_CREAT, too

See 461cb1a6438d5f474d2958019fa5d42628d3a490

mds: set .inode in projected linkages; add dentry to remote_parents only when active

This let's us do dnl->get_inode() on projected linkages for
remote links.

mds: fix link() dn linkage projection

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

kclient: some sparse cleanups

mds: only set max_size on open+O_CREAT if file opened for writing

mds: optionally pass a specific linkage for journal_cow_dentry to use

This is needed just for rename(), which up pushes projected linkages
before calling journal_cow_dentry and friend.  Consequently, they
can't just use dn->get_projected_linkage() like they usually do.

mds: fix fast create + rm failure

The inode projected_version() needs to be accurate or we run into
problems later.  So, change the way the inode creation version is
initialized by moving the hack to right before mark_dirty() is
called (to keep the v < pv assertion in place).

mds: make xlock stable

kclient: set dentry d_time when doing local ENOENT

This allows a subsequent d_revalidate to succeed.

mds: get_linkage() should return projected if xlocked by self

Also, move set_xlocks_done() to _below_ set_trace_dist, in case some
other request comes in and xlocks the dentry.

Allow read_projected in XLOCK state too.  Note that other requests
_still_ won't be able to re-xlock or rdlock until the prior request
set xlock done.

mds: touch using projected parents too

mds: journal using projected parent

kclient: one more update_parent fix

kclient: don't mark root complete (empty); debug complete flag

uclient: small bug fix

journaler: don't request ACKs if in safe mode; do safe mode by default (since mds does too)

This avoids ACK replies from the OSDs, which the MDS ignores
anyway.

kclient: refine dir complete/readdir handling

mds: kill FileLock

Keep ScatterLock.. it has the xlist nodes for tracking dirty scattered
metadata (used by sm_filelock and sm_scatterlock).

mds: redo choose_loner/drop_loner

Still need a simple_excl() with a try_choose_loner() check, and something
in simple_eval.

mds: merge *_sync() methods

mds: more lock refactoring.  merge *_lock() methods.

mds: ENOENT on null dentry in unlink()

mds: add lock->xlock state

mds: simplify loner_cap update

This may still not be right...

mds: generic locking helpers, step 1

Still need to refactor :*_sync(), *_lock(), etc... and test.

mds: rewrite SimpleLock using generic state specifications; new xlock semantics

Same client can re-xlock an item (or read_projected) if the prior
locker set_xlock_done().  Move from XLOCKDONE to either SYNC or
LOCK, depending on whether read leases/locks have been issued.

Still need to convert FileLock and ScatterLock to use the new
state machine specification.  (This will probably make those lock
types mostly go away.)

lease: difrentiate lease release cases (revoke, preemptive)

kclient: clear dir complete/readdir bits when appropriate

mds: remove some uninitialized cases

mds: disable empty directory fastpath check

We need to look at the _projected_ directory size for this to work.
Until then, disable the fastpath check.

mds: fix unlink

Need to project linkage.

mds: path_traverse cleanup

mds: always traverse projected hierarchy; xlocks will handle client views

If another client starts to follow a projected dentry, it will stop
on the xlock.  Unless it's a rename, in which case we do want the
projected value.

mds: force explicit current vs projected dentry linkage in API

CDentry users must use get_linkage() or get_projected_linkage()
(or get_linkage(int client) to autochoose) to explicitly specify
whether they want the current or projected dentry linkage.

mds: use projected dentry linkages in rename

Passes basic test, rest of the code still needs an audit.

mds: fix simplelock cap check

Only check caps if there is a cap_shift.. this replaces the
type != CEPH_LOCK_DN special case (no cap shift will be
defined if it's not on an inode).

mds: a few comments

mds: fix up EXCL state some.  fix set_trace_dist use of projected parent

mds: some cleanup

mds: project dentry linkage

kclient: fix lock leak in mdsc_handle_map

mds: verify is_stable() before calling simple_eval()

The finish_waiters may change the state again.

mds: end of traverse may be indoe or projected_inode

This may need a more general solution...

kclient: use CEPH_INO_ROOT constant

mds: include projected dn+inode to client if xlock_done

We should see the result in a readdir after a mkdir etc, even if it
hasn't journaled yet.  E.g., we should be able to killall -STOP cosd,
then

$ mkdir foo ; ls
foo

mds: fix LOCK_LOCK -> LOCK_LOCK_SYNC issue_lease transition logic

Bump the lock state even if we don't issue a lease now.

mds: allow FileLock wrlock when client holding FILE_EXCL

mds: issue cap on mkdir; set authlock to EXCL on open O_CREAT.

mds: fix encode_inode caps issue logic

We must mask _likes_ against _allowed_.  Bump filelock if we're a directory
and we're a loner.

mds: loner if only client with cap on a dir

kclient: only release dir RDCACHE if we're not holding EXCL

MDS will (soon) let us carry a wrlock if we have the EXCL lock.

kclient: hold onto dir EXCL cap

kclient: track COMPLETE flag on directories with RDCACHE; lookup ENOENT locally when possible

Maintain COMPLETE flag that indicates the client has all dentries for the
directory cached.  Only defined when holding FILE_RDCACHE cap.

mds: make Server use CDentry accessors

kclient: handle case in which splice_dentry fails in fill_trace

kclient: avoid starvation when fsync on dir

mds: increase preallocated ino

Although we still seem to manage to use them all up...

mds: allow clients to traverse dentries they xlock.

This could be cleaner.. maybe CDentry::get_inode() should take
a client argument?  Would need to fix up direct access to
dn->inode...

mds: fix CInode::adjust_nested_auth_pin()

Adjust nested_auth_pins even if no parent.  There will be eventually.

kclient: add missing parens in kick_requests

uclient: lease seq #'s; clean out inode leases

kclient: use lease seq #

mds: introduce lease seq #

Only recognize a release message if the seq # matches.  This prevents
races between mds requested revocations and volunatry client releases.

osd: fix ager missing open() arg

osdmaptool: fix --test-map-pg

todo

mds: do rename, unlink early replies; set_xlock_done as appropriate

mds: early_reply for link, unlink, rename.

mds: by default, always wait for journal safe

Waiting for just sync can make clients lose requests when mds and osds die
simultaneously.  Now that we have an early_reply, the performance impact
from always waiting for safe is mostly gone.

mds: wait for journal safe when doing ino allocations

Stop-gap, I suppose.. we really want to wait for things to fully journal,
period.  Hmm.

kclient: resend unsafe requests just before to MClientReconnect

This makes it clear ot the MDS which requests are being replayed (not that
it makes a difference at the moment).

kclient: list unsafe requests in the MDS session

This easily defines the requests needed during reconnect without having
to consult the larger request table.

kclient: break out __prepare_send_request helper

This will be used for preparing the request when sent during reconnect
(instead of do_request, which exited after the first unsafe reply).

kclient: separate flag for got_safe and got_unsafe

Slightly more informative debugging messages.  Avoid doing the safe cleanup
twice.

And the distinction will be important when replaying unsafe requests to
the mds during reconnect.  I think.

kclient: set ino in request if we got an early reply

Make 'ino' a generic field so we don't have to look at the request type
when sending the message.  It'll be ignored by the MDS when it's not
relevant anyway.

kclient: missing spin_unlock

kclient: replace radix tree with list for req dir listener

kclient: listener tree should use GFP_ATOMIC

kclient: remove extra mutex_unlock

start.sh: add $CEPH_BIN

kclient: fix fsync for directories

kclient: handle safe reply, sync dir waits for safe reply

mds: can_xlock_soon() should include LOCK_LOCK

i.e., if we are already xlocked.  This avoids calling {file,scatter}_lock
on an already LOCK_LOCK lock.

mds: for wrlock when updating max_size in issue_caps()

If check_inode_max_size() changes the lock state, teh issue_caps local
values for *_allowed etc. are out of date, and we do the wrong thing.

And in any case, we can safely update max_size even when a wrlock isn't
normally allowed, e.g. when in LONER state.