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.

mds: replace WANT cap op with DROP

While it's not always clear when we are expanding wanted (bc the
client may have skewed perception of mds_wanted), it IS always
clear when we are explicitly _dropping_ caps and don't want them
reissued to us.  And that's the behavior we're trying to avoid
anyway.

mds: use EXCL instead of LOCK to adjust max_size if loner

mds: don't rdlock_try authlock for path_traverse permission check

We don't actually check anything anyway, just ping the lock.

If the client is trusted with AUTH_EXCL, this is pointless anyway.
It is only really useful with untrusted (e.g., fuse) clients, but
they'll need some sort of special support for that later.

mds: issue caps in file_eval only if needed, indicated by WANTED cap op

We can't always issue_caps in file_eval or cap releases won't work.

Sometimes the client wanted shrink is missed, though, and a wanted
expansion is sent that doesn't actually change wanted.  In those
cases, we DO need to issue caps.  Use a separate cap op WANTED so
the mds knows when the client is asking for caps.

mds: fix file_eval to issue caps from EXCL state

Before it wasn't getting called in some cases.

todo

kclient: only flush caps in write_inode if wait=1

The problem is that on delayed writeback, vm calls write_inode and
THEN writepages.  Which means we still have WRBUFFER caps used,
so sending a cap release then is somewhat counter productive.  If
we don't release wanted, we'll have to again later.  And if we do,
the mds will explicitly revoke our WRBUFFER caps so that it can
journal the max_size to 0.  Yuck.

So.  If wait, then do the cap flush immediately, as before.  If
!wait, queue up the caps at the front of the delay queue so that
it goes the next time we check_delayed_caps.  This catches the
sync() and umount cases (basically the same, really).

On fsync, queue the caps for write, but don't wait, since the mds
can recover the size/mtime anyway.

kclient: maintain min and max cap hold delays

Set a minimum amount of time we keep caps wanted bits even after
the file is closed.  Before that time, even if we are sending a
cap message, we tell the mds we still want the caps.  After the min
but before the max, we will tell the mds we no longer need them
IF we are sending a cap message for some other reason.

The caps_delay queue works as before based on the max timeout. When
that timer goes off, send a new message to release the wanted bits.

In most cases, this now releases wanted bits when we write back the
file size to the mds after writepages, which means only a single
message after we write and close a file.  Yay!

kclient: drop FILE_RD if !wanted and max_size non-zero

If we are dropping wanted and max_size is non-zero, the mds will
want to journal the update, which will mean syncing the lock and
recalling FILE_RD anyway.

mds: adjust mds client request format to include optional releases

The goal is to release caps and/or dentry leases in the same
message as the request we are dropping them for.  We will already
get caps/leases reissued with the response, in most cases.

Kill the mds replication hack while we're at it.  That should be
cleaned up if/when it is reincarnated.

mds: separate CREATE vs OPEN handling

These are now distinct ops.

mds: allow full dir lease (FILE_RDCACHE) on root ino

Now that root changes are persistent, and client looks at
rdcache_gen and not i_version anyway, this will work.

kclient: drop root ino special cases

Now that root ino changes are persistent on the mds, we can remove
various special cases that disallow I_CONTENT checks.

kclient: mark dentries with dir rdcache_gen, not i_version

The i_version may change if we are doing dir updates with an excl
lock on the dir, but our dcache should remain consistent over those
operations (unless we lack a trace, and fill_trace clears
I_COMPLETE in that case).  Instead, we want to effectively
invalidate prior dentries when we are _newly_ issued RDCACHE and
don't know what has changed... which is exactly what rdcache_gen is
for.

kclient: don't clear I_COMPLETE on dentry revalidate failure

I_COMPLETE + FILE_RDCACHE means we have the full set of dentries.
If a revalidating dentry is part of the current set, then it will
successfully revalidate.  The only reason revalidate would fail is
if the dentry is not part of the current set, or we don't hold
FILE_RDCACHE.. and in those cases clearing I_COMPLETE is either
wrong or unnecessary.  Revalidate will already fail when we lose
FILE_RDCACHE, or when a dentry is released, or when a new RDCACHE
is issued and our rdcache_gen changes.

kclient: reverse logic of O_CREAT create vs open check

todo

config: remove INSTALL_PREFIX

On a 'norma' install, it's /usr, which isn't helpful.  If anything, we
need sysconfdir, etc. individually.  Blech.

uclient: fix up caps some.  make dentry leases work

uclient: set fsid in statfs request

kclient: fix ino returned in fstat for 32 bit arch

kclient: don't alter mds_wanted caps if dropping caps

vstart: kill bashisms

kclient: remove alignment restrictions on O_DIRECT reads and writes

These aren't needed, since we aren't restricted by DMA to a hardware disk
device or any such thing.  (And even if they were, it'd probably be
sector alignment, not page alignment.)

mds: fix compilation error

mds: bump mds protocol

mds: add CEPH_CAP_OP_REVOKE

kclient: clear di->lease_session when dropping session

mds: flush log when expanding caps and filelock is unstable

mds, kclient: add CEPH_MDS_OP_CREATE operation