confutils: cleanup, bug fixes

confutils: can flush config, preliminary config.cc integration

confutils: some cleanup

confutils: encoding/decoding using templates

confutils: going forward

confutils: adding missing file

confutils: some more

Signed-off-by: Yehuda Sadeh <yehuda@hq.newdream.net>

confutils: some more changes

Signed-off-by: Yehuda Sadeh <yehuda@hq.newdream.net>

config: some more changes

Signed-off-by: Yehuda Sadeh <yehuda@hq.newdream.net>

confutils: still not usable

config: remove some old cruft

osd: reset peering, in-flight repops on every pg change

Instead of complicated (and flawed) logic for letting in-progress rep ops
complete while the PG changes (but primary remains the same), reset the
pg state entirely.  Apply any ops we have in hand, but drop everything
else, including PUSH/PULL ops.

This vastly simplifies the logic in the OSD and makes it easy to reason
about things.

Fix clients (Objecter, osd_client) to resubmit ops when PG membership
changes (not just on primary change).

mds: eval_cap_gather in handle_client_caps even if no update

We may have recalled caps and journaled an update for some but
not all locks.  We should check for cap gathers even if something
(else) is journaled.

script: find high latency requests in mds log

mds: fix xattr projection

mds: drop rdlocks _after_ journaling; use new journal_and_reply helper

If we drop locks earlier we may run contexts that journal _other_
items out of order.  Badness.

mds: make cdentry debug print nicer

mds: unique (per mds) cap_id

A new cap_id is issued each time an MDS creates a new capability,
and is checked when releasing a capability to ensure it is the same
capability instance.  This specifically avoids a race like:

1- mds issues cap
2- mds sends cap message
3- mds and client time out cap
4- client receives cap message, sends release
5- mds reissues cap on same inode
6- mds receives release, doesn't realize the release is for the
   old capability

Checking seq numbers isn't enough because the MDS may reissue the
cap any number of times between 3 and 6.

mds: set straydn.first correctly during unlink

We need to do this in _unlink_local, not get_or_create_stray, just
as we set dn->first elsewhere in Server.cc.

mds: make straydn.first match the inode

uclient: flush/release buffered data on umount

uclient: update caps code to match kclient logic

kclient: some caps cleanup

kclient: improve snap locking scheme

Because snap_rwsem is taken for read on every write, we want to
minimize contention.  We:

- allow cap removal to occur without snap_rwsem (read or write)
- allow fill_trace and add_cap with snap_rwsem (read)
- require write really only for update_snap_trace and on snap
  updates from the mds.

Dropping realm references without snap_rwsem gets a bit tricky.  We
keep an empty (nref==0) realm list and purge it periodically to
avoid contention in the general case.

v0.6

Merge branch 'unstable'

kclient: rename lookup_mds_session get_mds_session

Since it bumps the ref count.

kclient: realm create does not take a ref count

kclient: split get_snap_realm to lookup and create

objectcacher: fix object trimming

Do not trim object until it fully commits.

mds: count in-flight updates per cap, not release attempts.  do not expire if updating.

mds: drop rdlocks after early reply is sent

We will still hold wrlocks and xlocks until journal entry commits.

mds: properly close session when inodes are still being preallocated

kclient: set i_op for special inodes

todos

kclient: retain comments

kclient: zero out *implemented in __ceph_caps_issued()

Otherwise we can get garbage

kclient: don't retain unwanted RD cap

This will allow an open to succeed locally, without any mechanism
to update the MDS' wanted value.

mds: take srci lock during rename to ensure ctime change propagates

mds: expose projected fields via caps if locks permit

The new CInode::encode_caps_message() mirrors the logic in
CInode::encode_inodestat().

kclient: shouldn't lookup_open with special inode

kclient: considered _held_ caps when deciding what to ignore in fill_inode

If EXCL is being revoked, we still "hold" it and should ignore inode values
provided by the MDS in fill_inode.

kclient: don't require all inode fields when just doing a lookup

mds: check against client in rdlock_try

This affects our auth check in path_traverse.  No need to wait for that to
flush.. we can look at the projected version.  (Not that we're actually
checking permissions yet!)

kclient: fix cap writeback vs revocation

We need to reply to a revocation via check_caps and __send_cap if we are
writing back dirty metadata.

We also need to take care to look at issued|implemented (not just issued)
when deciding what to write back (since it may be being revoked).

mds: fix rmdir ENOTEMPTY checks

Look at projected inode's dirstat.size().

mon: include fsid in MMonObserveNotify

mds: fix forward truncation

vstart: -l | --localhost to use 127.0.0.1

bash, not sh

bash, not sh

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.