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

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

notes

uclient: adjust cap release logic...

mds: only _do_cap_update if client held ANY_WR caps

mds: issue RDCACHE caps to client when possible.  add cap to do so if inode auth.

uclient: sorta working

mds: fix scatterlock print

mds: put a cap in each inode stat in trace; simplify snaprealm trace encoding

mds: cap comments

mds: rewrite CEPH_STAT_MASK_* as CEPH_STAT_CAP_* (cap masks)

mds: cap writeback authlock fields as well as filelock fields

No xattrs yet.

mds: share caps across multiple lock types.

Very rough initial first pass.

todo

mds: clean up lock print methods

Merge branch 'unstable' into asyncmds

Conflicts:

src/mon/OSDMonitor.cc

objecter: fix ack vs safe behavior

This was totally broken (ack was taken as a safe).  Doh!

journaler: add --journaler_safe hack support back

objecter: fix ack vs safe behavior

This was totally broken (ack was taken as a safe).  Doh!

kclient: setattr on inode (not path) if holding WR cap

For newly created files, this avoids contention in the MDS over the dentry
xlock (e.g., for an untar).

It is slightly risky, because we could race with a caps release and MDS
cache trim.  Pretty unlikely, however, because cap release would also
involve MDS journaling.

mds: fix xattr projection

We do not want the new xattr to appear in the inode until the journal
entry commits.

kclient: update for ceph_fsid_t

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

vstart.sh: disable lockdep in default

mds todos

mds: avoid recursion on log trim

mds: add wrlock to simplelock; wrlock authlock on chmod, chown

mds: link on commit in openc; make find_snaprealm() follow projected_parent for unlinked inode

Linking inode in early confuses CDir::_committed().

mon: make 'osd setmap' take epoch, to avoid executing multiple times

ceph: increase command timeout

mds: flush log only when we need to

In particular, don't flush immediately on cap flush unless the lock is
unstable.  If we later wait on the lock state, make sure the log flushes.

mds: add --mds_early_reply option

mds: only include trace in first reply

No need to do it twice.

mds: rewrite, clean up mds open+O_CREAT; issue dn lease to xlocker; many other server cleanups

change ceph_fsid

Make it look more like uuid_t.  Rename type, comparator.

mds: early_reply on open, mknod, symlink, mkdir when possible

Use client-provided ino, if defined.

os: start_sync osd operation

If a client has a time sensitive operation, it can include a start_sync
in the op vector to start an immediate commit to disk.  It should then
get the ONDISK ack sooner.

osd: use .version in eversion_t to determine divergence

osd: cleanup

osd: clear entire pushing map on_change()

Primary state is reset; clear pushing map entirely.  We wouldn't know how
to handle the push acks properly anyway.

osd: fix read_log version attr check

osd: only request replica backlogs one at a time when searching for lost objects

osd: cancel_generate_backlog on activate

This fixes issue where primary requests backlog, finds its missing objects,
activates (by sending a backlog), and replica generates backlog only to
find that it already has it.

mon: fix mds cluster expansion

If we can't find a suitable standby, stop looping.

mount.ceph: fix warnings, add to Makefile.am

mds: fix inotable project, sessionmap projection, ino (pre)allocation.

Table changes must be projected so that the saved table is never
newer than the end of the journal.

mds: optional ino for mknod/mkdir/open requests

Will be needed for replaying those requests if we get an early
reply, to ensure that the same ino is used.

mds: preallocate inos for each client session

Do not use preallocated inos until we have journaled the
preallocation.  If we use a newly allocated ino, do not do an
early_reply.

When the session closes, release the inos.

mds: do early replies for basic inode update operations

chmod, chown, etc.  Not for mknod/mkdir, which allocate inos.

mds: early_reply infrastructure

mds: fix null_okay traverse logic

mds: add safe flag to mds reply

mds: process caps if freezing and unstable lock

The caps message may be a revocation ack that is needed to complete
the freeze.  In general, though, we back off even if freezing,
since we want to avoid starving the freeze as much as possible.

mds: misc filelock fixes

mds: auth_pin rdlocks too

Not sure why we didn't before... :/

kclient: make mdsmap_decode print nicer info

kclient: update num_fwd in client requests

We were keeping our local copy, but not updating the message sent.

Also fix buggy maybe_dup behavior (dup, then set rhead pointer)!

kclient: allow mds to force open a client session

mds: don't bump to sync if dir and subtree root

mds: fix file_wrlock_start waiting

mds: filelock typo in can_rdlock

mds: cleanup

vstart: 1 mds

mds: check_inode_max_size only change filelock state if needed

Don't try to change lock state unless we actually have something
to update.

kclient: ICONTENT -> IFILE

vstart: start 3 mdss

mds: basic filelock fixes

mon: add multiple mds's at once

mds: kill the dirlock

mds: make filelock a scatterlock child; move wrlock into simplelock

mds: fix mixed_sync state; send replica mixed state to primary as needed

mds: message include cleanup

mds: fix up filelock states

Allow wrlocks in LOCK_MIXED (which will serve the same function as
LOCK_SCATTER).

Clean up can_wrlock()/can_rdlock().. there were lots of states in
there that shouldn't have been.

mds: new FileLock lock->sync state

Previously this was avoided, more or less by accident.  ScatterLock
has it, so we'll presumably need it in FileLock to fold them
together.

mds: rename gather lock states

Easier to read: LOCK_oldstate_newstate, "oldstate->newstate"

mds: include max mds in mdsmap summary

mds: fix standby_replay on startup

remove uninitialized warnings

osd: gracefully exit when create_object_store() returns NULL

osd: inc_lock attr is optional

osd: update pg degraded stats only when active

peer_missing needs to be defined.

osd: initialize generate_backlog_epoch

osd: clear_prior when activating

This just ensures that, once active, an osd state change affecting our
prior_set won't make us repeer.  E.g., a prior going down.

osd: clear backlog flag when done

Otherwise we won't requeue again later.

osd: only update degraded object stats after peering

This avoids incorrectly populating peer_missing[acting[i]], which
in turn screws up peering and recovery.