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.

mds: drop dup code

kclient: fix add_cap cap update

We want to _set_ cap->issued, and add bits to cap->implemented.  This
mirrors what we see in handle_cap_grant.  Note that this is dependent
on that fact that (currently, at least!) we should never see
a revocation here.

uclient: handle xattr updates

kclient: only update xattr blob when defined and newer (caps|reply)

mds: send xattrs down to client efficiently

Track what xattr_version the client (should) have in the capability
so we can be smart about including the xattr blob in the inodestat
and in caps messages.

move to generic ceph_seq_t 32-bit sequence number and comparator

We want to behave when the seq # rolls over.  We'll be fine as long
as we don't differ by more than 1<<31.

kclient: make fill_trace look for RDCACHE cap on directory

The dcache update logic depends on whether EITHER a dentry lease
or an RDCACHE cap on the whole directory is provided.  This detail
got lost in the lease->cap transition.

stop.sh: stop valgrind procs too

mds: fix capability off-by-one bug

mds: safely allow client to rdlock|lease dentries it xlocked

If the locked item is in it's final state, we can call
set_xlock_done().  Thereafter, we allow new rdlocks or leases
to be issued if the client matches the xlocker.  Move the lock
state to LOCK_LOCK_SYNC to ensure it is not relocked.

mds: fix SimpleLock release evals

todos

mds: use projected parent when updating max_size

May be new file, or renaming.

mds: only check max_size if inode is a file

mon: fix uninitialized variable

Merge branch 'unstable' into caps

vstart: run cmon through crun, valgrind

mds: set issue_stamp on cap reconnect

kclient: exclude expireable caps from reconnect

No need to remove them; they are already invalid as the gen is out
of date.

mds: fix sessionmap->version value during EMetaBlob replay

++v, not v++.

mds: fix EMetaBlob initialization

Use a single constructor.

mds: only file_eval on xlock_finish if stable

mds: only file_eval on xlock_finish if stable

todos

kclient: don't pin dentry with lease

Discard when we notice it is invalid, or when we release the
dentry.

kclient: separate mds session lookup from ref get

Merge branch 'unstable' into caps

vstart: fix ip determination

mds: disable inode leases

mds: no inode lease in lssnap

kclient: fix cap release logic a bit

Keep an EXCL bits we have, as long as we have something wanted or
used.

Fix wanted update vs delayed cap release behavior.

kclient: fix request ref count leak from duplicate replies

mds: expire rdcaps

Make sure mds and client agree on the wanted value.

kclient: trim expired rdcaps; ignored issued but timed out caps

Introduce new CEPH_CAP_EXPIREABLE mask to control which caps (if
alone) time out.

kclient: fix buffer overrun in parse_reply_info_trace()

Bug introduced by fb882d34c1be8fc7058f0f636bb68b134d638743.

mds: issue AUTH_EXCL if also issuing FILE_EXCL

This will let e.g. untar chmod/chown without talking to the mds.

mds: update cap notes

kclient: implement ceph_release_caps

Just pass a 'drop' mask to check_caps, and tell it not to
delay.

mds: set ttl_ms in cap IMPORT message

kclient: keep readonly caps on per-session lru

mds: keep caps in lru; put ttl in cap issue to clients

kclient: local chmod/chown if holding CEPH_CAP_AUTH_EXCL

client: send release anytime we get a caps message and have no inode or cap

The exceptions are IMPORT, EXPORT, and FLUSHSNAP_ACK.

mds: always issue cap in inodestat

The previous (wrong) optimization was trying to avoid the old
pending_caps list in Capability.

mds: don't let release race with any caps

mds: simplify capability issued tracking

The original was really stupid.. keeping track of every issued
value in a list and traversing it to calculate the effective
issued mask.

New version has a small, fixed array that is used only when bits
are revoked.

uclient: fix likes bits

kclient: use new caps protocol

Also,
- Stat root inode instead of opening it.  We will keep the PIN cap
  and be happy.
- add ceph_cap_string helper to make cap values readable

mds: fix stat mask

mds: only send clientcaps if we need to revoke, or we can issue explicitly wanted caps

mds: fix cap release seq check

uclient: set dirty bits in cap_snap

mds: bunch of cap protocol changes, and user client adjustments.

See capability protocol notes in mds/Capability.h

kclient: fix snap realm update on reply

Take snap_rwsem always, since we usually get caps.  Drop trailing
snaprealm ref after trace is fully processed.

mds: fix set_trace_dist snaprealm problem on unlink

Set snaprealm trace based on the first inode we see.

kclient: ref count cap_snap to avoid unnecessarily copying into temp variables

kclient: take fmode ref atomically while adding cap

client: do not update when already holding EXCL cap

kclient: caps basically working

handle caps on any inode in reply.  no more inode leases.

kclient: use ceph_caps_release instead of dropping inode lease

kclient: switch from inode leases to new caps

----------------------------