RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-03-06 16:28:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

osdc: adjust objecter interface to use SnapContext for writes

Browse Source
This commit is contained in:
Sage Weil 2008-08-05 16:06:55 -07:00
parent 09d37013dd
commit 8f557ad034
21 changed files with 243 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/TODO
View File

@ -43,6 +43,8 @@ snaps on mds
- build snaprealm for any hardlinked file
- include snaps for all (primary+remote) parents
- does snap_follows in MClientFileCaps properly handle snap deletion?
snaps on osd
- clean up snap context packaging..
- seq, not just snap list

53
src/client/Client.cc
View File

@ -1568,7 +1568,7 @@ void Client::add_update_cap(Inode *in, int mds,
dout(15) << "add_update_cap first one, opened snaprealm " << in->snaprealm << dendl;
}
if (in->exporting_mds == mds) {
dout(10) << " clearing exporting_caps on " << mds << dendl;
dout(10) << "add_update_cap clearing exporting_caps on " << mds << dendl;
in->exporting_mds = -1;
in->exporting_issued = 0;
in->exporting_mseq = 0;
@ -1581,6 +1581,8 @@ void Client::add_update_cap(Inode *in, int mds,
cap->implemented |= issued;
cap->seq = seq;
cap->mseq = mseq;
dout(10) << "add_update_cap issued " << cap_string(old_caps) << " -> " << cap_string(cap->issued)
<< " from mds" << mds << dendl;
if (issued & ~old_caps)
signal_cond_list(in->waitfor_caps);
@ -1612,9 +1614,10 @@ void Client::remove_all_caps(Inode *in)
}
}
void SnapRealm::build_snaps()
void SnapRealm::build_snap_context()
{
set<snapid_t> snaps;
snapid_t max_seq = seq;
// start with prior_parents?
for (unsigned i=0; i<prior_parent_snaps.size(); i++)
@ -1622,10 +1625,12 @@ void SnapRealm::build_snaps()
// current parent's snaps
if (pparent) {
const vector<snapid_t> psnaps = pparent->get_snaps();
for (unsigned i=0; i<psnaps.size(); i++)
if (psnaps[i] >= parent_since)
snaps.insert(psnaps[i]);
const SnapContext& psnapc = pparent->get_snap_context();
for (unsigned i=0; i<psnapc.snaps.size(); i++)
if (psnapc.snaps[i] >= parent_since)
snaps.insert(psnapc.snaps[i]);
if (psnapc.seq > max_seq)
max_seq = psnapc.seq;
}
// my snaps
@ -1633,12 +1638,13 @@ void SnapRealm::build_snaps()
snaps.insert(my_snaps[i]);
// ok!
cached_snaps.resize(0);
cached_snaps.reserve(snaps.size());
cached_snap_context.seq = max_seq;
cached_snap_context.snaps.resize(0);
cached_snap_context.snaps.reserve(snaps.size());
for (set<snapid_t>::reverse_iterator p = snaps.rbegin(); p != snaps.rend(); p++)
cached_snaps.push_back(*p);
cached_snap_context.snaps.push_back(*p);
cout << *this << " build_snaps got " << cached_snaps << std::endl;
cout << *this << " build_snap_context got " << cached_snap_context << std::endl;
}
void Client::invalidate_snaprealm_and_children(SnapRealm *realm)
@ -1738,7 +1744,7 @@ inodeno_t Client::update_snap_trace(bufferlist& bl, bool flush)
if (invalidate) {
invalidate_snaprealm_and_children(realm);
dout(15) << "update_snap_trace " << *realm << " self|parent updated" << dendl;
dout(15) << " snaps " << realm->get_snaps() << dendl;
dout(15) << " snapc " << realm->get_snap_context() << dendl;
} else {
dout(10) << "update_snap_trace " << *realm << " seq " << info.seq
<< " <= " << realm->seq << " and same parent, SKIPPING" << dendl;
@ -3467,21 +3473,17 @@ int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
dout(10) << "readahead " << f->nr_consec_read << " reads "
<< f->consec_read_bytes << " bytes ... readahead " << offset << "~" << l
<< " (caller wants " << offset << "~" << size << ")" << dendl;
objectcacher->file_read(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
objectcacher->file_read(in->inode.ino, &in->inode.layout, in->snapid,
offset, l, NULL, 0, 0);
dout(10) << "readahead initiated" << dendl;
}
// read (and possibly block)
vector<snapid_t> emptysnaps;
if (in->snapid == CEPH_NOSNAP)
r = objectcacher->file_read(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
r = objectcacher->file_read(in->inode.ino, &in->inode.layout, in->snapid,
offset, size, bl, 0, onfinish);
else
r = objectcacher->file_read(in->inode.ino, &in->inode.layout,
in->snapid, emptysnaps,
r = objectcacher->file_read(in->inode.ino, &in->inode.layout, in->snapid,
offset, size, bl, 0, onfinish);
@ -3494,8 +3496,7 @@ int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
delete onfinish;
}
} else {
r = objectcacher->file_atomic_sync_read(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
r = objectcacher->file_atomic_sync_read(in->inode.ino, &in->inode.layout, in->snapid,
offset, size, bl, 0, client_lock);
}
@ -3503,8 +3504,7 @@ int Client::_read(Fh *f, __s64 offset, __u64 size, bufferlist *bl)
// object cache OFF -- non-atomic sync read from osd
// do sync read
Objecter::OSDRead *rd = filer->prepare_read(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
Objecter::OSDRead *rd = filer->prepare_read(in->inode.ino, &in->inode.layout, in->snapid,
offset, size, bl, 0);
if (in->hack_balance_reads || g_conf.client_hack_balance_reads)
rd->flags |= CEPH_OSD_OP_BALANCE_READS;
@ -3665,13 +3665,11 @@ int Client::_write(Fh *f, __s64 offset, __u64 size, const char *buf)
objectcacher->wait_for_write(size, client_lock);
// async, caching, non-blocking.
objectcacher->file_write(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
objectcacher->file_write(in->inode.ino, &in->inode.layout, in->snaprealm->get_snap_context(),
offset, size, bl, 0);
} else {
// atomic, synchronous, blocking.
objectcacher->file_atomic_sync_write(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
objectcacher->file_atomic_sync_write(in->inode.ino, &in->inode.layout, in->snaprealm->get_snap_context(),
offset, size, bl, 0, client_lock);
}
} else {
@ -3684,8 +3682,7 @@ int Client::_write(Fh *f, __s64 offset, __u64 size, const char *buf)
unsafe_sync_write++;
in->get_cap_ref(CEPH_CAP_WRBUFFER);
filer->write(in->inode.ino, &in->inode.layout,
CEPH_NOSNAP, in->snaprealm->get_snaps(),
filer->write(in->inode.ino, &in->inode.layout, in->snaprealm->get_snap_context(),
offset, size, bl, 0, onfinish, onsafe);
while (!done)

23
src/client/Client.h
View File

@ -130,7 +130,7 @@ struct SnapRealm {
SnapRealm *pparent;
set<SnapRealm*> pchildren;
vector<snapid_t> cached_snaps; // my_snaps + parent snaps + past_parent_snaps
SnapContext cached_snap_context; // my_snaps + parent snaps + past_parent_snaps
xlist<Inode*> inodes_with_caps;
@ -138,20 +138,21 @@ struct SnapRealm {
ino(i), nref(0), created(0), seq(0),
pparent(NULL) { }
void build_snaps();
void build_snap_context();
void invalidate_cache() {
cached_snaps.clear();
cached_snap_context.clear();
}
const vector<snapid_t>& get_snaps() {
if (cached_snaps.empty())
build_snaps();
return cached_snaps;
const SnapContext& get_snap_context() {
if (cached_snap_context.seq == 0)
build_snap_context();
return cached_snap_context;
}
snapid_t get_follows() {
get_snaps();
if (cached_snaps.empty())
get_snap_context();
if (cached_snap_context.empty())
return 0;
return cached_snaps[0];
return cached_snap_context.snaps[0];
}
};
@ -159,7 +160,7 @@ inline ostream& operator<<(ostream& out, const SnapRealm& r) {
return out << "snaprealm(" << r.ino << " nref=" << r.nref << " c=" << r.created << " seq=" << r.seq
<< " parent=" << r.parent
<< " my_snaps=" << r.my_snaps
<< " cached_snaps=" << r.cached_snaps
<< " cached_snapc=" << r.cached_snap_context
<< ")";
}

27
src/client/SyntheticClient.cc
View File

@ -1307,8 +1307,7 @@ int SyntheticClient::play_trace(Trace& t, string& prefix, bool metadata_only)
lock.Lock();
ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2, 0);
__u64 size;
vector<snapid_t> snaps;
client->objecter->stat(oid, &size, layout, snaps, 0, new C_SafeCond(&lock, &cond, &ack));
client->objecter->stat(oid, &size, layout, 0, new C_SafeCond(&lock, &cond, &ack));
while (!ack) cond.Wait(lock);
lock.Unlock();
}
@ -1321,8 +1320,7 @@ int SyntheticClient::play_trace(Trace& t, string& prefix, bool metadata_only)
lock.Lock();
ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2, 0);
bufferlist bl;
vector<snapid_t> snaps;
client->objecter->read(oid, off, len, layout, snaps, &bl, 0, new C_SafeCond(&lock, &cond, &ack));
client->objecter->read(oid, off, len, layout, &bl, 0, new C_SafeCond(&lock, &cond, &ack));
while (!ack) cond.Wait(lock);
lock.Unlock();
}
@ -1337,8 +1335,8 @@ int SyntheticClient::play_trace(Trace& t, string& prefix, bool metadata_only)
bufferptr bp(len);
bufferlist bl;
bl.push_back(bp);
vector<snapid_t> snaps;
client->objecter->write(oid, off, len, layout, snaps, bl, 0,
SnapContext snapc;
client->objecter->write(oid, off, len, layout, snapc, bl, 0,
new C_SafeCond(&lock, &cond, &ack),
safeg->new_sub());
while (!ack) cond.Wait(lock);
@ -1352,8 +1350,8 @@ int SyntheticClient::play_trace(Trace& t, string& prefix, bool metadata_only)
object_t oid(oh, ol);
lock.Lock();
ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP, 2, 0);
vector<snapid_t> snaps;
client->objecter->zero(oid, off, len, layout, snaps, 0,
SnapContext snapc;
client->objecter->zero(oid, off, len, layout, snapc, 0,
new C_SafeCond(&lock, &cond, &ack),
safeg->new_sub());
while (!ack) cond.Wait(lock);
@ -2059,7 +2057,7 @@ int SyntheticClient::create_objects(int nobj, int osize, int inflight)
object_t oid(0x1000, i);
ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP,
g_default_file_layout.fl_pg_size, 0);
vector<snapid_t> snaps;
SnapContext snapc;
if (i % inflight == 0) {
dout(6) << "create_objects " << i << "/" << (nobj+1) << dendl;
@ -2068,7 +2066,7 @@ int SyntheticClient::create_objects(int nobj, int osize, int inflight)
starts.push_back(g_clock.now());
client->client_lock.Lock();
client->objecter->write(oid, 0, osize, layout, snaps, bl, 0,
client->objecter->write(oid, 0, osize, layout, snapc, bl, 0,
new C_Ref(lock, cond, &unack),
new C_Ref(lock, cond, &unsafe));
client->client_lock.Unlock();
@ -2163,19 +2161,19 @@ int SyntheticClient::object_rw(int nobj, int osize, int wrpc,
ceph_object_layout layout = client->osdmap->make_object_layout(oid, pg_t::TYPE_REP,
g_default_file_layout.fl_pg_size, 0);
vector<snapid_t> snaps;
SnapContext snapc;
client->client_lock.Lock();
utime_t start = g_clock.now();
if (write) {
dout(10) << "write to " << oid << dendl;
client->objecter->write(oid, 0, osize, layout, snaps, bl, 0,
client->objecter->write(oid, 0, osize, layout, snapc, bl, 0,
new C_Ref(lock, cond, &unack),
new C_Ref(lock, cond, &unsafe));
} else {
dout(10) << "read from " << oid << dendl;
bufferlist inbl;
client->objecter->read(oid, 0, osize, layout, snaps, &inbl, 0,
client->objecter->read(oid, 0, osize, layout, &inbl, 0,
new C_Ref(lock, cond, &unack));
}
client->client_lock.Unlock();
@ -3215,11 +3213,10 @@ int SyntheticClient::chunk_file(string &filename)
Cond cond;
bool done;
bufferlist bl;
vector<snapid_t> snaps;
lock.Lock();
Context *onfinish = new C_SafeCond(&lock, &cond, &done);
filer->read(inode.ino, &inode.layout, 0, snaps, pos, get, &bl, 0, onfinish);
filer->read(inode.ino, &inode.layout, 0, pos, get, &bl, 0, onfinish);
while (!done)
cond.Wait(lock);
lock.Unlock();

3
src/dumpjournal.cc
View File

@ -113,8 +113,7 @@ int main(int argc, const char **argv, const char *envp[])
Filer filer(objecter);
bufferlist bl;
vector<snapid_t> snaps;
filer.read(log_inode.ino, &log_inode.layout, 0, snaps,
filer.read(log_inode.ino, &log_inode.layout, 0,
start, len, &bl, 0, new C_SafeCond(&lock, &cond, &done));
lock.Lock();
while (!done)

1
src/include/ceph_fs.h
View File

@ -946,6 +946,7 @@ struct ceph_osd_request_head {
__le32 shed_count;
struct ceph_osd_peer_stat peer_stat;
__le64 snap_seq;
__le32 num_snaps;
__le64 snaps[];
} __attribute__ ((packed));

147
src/include/types.h
View File

@ -84,6 +84,75 @@ namespace __gnu_cxx {
}
// -- io helpers --
template<class A, class B>
inline ostream& operator<<(ostream& out, const pair<A,B> v) {
return out << v.first << "," << v.second;
}
template<class A>
inline ostream& operator<<(ostream& out, const vector<A>& v) {
out << "[";
for (typename vector<A>::const_iterator p = v.begin(); p != v.end(); p++) {
if (p != v.begin()) out << ",";
out << *p;
}
out << "]";
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const list<A>& ilist) {
for (typename list<A>::const_iterator it = ilist.begin();
it != ilist.end();
it++) {
if (it != ilist.begin()) out << ",";
out << *it;
}
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const set<A>& iset) {
for (typename set<A>::const_iterator it = iset.begin();
it != iset.end();
it++) {
if (it != iset.begin()) out << ",";
out << *it;
}
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const multiset<A>& iset) {
for (typename multiset<A>::const_iterator it = iset.begin();
it != iset.end();
it++) {
if (it != iset.begin()) out << ",";
out << *it;
}
return out;
}
template<class A,class B>
inline ostream& operator<<(ostream& out, const map<A,B>& m)
{
out << "{";
for (typename map<A,B>::const_iterator it = m.begin();
it != m.end();
it++) {
if (it != m.begin()) out << ",";
out << it->first << "=" << it->second;
}
out << "}";
return out;
}
/*
* comparators for stl containers
*/
@ -243,7 +312,20 @@ struct SnapRealmInfo {
WRITE_CLASS_ENCODER(SnapRealmInfo)
struct SnapContext {
snapid_t seq;
vector<snapid_t> snaps;
void clear() {
seq = 0;
snaps.clear();
}
bool empty() { return seq == 0; }
};
inline ostream& operator<<(ostream& out, const SnapContext& snapc) {
return out << snapc.seq << "=" << snapc.snaps;
}
// dentries
#define MAX_DENTRY_LEN 255
@ -257,71 +339,6 @@ inline ostream& operator<<(ostream& out, const ceph_fsid& f) {
// -- io helpers --
template<class A, class B>
inline ostream& operator<<(ostream& out, const pair<A,B> v) {
return out << v.first << "," << v.second;
}
template<class A>
inline ostream& operator<<(ostream& out, const vector<A>& v) {
out << "[";
for (typename vector<A>::const_iterator p = v.begin(); p != v.end(); p++) {
if (p != v.begin()) out << ",";
out << *p;
}
out << "]";
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const list<A>& ilist) {
for (typename list<A>::const_iterator it = ilist.begin();
it != ilist.end();
it++) {
if (it != ilist.begin()) out << ",";
out << *it;
}
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const set<A>& iset) {
for (typename set<A>::const_iterator it = iset.begin();
it != iset.end();
it++) {
if (it != iset.begin()) out << ",";
out << *it;
}
return out;
}
template<class A>
inline ostream& operator<<(ostream& out, const multiset<A>& iset) {
for (typename multiset<A>::const_iterator it = iset.begin();
it != iset.end();
it++) {
if (it != iset.begin()) out << ",";
out << *it;
}
return out;
}
template<class A,class B>
inline ostream& operator<<(ostream& out, const map<A,B>& m)
{
out << "{";
for (typename map<A,B>::const_iterator it = m.begin();
it != m.end();
it++) {
if (it != m.begin()) out << ",";
out << it->first << "=" << it->second;
}
out << "}";
return out;
}
#endif

6
src/mds/CDir.cc
View File

@ -1034,12 +1034,10 @@ void CDir::fetch(Context *c, bool ignore_authpinnability)
// start by reading the first hunk of it
C_Dir_Fetch *fin = new C_Dir_Fetch(this);
vector<snapid_t> snaps;
cache->mds->objecter->read( get_ondisk_object(),
0, 0, // whole object
cache->mds->objecter->osdmap->file_to_object_layout( get_ondisk_object(),
g_default_mds_dir_layout ),
snaps,
&fin->bl, 0,
fin );
}
@ -1462,12 +1460,12 @@ void CDir::_commit(version_t want)
finalbl.claim_append(bl);
// write it.
vector<snapid_t> snapvec;
SnapContext snapc;
cache->mds->objecter->write( get_ondisk_object(),
0, finalbl.length(),
cache->mds->objecter->osdmap->file_to_object_layout( get_ondisk_object(),
g_default_mds_dir_layout ),
snapvec,
snapc,
finalbl, 0,
NULL, new C_Dir_Committed(this, get_version()) );
}

11
src/mds/MDCache.cc
View File

@ -3906,15 +3906,11 @@ void MDCache::do_file_recover()
CInode *in = *file_recover_queue.begin();
file_recover_queue.erase(in);
snapid_t snap = in->last;
const vector<snapid_t>& snaps = in->find_snaprealm()->get_snap_vector();
if (in->inode.max_size > in->inode.size) {
dout(10) << "do_file_recover starting " << in->inode.size << "/" << in->inode.max_size
<< " snap " << snap << " snaps " << snaps
<< " " << *in << dendl;
file_recovering.insert(in);
mds->filer->probe(in->inode.ino, &in->inode.layout, snap, snaps,
mds->filer->probe(in->inode.ino, &in->inode.layout, in->last,
in->inode.max_size, &in->inode.size, false,
0, new C_MDC_Recover(this, in));
} else {
@ -4011,8 +4007,8 @@ void MDCache::_do_purge_inode(CInode *in, loff_t newsize, loff_t oldsize)
// remove
if (newsize < oldsize) {
const vector<snapid_t> snaps = in->find_snaprealm()->get_snap_vector();
mds->filer->remove(in->inode.ino, &in->inode.layout, CEPH_NOSNAP, snaps,
const SnapContext& snapc = in->find_snaprealm()->get_snap_context();
mds->filer->remove(in->inode.ino, &in->inode.layout, snapc,
newsize, oldsize-newsize, 0,
0, new C_MDC_PurgeFinish(this, in, newsize, oldsize));
} else {
@ -6134,7 +6130,6 @@ void MDCache::do_realm_split_notify(CInode *in)
bufferlist snapbl;
in->snaprealm->build_snap_trace(snapbl);
const vector<snapid_t> snaps = in->snaprealm->get_snap_vector();
map<int, MClientSnap*> updates;
// send splits for all clients with caps in this _or nested_ realms.

7
src/mds/MDSTable.cc
View File

@ -57,8 +57,8 @@ void MDSTable::save(Context *onfinish, version_t v)
waitfor_save[version].push_back(onfinish);
// write (async)
vector<snapid_t> snaps;
mds->filer->write(ino, &layout, 0, snaps,
SnapContext snapc;
mds->filer->write(ino, &layout, snapc,
0, bl.length(), bl,
0,
0, new C_MT_Save(this, version));
@ -112,8 +112,7 @@ void MDSTable::load(Context *onfinish)
state = STATE_OPENING;
C_MT_Load *c = new C_MT_Load(this, onfinish);
vector<snapid_t> snaps;
mds->filer->read(ino, &layout, 0, snaps,
mds->filer->read(ino, &layout, 0,
0, ceph_file_layout_su(layout),
&c->bl, 0,
c);

7
src/mds/SessionMap.cc
View File

@ -62,8 +62,7 @@ void SessionMap::load(Context *onload)
waiting_for_load.push_back(onload);
C_SM_Load *c = new C_SM_Load(this);
vector<snapid_t> snaps;
mds->filer->read(inode.ino, &inode.layout, 0, snaps,
mds->filer->read(inode.ino, &inode.layout, 0,
0, ceph_file_layout_su(inode.layout),
&c->bl, 0,
c);
@ -113,8 +112,8 @@ void SessionMap::save(Context *onsave, version_t needv)
init_inode();
encode(bl);
committing = version;
vector<snapid_t> snaps;
mds->filer->write(inode.ino, &inode.layout, 0, snaps,
SnapContext snapc;
mds->filer->write(inode.ino, &inode.layout, snapc,
0, bl.length(), bl,
0,
0, new C_SM_Save(this, version));

14
src/mds/snap.cc
View File

@ -180,7 +180,8 @@ void SnapRealm::check_cache()
return;
cached_snaps.clear();
cached_snap_vec.clear();
cached_snap_context.clear();
cached_last_created = last_created;
cached_last_destroyed = last_destroyed;
cached_seq = seq;
@ -207,20 +208,21 @@ const set<snapid_t>& SnapRealm::get_snaps()
/*
* build vector in reverse sorted order
*/
const vector<snapid_t>& SnapRealm::get_snap_vector()
const SnapContext& SnapRealm::get_snap_context()
{
check_cache();
if (cached_snap_vec.empty()) {
cached_snap_vec.resize(cached_snaps.size());
if (!cached_snap_context.seq) {
cached_snap_context.seq = cached_seq;
cached_snap_context.snaps.resize(cached_snaps.size());
unsigned i = 0;
for (set<snapid_t>::reverse_iterator p = cached_snaps.rbegin();
p != cached_snaps.rend();
p++)
cached_snap_vec[i++] = *p;
cached_snap_context.snaps[i++] = *p;
}
return cached_snap_vec;
return cached_snap_context;
}
void SnapRealm::get_snap_info(map<snapid_t,SnapInfo*>& infomap, snapid_t first, snapid_t last)

4
src/mds/snap.h
View File

@ -122,7 +122,7 @@ struct SnapRealm {
snapid_t cached_last_created; // max last_created over all past+present parents
snapid_t cached_last_destroyed;
set<snapid_t> cached_snaps;
vector<snapid_t> cached_snap_vec;
SnapContext cached_snap_context;
xlist<CInode*> inodes_with_caps; // for efficient realm splits
map<int, xlist<Capability*> > client_caps; // to identify clients who need snap notifications
@ -170,7 +170,7 @@ struct SnapRealm {
void check_cache();
const set<snapid_t>& get_snaps();
const vector<snapid_t>& get_snap_vector();
const SnapContext& get_snap_context();
void invalidate_cached_snaps() {
cached_seq = 0;
}

2
src/messages/MOSDOp.h
View File

@ -65,7 +65,9 @@ private:
friend class MOSDOpReply;
public:
snapid_t get_snap_seq() { return snapid_t(head.snap_seq); }
vector<snapid_t> &get_snaps() { return snaps; }
void set_snap_seq(snapid_t s) { head.snap_seq = s; }
osd_reqid_t get_reqid() { return osd_reqid_t(get_orig_source(),
head.client_inc,

8
src/osdc/Filer.cc
View File

@ -45,7 +45,7 @@ public:
int Filer::probe(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t> &snaps,
snapid_t snapid,
__u64 start_from,
__u64 *end, // LB, when !fwd
bool fwd,
@ -57,7 +57,7 @@ int Filer::probe(inodeno_t ino,
<< " starting from " << start_from
<< dendl;
Probe *probe = new Probe(ino, *layout, snap, snaps, start_from, end, flags, fwd, onfinish);
Probe *probe = new Probe(ino, *layout, snapid, start_from, end, flags, fwd, onfinish);
// period (bytes before we jump unto a new set of object(s))
__u64 period = ceph_file_layout_period(*layout);
@ -86,14 +86,14 @@ void Filer::_probe(Probe *probe)
<< dendl;
// map range onto objects
file_to_extents(probe->ino, &probe->layout, probe->snap, probe->from, probe->probing_len, probe->probing);
file_to_extents(probe->ino, &probe->layout, probe->snapid, probe->from, probe->probing_len, probe->probing);
for (list<ObjectExtent>::iterator p = probe->probing.begin();
p != probe->probing.end();
p++) {
dout(10) << "_probe probing " << p->oid << dendl;
C_Probe *c = new C_Probe(this, probe, p->oid);
probe->ops[p->oid] = objecter->stat(p->oid, &c->size, p->layout, probe->snaps, probe->flags, c);
probe->ops[p->oid] = objecter->stat(p->oid, &c->size, p->layout, probe->flags, c);
}
}

37
src/osdc/Filer.h
View File

@ -45,8 +45,7 @@ class Filer {
struct Probe {
inodeno_t ino;
ceph_file_layout layout;
snapid_t snap;
vector<snapid_t> snaps;
snapid_t snapid;
__u64 from; // for !fwd, this is start of extent we are probing, thus possibly < our endpoint.
__u64 *end;
int flags;
@ -61,9 +60,9 @@ class Filer {
map<object_t, __u64> known;
map<object_t, tid_t> ops;
Probe(inodeno_t i, ceph_file_layout &l, snapid_t sn, const vector<snapid_t>& sns,
Probe(inodeno_t i, ceph_file_layout &l, snapid_t sn,
__u64 f, __u64 *e, int fl, bool fw, Context *c) :
ino(i), layout(l), snap(sn), snaps(sns),
ino(i), layout(l), snapid(sn),
from(f), end(e), flags(fl), fwd(fw), onfinish(c), probing_len(0) {}
};
@ -83,64 +82,64 @@ class Filer {
/*** async file interface ***/
Objecter::OSDRead *prepare_read(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t>& snaps,
snapid_t snapid,
__u64 offset,
size_t len,
bufferlist *bl,
int flags) {
Objecter::OSDRead *rd = objecter->prepare_read(snaps, bl, flags);
file_to_extents(ino, layout, snap, offset, len, rd->extents);
Objecter::OSDRead *rd = objecter->prepare_read(bl, flags);
file_to_extents(ino, layout, snapid, offset, len, rd->extents);
return rd;
}
int read(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, vector<snapid_t>& snaps,
snapid_t snapid,
__u64 offset,
size_t len,
bufferlist *bl, // ptr to data
int flags,
Context *onfinish) {
Objecter::OSDRead *rd = prepare_read(ino, layout, snap, snaps, offset, len, bl, flags);
Objecter::OSDRead *rd = prepare_read(ino, layout, snapid, offset, len, bl, flags);
return objecter->readx(rd, onfinish) > 0 ? 0:-1;
}
int write(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t>& snaps,
const SnapContext& snapc,
__u64 offset,
size_t len,
bufferlist& bl,
int flags,
Context *onack,
Context *oncommit) {
Objecter::OSDWrite *wr = objecter->prepare_write(snaps, bl, flags);
file_to_extents(ino, layout, snap, offset, len, wr->extents);
Objecter::OSDWrite *wr = objecter->prepare_write(snapc, bl, flags);
file_to_extents(ino, layout, CEPH_NOSNAP, offset, len, wr->extents);
return objecter->modifyx(wr, onack, oncommit) > 0 ? 0:-1;
}
int zero(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, vector<snapid_t>& snaps,
const SnapContext& snapc,
__u64 offset,
size_t len,
int flags,
Context *onack,
Context *oncommit) {
Objecter::OSDModify *z = objecter->prepare_modify(snaps, CEPH_OSD_OP_ZERO, flags);
file_to_extents(ino, layout, snap, offset, len, z->extents);
Objecter::OSDModify *z = objecter->prepare_modify(snapc, CEPH_OSD_OP_ZERO, flags);
file_to_extents(ino, layout, CEPH_NOSNAP, offset, len, z->extents);
return objecter->modifyx(z, onack, oncommit) > 0 ? 0:-1;
}
int remove(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t>& snaps,
const SnapContext& snapc,
__u64 offset,
size_t len,
int flags,
Context *onack,
Context *oncommit) {
Objecter::OSDModify *z = objecter->prepare_modify(snaps, CEPH_OSD_OP_DELETE, flags);
file_to_extents(ino, layout, snap, offset, len, z->extents);
Objecter::OSDModify *z = objecter->prepare_modify(snapc, CEPH_OSD_OP_DELETE, flags);
file_to_extents(ino, layout, CEPH_NOSNAP, offset, len, z->extents);
return objecter->modifyx(z, onack, oncommit) > 0 ? 0:-1;
}
@ -151,7 +150,7 @@ class Filer {
*/
int probe(inodeno_t ino,
ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t> &snaps,
snapid_t snapid,
__u64 start_from,
__u64 *end,
bool fwd,

26
src/osdc/Journaler.cc
View File

@ -82,7 +82,8 @@ void Journaler::recover(Context *onread)
state = STATE_READHEAD;
C_ReadHead *fin = new C_ReadHead(this);
vector<snapid_t> snaps;
filer.read(ino, &layout, 0, snaps, 0, sizeof(Header), &fin->bl, CEPH_OSD_OP_INCLOCK_FAIL, fin);
filer.read(ino, &layout, 0,
0, sizeof(Header), &fin->bl, CEPH_OSD_OP_INCLOCK_FAIL, fin);
}
void Journaler::_finish_read_head(int r, bufferlist& bl)
@ -113,8 +114,8 @@ void Journaler::_finish_read_head(int r, bufferlist& bl)
// probe the log
state = STATE_PROBING;
C_ProbeEnd *fin = new C_ProbeEnd(this);
vector<snapid_t> snaps;
filer.probe(ino, &layout, 0, snaps, h.write_pos, (__u64 *)&fin->end, true, CEPH_OSD_OP_INCLOCK_FAIL, fin);
filer.probe(ino, &layout, 0,
h.write_pos, (__u64 *)&fin->end, true, CEPH_OSD_OP_INCLOCK_FAIL, fin);
}
void Journaler::_finish_probe_end(int r, __s64 end)
@ -170,8 +171,9 @@ void Journaler::write_head(Context *oncommit)
bufferlist bl;
::encode(last_written, bl);
vector<snapid_t> snaps;
filer.write(ino, &layout, 0, snaps, 0, bl.length(), bl, CEPH_OSD_OP_INCLOCK_FAIL,
SnapContext snapc;
filer.write(ino, &layout, snapc,
0, bl.length(), bl, CEPH_OSD_OP_INCLOCK_FAIL,
NULL,
new C_WriteHead(this, last_written, oncommit));
}
@ -341,8 +343,9 @@ void Journaler::_do_flush()
// submit write for anything pending
// flush _start_ pos to _finish_flush
utime_t now = g_clock.now();
vector<snapid_t> snaps;
filer.write(ino, &layout, 0, snaps, flush_pos, len, write_buf,
SnapContext snapc;
filer.write(ino, &layout, snapc,
flush_pos, len, write_buf,
CEPH_OSD_OP_INCLOCK_FAIL,
new C_Flush(this, flush_pos, now, false), // on ACK
new C_Flush(this, flush_pos, now, true)); // on COMMIT
@ -530,8 +533,8 @@ void Journaler::_issue_read(__s64 len)
<< ", read pointers " << read_pos << "/" << received_pos << "/" << (requested_pos+len)
<< dendl;
vector<snapid_t> snaps;
filer.read(ino, &layout, 0, snaps, requested_pos, len, &reading_buf, CEPH_OSD_OP_INCLOCK_FAIL,
filer.read(ino, &layout, 0,
requested_pos, len, &reading_buf, CEPH_OSD_OP_INCLOCK_FAIL,
new C_Read(this));
requested_pos += len;
}
@ -715,8 +718,9 @@ void Journaler::trim()
<< trimmed_pos << "/" << trimming_pos << "/" << expire_pos
<< dendl;
vector<snapid_t> snaps;
filer.remove(ino, &layout, 0, snaps, trimming_pos, trim_to-trimming_pos, CEPH_OSD_OP_INCLOCK_FAIL,
SnapContext snapc;
filer.remove(ino, &layout, snapc,
trimming_pos, trim_to-trimming_pos, CEPH_OSD_OP_INCLOCK_FAIL,
NULL, new C_Trim(this, trim_to));
trimming_pos = trim_to;
}

9
src/osdc/ObjectCacher.cc
View File

@ -23,7 +23,7 @@ ObjectCacher::BufferHead *ObjectCacher::Object::split(BufferHead *left, off_t of
ObjectCacher::BufferHead *right = new BufferHead(this);
right->last_write_tid = left->last_write_tid;
right->set_state(left->get_state());
right->snaps = left->snaps;
right->snapc = left->snapc;
off_t newleftlen = off - left->start();
right->set_start(off);
@ -403,7 +403,6 @@ void ObjectCacher::bh_read(BufferHead *bh)
// go
objecter->read(bh->ob->get_oid(), bh->start(), bh->length(), bh->ob->get_layout(),
bh->snaps,
&onfinish->bl, 0,
onfinish);
}
@ -494,7 +493,7 @@ void ObjectCacher::bh_write(BufferHead *bh)
// go
tid_t tid = objecter->write(bh->ob->get_oid(), bh->start(), bh->length(), bh->ob->get_layout(),
bh->snaps, bh->bl, 0,
bh->snapc, bh->bl, 0,
onack, oncommit);
// set bh last_write_tid
@ -748,7 +747,6 @@ int ObjectCacher::readx(Objecter::OSDRead *rd, inodeno_t ino, Context *onfinish)
for (map<off_t, BufferHead*>::iterator bh_it = missing.begin();
bh_it != missing.end();
bh_it++) {
bh_it->second->snaps = rd->snaps;
bh_read(bh_it->second);
if (success && onfinish) {
dout(10) << "readx missed, waiting on " << *bh_it->second
@ -762,7 +760,6 @@ int ObjectCacher::readx(Objecter::OSDRead *rd, inodeno_t ino, Context *onfinish)
for (map<off_t, BufferHead*>::iterator bh_it = rx.begin();
bh_it != rx.end();
bh_it++) {
bh_it->second->snaps = rd->snaps;
touch_bh(bh_it->second); // bump in lru, so we don't lose it.
if (success && onfinish) {
dout(10) << "readx missed, waiting on " << *bh_it->second
@ -880,7 +877,7 @@ int ObjectCacher::writex(Objecter::OSDWrite *wr, inodeno_t ino)
// map it all into a single bufferhead.
BufferHead *bh = o->map_write(wr);
bh->snaps = wr->snaps;
bh->snapc = wr->snapc;
// adjust buffer pointers (ie "copy" data into my cache)
// this is over a single ObjectExtent, so we know that

26
src/osdc/ObjectCacher.h
View File

@ -43,7 +43,7 @@ class ObjectCacher {
bufferlist bl;
tid_t last_write_tid; // version of bh (if non-zero)
utime_t last_write;
vector<snapid_t> snaps;
SnapContext snapc;
map< off_t, list<Context*> > waitfor_read;
@ -483,21 +483,21 @@ class ObjectCacher {
// file functions
/*** async+caching (non-blocking) file interface ***/
int file_read(inodeno_t ino, ceph_file_layout *layout, snapid_t snap, const vector<snapid_t> &snaps,
int file_read(inodeno_t ino, ceph_file_layout *layout, snapid_t snapid,
off_t offset, size_t len,
bufferlist *bl,
int flags,
Context *onfinish) {
Objecter::OSDRead *rd = objecter->prepare_read(snaps, bl, flags);
filer.file_to_extents(ino, layout, snap, offset, len, rd->extents);
Objecter::OSDRead *rd = objecter->prepare_read(bl, flags);
filer.file_to_extents(ino, layout, snapid, offset, len, rd->extents);
return readx(rd, ino, onfinish);
}
int file_write(inodeno_t ino, ceph_file_layout *layout, snapid_t snap, const vector<snapid_t> &snaps,
int file_write(inodeno_t ino, ceph_file_layout *layout, const SnapContext& snapc,
off_t offset, size_t len,
bufferlist& bl, int flags) {
Objecter::OSDWrite *wr = objecter->prepare_write(snaps, bl, flags);
filer.file_to_extents(ino, layout, snap, offset, len, wr->extents);
Objecter::OSDWrite *wr = objecter->prepare_write(snapc, bl, flags);
filer.file_to_extents(ino, layout, CEPH_NOSNAP, offset, len, wr->extents);
return writex(wr, ino);
}
@ -506,22 +506,22 @@ class ObjectCacher {
/*** sync+blocking file interface ***/
int file_atomic_sync_read(inodeno_t ino, ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t> &snaps,
snapid_t snapid,
off_t offset, size_t len,
bufferlist *bl, int flags,
Mutex &lock) {
Objecter::OSDRead *rd = objecter->prepare_read(snaps, bl, flags);
filer.file_to_extents(ino, layout, snap, offset, len, rd->extents);
Objecter::OSDRead *rd = objecter->prepare_read(bl, flags);
filer.file_to_extents(ino, layout, snapid, offset, len, rd->extents);
return atomic_sync_readx(rd, ino, lock);
}
int file_atomic_sync_write(inodeno_t ino, ceph_file_layout *layout,
snapid_t snap, const vector<snapid_t> &snaps,
const SnapContext& snapc,
off_t offset, size_t len,
bufferlist& bl, int flags,
Mutex &lock) {
Objecter::OSDWrite *wr = objecter->prepare_write(snaps, bl, flags);
filer.file_to_extents(ino, layout, snap, offset, len, wr->extents);
Objecter::OSDWrite *wr = objecter->prepare_write(snapc, bl, flags);
filer.file_to_extents(ino, layout, CEPH_NOSNAP, offset, len, wr->extents);
return atomic_sync_writex(wr, ino, lock);
}

25
src/osdc/Objecter.cc
View File

@ -336,9 +336,9 @@ void Objecter::handle_osd_op_reply(MOSDOpReply *m)
// stat -----------------------------------
tid_t Objecter::stat(object_t oid, __u64 *size, ceph_object_layout ol, const vector<snapid_t>& snaps, int flags, Context *onfinish)
tid_t Objecter::stat(object_t oid, __u64 *size, ceph_object_layout ol, int flags, Context *onfinish)
{
OSDStat *st = prepare_stat(snaps, size, flags);
OSDStat *st = prepare_stat(size, flags);
st->extents.push_back(ObjectExtent(oid, 0, 0));
st->extents.front().layout = ol;
st->onfinish = onfinish;
@ -377,7 +377,6 @@ tid_t Objecter::stat_submit(OSDStat *st)
MOSDOp *m = new MOSDOp(client_inc, last_tid,
ex.oid, ex.layout, osdmap->get_epoch(),
CEPH_OSD_OP_STAT, flags);
m->get_snaps() = st->snaps;
if (inc_lock > 0) {
st->inc_lock = inc_lock;
m->set_inc_lock(inc_lock);
@ -452,10 +451,10 @@ void Objecter::handle_osd_stat_reply(MOSDOpReply *m)
// read -----------------------------------
tid_t Objecter::read(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t> &snaps, bufferlist *bl, int flags,
tid_t Objecter::read(object_t oid, __u64 off, size_t len, ceph_object_layout ol, bufferlist *bl, int flags,
Context *onfinish)
{
OSDRead *rd = prepare_read(snaps, bl, flags);
OSDRead *rd = prepare_read(bl, flags);
rd->extents.push_back(ObjectExtent(oid, off, len));
rd->extents.front().layout = ol;
readx(rd, onfinish);
@ -506,7 +505,6 @@ tid_t Objecter::readx_submit(OSDRead *rd, ObjectExtent &ex, bool retry)
MOSDOp *m = new MOSDOp(client_inc, last_tid,
ex.oid, ex.layout, osdmap->get_epoch(),
CEPH_OSD_OP_READ, flags);
m->get_snaps() = rd->snaps;
if (inc_lock > 0) {
rd->inc_lock = inc_lock;
m->set_inc_lock(inc_lock);
@ -710,10 +708,10 @@ void Objecter::handle_osd_read_reply(MOSDOpReply *m)
// write ------------------------------------
tid_t Objecter::write(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t> &snaps, bufferlist &bl, int flags,
tid_t Objecter::write(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const SnapContext& snapc, bufferlist &bl, int flags,
Context *onack, Context *oncommit)
{
OSDWrite *wr = prepare_write(snaps, bl, flags);
OSDWrite *wr = prepare_write(snapc, bl, flags);
wr->extents.push_back(ObjectExtent(oid, off, len));
wr->extents.front().layout = ol;
wr->extents.front().buffer_extents[0] = len;
@ -724,10 +722,10 @@ tid_t Objecter::write(object_t oid, __u64 off, size_t len, ceph_object_layout ol
// zero
tid_t Objecter::zero(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t> &snaps, int flags,
tid_t Objecter::zero(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const SnapContext& snapc, int flags,
Context *onack, Context *oncommit)
{
OSDModify *z = prepare_modify(snaps, CEPH_OSD_OP_ZERO, flags);
OSDModify *z = prepare_modify(snapc, CEPH_OSD_OP_ZERO, flags);
z->extents.push_back(ObjectExtent(oid, off, len));
z->extents.front().layout = ol;
modifyx(z, onack, oncommit);
@ -737,10 +735,10 @@ tid_t Objecter::zero(object_t oid, __u64 off, size_t len, ceph_object_layout ol,
// lock ops
tid_t Objecter::lock(int op, object_t oid, int flags, ceph_object_layout ol, const vector<snapid_t> &snaps,
tid_t Objecter::lock(int op, object_t oid, int flags, ceph_object_layout ol, const SnapContext& snapc,
Context *onack, Context *oncommit)
{
OSDModify *l = prepare_modify(snaps, op, flags);
OSDModify *l = prepare_modify(snapc, op, flags);
l->extents.push_back(ObjectExtent(oid, 0, 0));
l->extents.front().layout = ol;
modifyx(l, onack, oncommit);
@ -810,7 +808,8 @@ tid_t Objecter::modifyx_submit(OSDModify *wr, ObjectExtent &ex, tid_t usetid)
MOSDOp *m = new MOSDOp(client_inc, tid,
ex.oid, ex.layout, osdmap->get_epoch(),
wr->op, flags);
m->get_snaps() = wr->snaps;
m->set_snap_seq(wr->snapc.seq);
m->get_snaps() = wr->snapc.snaps;
if (inc_lock > 0) {
wr->inc_lock = inc_lock;
m->set_inc_lock(inc_lock);

40
src/osdc/Objecter.h
View File

@ -71,9 +71,8 @@ class Objecter {
class OSDOp {
public:
list<ObjectExtent> extents;
vector<snapid_t> snaps;
int inc_lock;
OSDOp(const vector<snapid_t>& s) : snaps(s), inc_lock(0) {}
OSDOp() : inc_lock(0) {}
virtual ~OSDOp() {}
};
@ -85,14 +84,14 @@ class Objecter {
map<object_t, bufferlist*> read_data; // bits of data as they come back
int flags;
OSDRead(const vector<snapid_t> &s, bufferlist *b, int f) : OSDOp(s), bl(b), onfinish(0), flags(f) {
OSDRead(bufferlist *b, int f) : OSDOp(), bl(b), onfinish(0), flags(f) {
if (bl)
bl->clear();
}
};
OSDRead *prepare_read(const vector<snapid_t>& snaps, bufferlist *b, int f) {
return new OSDRead(snaps, b, f);
OSDRead *prepare_read(bufferlist *b, int f) {
return new OSDRead(b, f);
}
class OSDStat : public OSDOp {
@ -101,16 +100,17 @@ class Objecter {
__u64 *size; // where the size goes.
int flags;
Context *onfinish;
OSDStat(const vector<snapid_t> &sn, __u64 *s, int f) : OSDOp(sn), tid(0), size(s), flags(f), onfinish(0) { }
OSDStat(__u64 *s, int f) : OSDOp(), tid(0), size(s), flags(f), onfinish(0) { }
};
OSDStat *prepare_stat(const vector<snapid_t>& snaps, __u64 *s, int f) {
return new OSDStat(snaps, s, f);
OSDStat *prepare_stat(__u64 *s, int f) {
return new OSDStat(s, f);
}
// generic modify
class OSDModify : public OSDOp {
public:
SnapContext snapc;
int op;
list<ObjectExtent> extents;
int flags;
@ -120,22 +120,22 @@ class Objecter {
map<tid_t, eversion_t> tid_version;
map<tid_t, ObjectExtent> waitfor_commit;
OSDModify(const vector<snapid_t>& sn, int o, int f) : OSDOp(sn) ,op(o), flags(f), onack(0), oncommit(0) {}
OSDModify(const SnapContext& sc, int o, int f) : OSDOp(), snapc(sc), op(o), flags(f), onack(0), oncommit(0) {}
};
OSDModify *prepare_modify(const vector<snapid_t>& snaps, int o, int f) {
return new OSDModify(snaps, o, f);
OSDModify *prepare_modify(const SnapContext& sc, int o, int f) {
return new OSDModify(sc, o, f);
}
// write (includes the bufferlist)
class OSDWrite : public OSDModify {
public:
bufferlist bl;
OSDWrite(const vector<snapid_t>& sn, bufferlist &b, int f) : OSDModify(sn, CEPH_OSD_OP_WRITE, f), bl(b) {}
OSDWrite(const SnapContext& sc, bufferlist &b, int f) : OSDModify(sc, CEPH_OSD_OP_WRITE, f), bl(b) {}
};
OSDWrite *prepare_write(const vector<snapid_t>& snaps, bufferlist &b, int f) {
return new OSDWrite(snaps, b, f);
OSDWrite *prepare_write(const SnapContext& sc, bufferlist &b, int f) {
return new OSDWrite(sc, b, f);
}
@ -237,15 +237,15 @@ class Objecter {
tid_t modifyx(OSDModify *wr, Context *onack, Context *oncommit);
// even lazier
tid_t read(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t>& snaps, bufferlist *bl, int flags,
tid_t read(object_t oid, __u64 off, size_t len, ceph_object_layout ol, bufferlist *bl, int flags,
Context *onfinish);
tid_t write(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t>& snaps, bufferlist &bl, int flags,
tid_t stat(object_t oid, __u64 *size, ceph_object_layout ol, int flags, Context *onfinish);
tid_t write(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const SnapContext& snapc, bufferlist &bl, int flags,
Context *onack, Context *oncommit);
tid_t zero(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const vector<snapid_t>& snaps, int flags,
tid_t zero(object_t oid, __u64 off, size_t len, ceph_object_layout ol, const SnapContext& snapc, int flags,
Context *onack, Context *oncommit);
tid_t stat(object_t oid, __u64 *size, ceph_object_layout ol, const vector<snapid_t>& snaps, int flags, Context *onfinish);
tid_t lock(int op, object_t oid, int flags, ceph_object_layout ol, const vector<snapid_t>& snaps, Context *onack, Context *oncommit);
tid_t lock(int op, object_t oid, int flags, ceph_object_layout ol, const SnapContext& snapc, Context *onack, Context *oncommit);
void ms_handle_failure(Message *m, entity_name_t dest, const entity_inst_t& inst);