kclient: fix blob size initalization

mds: add/remove inodes to/from open file list based on wanted caps changes

We only want to track "open" files for things the client will have open
file handles for.  The rest we will recover opportunistically...

mds: fix file_excl() call preconditions

We could have filelock in LOCK_EXCL but no loner.. maybe..

mds: avoid dup locallock wrlocks

kclient: reorder setxattr to avoid race

kclient: removexattr marks inode dirty when required

kclient: break I_NODELAY into NODELAY and FLUSH

FLUSH indicates the inode should be flushed asap.  That is, we
should send a cap message with the dirty metadata.  It's set
by write_inode.

NODELAY means we shouldn't delay our cap/wanted release when we
do send a message.  It's set for unlinked files.

mds: rewrite scatter_tempsync

Recall caps, among other things.

vstart: selectively run mds through valgrind

mds: drop unused mdr->cap

mds: remove debug msg

kclient: helpers for mount options

kclient: fix dcache readdir bug; add mount option to turn it off

mds: init var

kclient: setxattr cleanups

Do dirty stuff inside i_lock.
Reuse retry label after successful allocation.

mds: issue all caps we can (except RD|WR on dirs)

Might as well.

Most importantly, it means we issue EXCL caps on directories that
clients are using.

mds: fix snap.c debug prefix

kclient: drop RD, WR caps on file lock setattr

The mds will move to LOCK state, which will revoke them anyway.

mds: use actual cap wanted, not requested

(The wanted update doesn't always succeed.)

mds: allow request_release to update wanted; do so if I_NODELAY

kclient: fix up cap timeouts

mds, kclient: fix issue_seq vs seq, limit dup cap messages

mds: consolidate calls to issue_caps

kclient: silence down log messages

kclient: add missing initialization

kclient: fix xattrs cap message

kclient: merge asyncxattr

kclient: refactor setxattr, listxattr

kclient: fix removexattr

kclient: fix some leaks

kclient: xattrs, selective rb erasing, fix tree tear down

kclient: make listxattr actually work

kclient: xattr name length fixes

kclient: initialize xattrs version

kclient: send xattr name on setxattr

kclient: verbose xattrs

kclient: list, get cached xattrs

kclient: don't copy null xattrs blob

kclient: send xattrs blob when dropping xattr rdcache

kclient: preallocated buffer for the xattr blob

kclient: xattrs cleanup, preallocate xattr structure

kclient: don't rebuild xattr rbtree if exists

kclient: fix some more xattr stuff, basic stuff works

kclient: some more xattr fixes

kclient: xattr initalization and bug fixes

kclient: xattr uses rbtree for indexing

mds: fix CInode::get_caps_wanted to do the shift on returned mask

mds: move simplelocks (auth, xattr) to EXCL in simple_eval

Also move xattr lock to EXCL state on mkdir, create.

kclient: assign meaningful readdir offset to client-created dentry

Set i_max_offset when I_COMPLETE flag is set.  Thereafter, and local
negative lookups will get the next unused offset.

Not coherent if we fall back to talking to the MDS.

mds: add mds_max_mem conf item, hook to check memory utilization

mds: trim cache during tick, not every request

More efficient

mds: put mds format magic in root inode, journal; check on start, replay

context: return error from C_Gather

mds: kill rdcaps code

Since caps no longer time out, we no longer need to maintain an rdcaps
lru.  Good riddance.

mds: count caps, inodes with caps

todo

kclient: fix up dcache readdir

Code should behave with frags and seeks, though both are untested :).

kclient: initialize xattrs version

kclient: send xattr name in setxattr

uclient: make O_CREAT work

kclient: do readdir from dcache when possible

If we have I_COMPLETE, do a readdir straight from the dcache.  When
we do a readdir prepopulate, reorder parent->d_subdirs to match the
mds order, so that the dcache readdir order matches.

Some wonkiness here to detect the end of directory.  There is also
some inconsistency if the directory changes mid-readdir and we
have to switch back to talking to the mds.

filestore: clean up attr name, path buffer lengths

filestore: make path buffers longer

scripts: fix mds and osd request latency checkers

mds: flush log in do_cap_update if there are unissued but wanted caps

mds: issue caps as needed in xlock_finish

We don't leave xlockdone via eval_gather, so we need a special call
to issue_caps.

debug: make log symlinks relative if dirs match

mds: eval_gather on cap removal

This fixes a purge_stray problem with a lingering auth_pin (due
to an unstable lock).

mds: never issue caps in file_eval

We should do it explicitly when it is appropriate.  Normally, that's
in eval_gather(), or when caps wanted changes, or something
similar.

When we explicitly issue caps, avoid scanning the whole list when
possible.

mds: hide stray dentries and inodes that are purging

Otherwise we get unwanted references when the inode is supposed to
die.

mds: reorder some code

mds: use rdlock_path_* for rename; fix helper paths

mds: make dn vec accurate after rdlock_path_xlock_dentry

mds: store up to two paths in MDRequest; generalize rdlock_path_*

Eventually we want to use those helpers for _both_ arguments of rename,
link.

mds: kill mdr->ref_snapdiri

The client handles the nosnap->snap namespace transition.

mds: move done_locking into acquire_locks

Be consistent.

mds: acquire_locks in callers, not rdlock_path_* helpers

This way we only call acquire_locks from one place, and avoid weird lock
reordering issues.

mds: refactor path_traverse, callers

Mainly, we want path_traverse to do the work of giving us back the inode
the final dentry links to.  Simplify callers to use it.

todo

vstart: behave a bit better when sudoing

kclient: allocate cap releases outside of spinlock

kclient: use FLUSH cap op on cap writeback

This is just to make the message logs easier to read.  The only
real distinction is that a FLUSH won't release caps, only write
dirty ones back.

kclient: only check auth cap for WRBUFFER, max_size checks

kclient: switch check_caps interface to use flags field

kclient: fix setxattr

This was broken ages ago with the mds client interface was switched
up a bit.

kclient: kill ceph_release_caps and check_caps drop arg

kclient: fix up cap/wanted delayed release logic

mds: don't reissue caps on embedded request releases

mds: default to issue_caps in file_eval, _unless_ we are dropping caps

mon: make log messages a bit nicer

mds: journal max_size update as loner, if any

This avoids calling file_excl if the lock is already LOCK_EXCL.

kclient: less chatty

mds: include cap, dentry lease release in request messages

Embed dentry and cap releases inside mds request messages.  This
avoids the overhead of sending additional messages, although it
does limit the release to the mds the request is going to.  That
is normally fine, since updates go to the auth MDS, and that is
usually who we're dealing with.

mds: avoid dup change_max in _do_cap_update

Set a flag to prevent issue_caps from checking the max_size (since
we're about to journal that update anyway).  This avoids some dup
cap messages.

kclient: dequeue cap on non-drop send caps

If we are doing a full update (i.e., not a drop, where wanted is
censored), remove ourselves from the delay queue.

mds: drop 'careful' caps concept

This was originally needed before we were smart about projected
vs non-projected values, and making them visible to only the
xlocking or excl client.  No more.

mds: choose reasonable state after xlock finishes

mds: better max_size lock checks when EXCL

Choose an appropriate lock state to change to when we need to
journal a max_size update (-> 0, usually).

mds: stay in EXCL and keep loner until wrlocks drain

Otherwise we go to MIX and revoke caps from the loner, which is
lame.

mds: clean up can_wrlock() so that it checks of loner

Previously the EXCL state/cap check was outside of can_wrlock,
which is yucky.