__u8 state{0};
CInode::mempool_old_inode_map old_inodes; // XXX should not be part of mempool; wait for std::pmr to simplify
- fullbit(const fullbit& o);
- const fullbit& operator=(const fullbit& o);
-
fullbit(std::string_view d, snapid_t df, snapid_t dl,
version_t v, const CInode::mempool_inode& i, const fragtree_t &dft,
const CInode::mempool_xattr_map &xa, std::string_view sym,
decode(p);
}
fullbit() {}
+ fullbit(const fullbit&) = delete;
~fullbit() {}
+ fullbit& operator=(const fullbit&) = delete;
void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::const_iterator &bl);
void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<nullbit*>& ls);
- void print(ostream& out) {
+ void print(ostream& out) const {
out << " nullbit dn " << dn << " [" << dnfirst << "," << dnlast << "] dnv " << dnv
<< " dirty=" << dirty << std::endl;
}
private:
mutable bufferlist dnbl;
mutable bool dn_decoded;
- mutable list<std::shared_ptr<fullbit> > dfull;
- mutable list<remotebit> dremote;
- mutable list<nullbit> dnull;
+ mutable list<fullbit> dfull;
+ mutable vector<remotebit> dremote;
+ mutable vector<nullbit> dnull;
public:
dirlump() : state(0), nfull(0), nremote(0), nnull(0), dn_decoded(true) { }
+ dirlump(const dirlump&) = delete;
+ dirlump& operator=(const dirlump&) = delete;
bool is_complete() const { return state & STATE_COMPLETE; }
void mark_complete() { state |= STATE_COMPLETE; }
bool is_dirty_dft() { return state & STATE_DIRTYDFT; }
void mark_dirty_dft() { state |= STATE_DIRTYDFT; }
- const list<std::shared_ptr<fullbit> > &get_dfull() const { return dfull; }
- const list<remotebit> &get_dremote() const { return dremote; }
- const list<nullbit> &get_dnull() const { return dnull; }
+ const list<fullbit> &get_dfull() const { return dfull; }
+ list<fullbit> &_get_dfull() { return dfull; }
+ const vector<remotebit> &get_dremote() const { return dremote; }
+ const vector<nullbit> &get_dnull() const { return dnull; }
- void add_dnull(nullbit const &n) { dnull.push_back(n); };
- void add_dfull(std::shared_ptr<fullbit> const &p) { dfull.push_back(p); };
- void add_dremote(remotebit const &r) { dremote.push_back(r); };
+ template< class... Args>
+ void add_dfull(Args&&... args) {
+ dfull.emplace_back(std::forward<Args>(args)...);
+ }
+ template< class... Args>
+ void add_dremote(Args&&... args) {
+ dremote.emplace_back(std::forward<Args>(args)...);
+ }
+ template< class... Args>
+ void add_dnull(Args&&... args) {
+ dnull.emplace_back(std::forward<Args>(args)...);
+ }
- void print(dirfrag_t dirfrag, ostream& out) {
+ void print(dirfrag_t dirfrag, ostream& out) const {
out << "dirlump " << dirfrag << " v " << fnode.version
<< " state " << state
<< " num " << nfull << "/" << nremote << "/" << nnull
<< std::endl;
_decode_bits();
- for (list<std::shared_ptr<fullbit> >::iterator p = dfull.begin(); p != dfull.end(); ++p)
- (*p)->print(out);
- for (list<remotebit>::iterator p = dremote.begin(); p != dremote.end(); ++p)
- p->print(out);
- for (list<nullbit>::iterator p = dnull.begin(); p != dnull.end(); ++p)
- p->print(out);
+ for (const auto& p : dfull)
+ p.print(out);
+ for (const auto& p : dremote)
+ p.print(out);
+ for (const auto& p : dnull)
+ p.print(out);
}
string state_string() const {
WRITE_CLASS_ENCODER_FEATURES(dirlump)
// my lumps. preserve the order we added them in a list.
- list<dirfrag_t> lump_order;
+ vector<dirfrag_t> lump_order;
map<dirfrag_t, dirlump> lump_map;
- list<std::shared_ptr<fullbit> > roots;
+ list<fullbit> roots;
public:
-
list<pair<__u8,version_t> > table_tids; // tableclient transactions
+
vector<pair<__u8,version_t> > table_tids; // tableclient transactions
inodeno_t opened_ino;
public:
inodeno_t renamed_dirino;
- list<frag_t> renamed_dir_frags;
+ vector<frag_t> renamed_dir_frags;
private:
// ino (pre)allocation. may involve both inotable AND session state.
entity_name_t client_name; // session
// inodes i've truncated
- list<inodeno_t> truncate_start; // start truncate
+ vector<inodeno_t> truncate_start; // start truncate
map<inodeno_t, log_segment_seq_t> truncate_finish; // finished truncate (started in segment blah)
public:
private:
// idempotent op(s)
-
list<pair<metareqid_t,uint64_t> > client_reqs;
-
list<pair<metareqid_t,uint64_t> > client_flushes;
+
vector<pair<metareqid_t,uint64_t> > client_reqs;
+
vector<pair<metareqid_t,uint64_t> > client_flushes;
public:
void encode(bufferlist& bl, uint64_t features) const;
inotablev(0), sessionmapv(0), allocated_ino(0),
last_subtree_map(0), event_seq(0)
{}
+ EMetaBlob(const EMetaBlob&) = delete;
~EMetaBlob() { }
+ EMetaBlob& operator=(const EMetaBlob&) = delete;
void print(ostream& out) {
- for (list<dirfrag_t>::iterator p = lump_order.begin();
- p != lump_order.end();
- ++p) {
- lump_map[*p].print(*p, out);
- }
+ for (const auto &p : lump_order)
+ lump_map[p].print(p, out);
}
void add_client_req(metareqid_t r, uint64_t tid=0) {
void add_null_dentry(dirlump& lump, CDentry *dn, bool dirty) {
// add the dir
lump.nnull++;
- lump.add_dnull(nullbit(dn->get_name(),
- dn->first, dn->last,
- dn->get_projected_version(),
- dirty));
+ lump.add_dnull(dn->get_name(), dn->first, dn->last,
+ dn->get_projected_version(), dirty);
}
void add_remote_dentry(CDentry *dn, bool dirty) {
rdt = dn->get_projected_linkage()->get_remote_d_type();
}
lump.nremote++;
- lump.add_dremote(remotebit(dn->get_name(),
- dn->first, dn->last,
- dn->get_projected_version(),
- rino, rdt,
- dirty));
+ lump.add_dremote(dn->get_name(), dn->first, dn->last,
+ dn->get_projected_version(), rino, rdt, dirty);
}
// return remote pointer to to-be-journaled inode
sr->encode(snapbl);
lump.nfull++;
- lump.add_dfull(std::shared_ptr<fullbit>(new fullbit(dn->get_name(),
- dn->first, dn->last,
- dn->get_projected_version(),
- *pi, in->dirfragtree,
- *in->get_projected_xattrs(),
- in->symlink,
- in->oldest_snap, snapbl,
- state, &in->old_inodes)));
+ lump.add_dfull(dn->get_name(), dn->first, dn->last, dn->get_projected_version(),
+ *pi, in->dirfragtree, *in->get_projected_xattrs(), in->symlink,
+ in->oldest_snap, snapbl, state, &in->old_inodes);
}
// convenience: primary or remote? figure it out.
if (sr)
sr->encode(snapbl);
- for (list<std::shared_ptr<fullbit> >::iterator p = roots.begin(); p != roots.end(); ++p) {
- if ((*p)->inode.ino == in->ino()) {
+ for (auto p = roots.begin(); p != roots.end(); ++p) {
+ if (p->inode.ino == in->ino()) {
roots.erase(p);
break;
}
}
string empty;
- roots.push_back(std::shared_ptr<fullbit>(new fullbit(empty, in->first, in->last, 0, pi,
- pdft, px, in->symlink,
- in->oldest_snap, snapbl,
- dirty ? fullbit::STATE_DIRTY : 0,
- &in->old_inodes)));
+ roots.emplace_back(empty, in->first, in->last, 0, pi, pdft, px, in->symlink,
+ in->oldest_snap, snapbl, (dirty ? fullbit::STATE_DIRTY : 0),
+ &in->old_inodes);
}
dirlump& add_dir(CDir *dir, bool dirty, bool complete=false) {
f->dump_int("nnull", nnull);
f->open_array_section("full bits");
- for (list<std::shared_ptr<fullbit> >::const_iterator
- iter = dfull.begin(); iter != dfull.end(); ++iter) {
+ for (const auto& iter : dfull) {
f->open_object_section("fullbit");
- (*iter)->dump(f);
+ iter.dump(f);
f->close_section(); // fullbit
}
f->close_section(); // full bits
f->open_array_section("remote bits");
- for (list<remotebit>::const_iterator
- iter = dremote.begin(); iter != dremote.end(); ++iter) {
+ for (const auto& iter : dremote) {
f->open_object_section("remotebit");
- (*iter).dump(f);
+ iter.dump(f);
f->close_section(); // remotebit
}
f->close_section(); // remote bits
f->open_array_section("null bits");
- for (list<nullbit>::const_iterator
- iter = dnull.begin(); iter != dnull.end(); ++iter) {
+ for (const auto& iter : dnull) {
f->open_object_section("null bit");
- (*iter).dump(f);
+ iter.dump(f);
f->close_section(); // null bit
}
f->close_section(); // null bits
decode(rootbl, bl);
if (rootbl.length()) {
auto p = rootbl.cbegin();
- roots.push_back(std::shared_ptr<fullbit>(new fullbit(p)));
+ roots.emplace_back(p);
}
}
decode(table_tids, bl);
dl._decode_bits();
// Record inodes of fullbits
- list<std::shared_ptr<fullbit> > const &fb_list = dl.get_dfull();
- for (list<std::shared_ptr<fullbit> >::const_iterator
- iter = fb_list.begin(); iter != fb_list.end(); ++iter) {
- inodes.insert((*iter)->inode.ino);
+ for (const auto& iter : dl.get_dfull()) {
+ inodes.insert(iter.inode.ino);
}
// Record inodes of remotebits
- list<remotebit> const &rb_list = dl.get_dremote();
- for (list<remotebit>::const_iterator
- iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- inodes.insert(iter->ino);
+ for (const auto& iter : dl.get_dremote()) {
+ inodes.insert(iter.ino);
}
}
}
// Get all bits
dl._decode_bits();
- list<std::shared_ptr<fullbit> > const &fb_list = dl.get_dfull();
- list<nullbit> const &nb_list = dl.get_dnull();
- list<remotebit> const &rb_list = dl.get_dremote();
// For all bits, store dentry
- for (list<std::shared_ptr<fullbit> >::const_iterator
- iter = fb_list.begin(); iter != fb_list.end(); ++iter) {
- dentries[df].insert((*iter)->dn);
-
+ for (const auto& iter : dl.get_dfull()) {
+ dentries[df].insert(iter.dn);
}
- for (list<nullbit>::const_iterator
- iter = nb_list.begin(); iter != nb_list.end(); ++iter) {
- dentries[df].insert(iter->dn);
+ for (const auto& iter : dl.get_dremote()) {
+ dentries[df].insert(iter.dn);
}
- for (list<remotebit>::const_iterator
- iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- dentries[df].insert(iter->dn);
+ for (const auto& iter : dl.get_dnull()) {
+ dentries[df].insert(iter.dn);
}
}
}
dirlump const &dl = i->second;
dl._decode_bits();
- list<std::shared_ptr<fullbit> > const &fb_list = dl.get_dfull();
- list<nullbit> const &nb_list = dl.get_dnull();
- list<remotebit> const &rb_list = dl.get_dremote();
-
- for (list<std::shared_ptr<fullbit> >::const_iterator
- iter = fb_list.begin(); iter != fb_list.end(); ++iter) {
- std::string_view dentry = (*iter)->dn;
+ for (const auto& iter : dl.get_dfull()) {
+ std::string_view dentry = iter.dn;
children[dir_ino].emplace_back(dentry);
- ino_locations[(*iter)->inode.ino] = Location(dir_ino, dentry);
+ ino_locations[iter.inode.ino] = Location(dir_ino, dentry);
}
- for (list<nullbit>::const_iterator
- iter = nb_list.begin(); iter != nb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ for (const auto& iter : dl.get_dremote()) {
+ std::string_view dentry = iter.dn;
children[dir_ino].emplace_back(dentry);
}
- for (list<remotebit>::const_iterator
- iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ for (const auto& iter : dl.get_dnull()) {
+ std::string_view dentry = iter.dn;
children[dir_ino].emplace_back(dentry);
}
}
dirlump const &dl = i->second;
dl._decode_bits();
- list<std::shared_ptr<fullbit> > const &fb_list = dl.get_dfull();
- for (list<std::shared_ptr<fullbit> >::const_iterator
- iter = fb_list.begin(); iter != fb_list.end(); ++iter) {
- std::string_view dentry = (*iter)->dn;
- if (children.find((*iter)->inode.ino) == children.end()) {
+ for (const auto& iter : dl.get_dfull()) {
+ std::string_view dentry = iter.dn;
+ if (children.find(iter.inode.ino) == children.end()) {
leaf_locations.push_back(Location(dir_ino, dentry));
}
}
- list<nullbit> const &nb_list = dl.get_dnull();
- for (list<nullbit>::const_iterator
- iter = nb_list.begin(); iter != nb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ for (const auto& iter : dl.get_dremote()) {
+ std::string_view dentry = iter.dn;
leaf_locations.push_back(Location(dir_ino, dentry));
}
- list<remotebit> const &rb_list = dl.get_dremote();
- for (list<remotebit>::const_iterator
- iter = rb_list.begin(); iter != rb_list.end(); ++iter) {
- std::string_view dentry = iter->dn;
+ for (const auto& iter : dl.get_dnull()) {
+ std::string_view dentry = iter.dn;
leaf_locations.push_back(Location(dir_ino, dentry));
}
}
void EMetaBlob::dump(Formatter *f) const
{
f->open_array_section("lumps");
- for (list<dirfrag_t>::const_iterator i = lump_order.begin();
- i != lump_order.end(); ++i) {
+ for (const auto& d : lump_order) {
f->open_object_section("lump");
f->open_object_section("dirfrag");
- f->dump_stream("dirfrag") << *i;
+ f->dump_stream("dirfrag") << d;
f->close_section(); // dirfrag
f->open_object_section("dirlump");
- lump_map.at(*i).dump(f);
+ lump_map.at(d).dump(f);
f->close_section(); // dirlump
f->close_section(); // lump
}
f->close_section(); // lumps
f->open_array_section("roots");
- for (list<std::shared_ptr<fullbit> >::const_iterator i = roots.begin();
- i != roots.end(); ++i) {
+ for (const auto& iter : roots) {
f->open_object_section("root");
- (*i)->dump(f);
+ iter.dump(f);
f->close_section(); // root
}
f->close_section(); // roots
f->open_array_section("tableclient tranactions");
- for (list<pair<__u8,version_t> >::const_iterator i = table_tids.begin();
- i != table_tids.end(); ++i) {
+ for (const auto& p : table_tids) {
f->open_object_section("transaction");
- f->dump_int("tid", i->first);
- f->dump_int("version", i->second);
+ f->dump_int("tid", p.first);
+ f->dump_int("version", p.second);
f->close_section(); // transaction
}
f->close_section(); // tableclient transactions
f->dump_int("renamed directory inodeno", renamed_dirino);
f->open_array_section("renamed directory fragments");
- for (list<frag_t>::const_iterator i = renamed_dir_frags.begin();
- i != renamed_dir_frags.end(); ++i) {
- f->dump_int("frag", *i);
+ for (const auto& p : renamed_dir_frags) {
+ f->dump_int("frag", p);
}
f->close_section(); // renamed directory fragments
f->close_section(); // client name
f->open_array_section("inodes starting a truncate");
- for(list<inodeno_t>::const_iterator i = truncate_start.begin();
- i != truncate_start.end(); ++i) {
- f->dump_int("inodeno", *i);
+ for(const auto& ino : truncate_start) {
+ f->dump_int("inodeno", ino);
}
f->close_section(); // truncate inodes
f->open_array_section("inodes finishing a truncated");
- for(map<inodeno_t,uint64_t>::const_iterator i = truncate_finish.begin();
- i != truncate_finish.end(); ++i) {
+ for(const auto& p : truncate_finish) {
f->open_object_section("inode+segment");
- f->dump_int("inodeno", i->first);
- f->dump_int("truncate starting segment", i->second);
+ f->dump_int("inodeno", p.first);
+ f->dump_int("truncate starting segment", p.second);
f->close_section(); // truncated inode
}
f->close_section(); // truncate finish inodes
f->close_section(); // destroyed inodes
f->open_array_section("client requests");
- for(list<pair<metareqid_t,uint64_t> >::const_iterator i = client_reqs.begin();
- i != client_reqs.end(); ++i) {
+ for(const auto& p : client_reqs) {
f->open_object_section("Client request");
- f->dump_stream("request ID") << i->first;
- f->dump_int("oldest request on client", i->second);
+ f->dump_stream("request ID") << p.first;
+ f->dump_int("oldest request on client", p.second);
f->close_section(); // request
}
f->close_section(); // client requests
ceph_assert(g_conf()->mds_kill_journal_replay_at != 1);
- for (list<std::shared_ptr<fullbit> >::iterator p = roots.begin(); p != roots.end(); ++p) {
- CInode *in = mds->mdcache->get_inode((*p)->inode.ino);
+ for (auto& p : roots) {
+ CInode *in = mds->mdcache->get_inode(p.inode.ino);
bool isnew = in ? false:true;
if (!in)
- in = new CInode(mds->mdcache, false);
- (*p)->update_inode(mds, in);
+ in = new CInode(mds->mdcache, false, 2, CEPH_NOSNAP);
+ p.update_inode(mds, in);
if (isnew)
mds->mdcache->add_inode(in);
- if ((*p)->is_dirty()) in->_mark_dirty(logseg);
+ if (p.is_dirty()) in->_mark_dirty(logseg);
dout(10) << "EMetaBlob.replay " << (isnew ? " added root ":" updated root ") << *in << dendl;
}
dout(10) << "EMetaBlob.replay don't have renamed ino " << renamed_dirino << dendl;
int nnull = 0;
- for (list<dirfrag_t>::iterator lp = lump_order.begin(); lp != lump_order.end(); ++lp) {
- dirlump &lump = lump_map[*lp];
+ for (const auto& lp : lump_order) {
+ dirlump &lump = lump_map[lp];
if (lump.nnull) {
- dout(10) << "EMetaBlob.replay found null dentry in dir " << *lp << dendl;
+ dout(10) << "EMetaBlob.replay found null dentry in dir " << lp << dendl;
nnull += lump.nnull;
}
}
set<CInode*> linked;
// walk through my dirs (in order!)
- for (list<dirfrag_t>::iterator lp = lump_order.begin();
- lp != lump_order.end();
- ++lp) {
- dout(10) << "EMetaBlob.replay dir " << *lp << dendl;
- dirlump &lump = lump_map[*lp];
+ for (const auto& lp : lump_order) {
+ dout(10) << "EMetaBlob.replay dir " << lp << dendl;
+ dirlump &lump = lump_map[lp];
// the dir
- CDir *dir = mds->mdcache->get_force_dirfrag(*lp, true);
+ CDir *dir = mds->mdcache->get_force_dirfrag(lp, true);
if (!dir) {
// hmm. do i have the inode?
- CInode *diri = mds->mdcache->get_inode((*lp).ino);
+ CInode *diri = mds->mdcache->get_inode((lp).ino);
if (!diri) {
- if (MDS_INO_IS_MDSDIR(lp->ino)) {
- ceph_assert(MDS_INO_MDSDIR(mds->get_nodeid()) != lp->ino);
- diri = mds->mdcache->create_system_inode(lp->ino, S_IFDIR|0755);
+ if (MDS_INO_IS_MDSDIR(lp.ino)) {
+ ceph_assert(MDS_INO_MDSDIR(mds->get_nodeid()) != lp.ino);
+ diri = mds->mdcache->create_system_inode(lp.ino, S_IFDIR|0755);
diri->state_clear(CInode::STATE_AUTH);
dout(10) << "EMetaBlob.replay created base " << *diri << dendl;
} else {
- dout(0) << "EMetaBlob.replay missing dir ino " << (*lp).ino << dendl;
+ dout(0) << "EMetaBlob.replay missing dir ino " << lp.ino << dendl;
mds->clog->error() << "failure replaying journal (EMetaBlob)";
mds->damaged();
ceph_abort(); // Should be unreachable because damaged() calls respawn()
}
// create the dirfrag
- dir = diri->get_or_open_dirfrag(mds->mdcache, (*lp).frag);
+ dir = diri->get_or_open_dirfrag(mds->mdcache, lp.frag);
- if (MDS_INO_IS_BASE(lp->ino))
+ if (MDS_INO_IS_BASE(lp.ino))
mds->mdcache->adjust_subtree_auth(dir, CDIR_AUTH_UNDEF);
dout(10) << "EMetaBlob.replay added dir " << *dir << dendl;
lump._decode_bits();
// full dentry+inode pairs
- for (list<std::shared_ptr<fullbit> >::const_iterator pp = lump.get_dfull().begin();
- pp != lump.get_dfull().end();
- ++pp) {
- std::shared_ptr<fullbit> p = *pp;
- CDentry *dn = dir->lookup_exact_snap(p->dn, p->dnlast);
+ for (auto& fb : lump._get_dfull()) {
+ CDentry *dn = dir->lookup_exact_snap(fb.dn, fb.dnlast);
if (!dn) {
- dn = dir->add_null_dentry(p->dn, p->dnfirst, p->dnlast);
- dn->set_version(p->dnv);
- if (p->is_dirty()) dn->_mark_dirty(logseg);
+ dn = dir->add_null_dentry(fb.dn, fb.dnfirst, fb.dnlast);
+ dn->set_version(fb.dnv);
+ if (fb.is_dirty()) dn->_mark_dirty(logseg);
dout(10) << "EMetaBlob.replay added (full) " << *dn << dendl;
} else {
- dn->set_version(p->dnv);
- if (p->is_dirty()) dn->_mark_dirty(logseg);
- dout(10) << "EMetaBlob.replay for [" << p->dnfirst << "," << p->dnlast << "] had " << *dn << dendl;
- dn->first = p->dnfirst;
- ceph_assert(dn->last == p->dnlast);
+ dn->set_version(fb.dnv);
+ if (fb.is_dirty()) dn->_mark_dirty(logseg);
+ dout(10) << "EMetaBlob.replay for [" << fb.dnfirst << "," << fb.dnlast << "] had " << *dn << dendl;
+ dn->first = fb.dnfirst;
+ ceph_assert(dn->last == fb.dnlast);
}
if (lump.is_importing())
dn->state_set(CDentry::STATE_AUTH);
- CInode *in = mds->mdcache->get_inode(p->inode.ino, p->dnlast);
+ CInode *in = mds->mdcache->get_inode(fb.inode.ino, fb.dnlast);
if (!in) {
- in = new CInode(mds->mdcache, dn->is_auth(), p->dnfirst, p->dnlast);
- p->update_inode(mds, in);
+ in = new CInode(mds->mdcache, dn->is_auth(), fb.dnfirst, fb.dnlast);
+ fb.update_inode(mds, in);
mds->mdcache->add_inode(in);
if (!dn->get_linkage()->is_null()) {
if (dn->get_linkage()->is_primary()) {
unlinked[dn->get_linkage()->get_inode()] = dir;
stringstream ss;
ss << "EMetaBlob.replay FIXME had dentry linked to wrong inode " << *dn
- << " " << *dn->get_linkage()->get_inode() << " should be " << p->inode.ino;
+ << " " << *dn->get_linkage()->get_inode() << " should be " << fb.inode.ino;
dout(0) << ss.str() << dendl;
mds->clog->warn(ss);
}
dir->link_primary_inode(dn, in);
dout(10) << "EMetaBlob.replay added " << *in << dendl;
} else {
- in->first = p->dnfirst;
- p->update_inode(mds, in);
+ in->first = fb.dnfirst;
+ fb.update_inode(mds, in);
if (dn->get_linkage()->get_inode() != in && in->get_parent_dn()) {
dout(10) << "EMetaBlob.replay unlinking " << *in << dendl;
unlinked[in] = in->get_parent_dir();
unlinked[dn->get_linkage()->get_inode()] = dir;
stringstream ss;
ss << "EMetaBlob.replay FIXME had dentry linked to wrong inode " << *dn
- << " " << *dn->get_linkage()->get_inode() << " should be " << p->inode.ino;
+ << " " << *dn->get_linkage()->get_inode() << " should be " << fb.inode.ino;
dout(0) << ss.str() << dendl;
mds->clog->warn(ss);
}
dir->link_primary_inode(dn, in);
dout(10) << "EMetaBlob.replay linked " << *in << dendl;
} else {
- dout(10) << "EMetaBlob.replay for [" << p->dnfirst << "," << p->dnlast << "] had " << *in << dendl;
+ dout(10) << "EMetaBlob.replay for [" << fb.dnfirst << "," << fb.dnlast << "] had " << *in << dendl;
}
- ceph_assert(in->first == p->dnfirst ||
- (in->is_multiversion() && in->first > p->dnfirst));
+ ceph_assert(in->first == fb.dnfirst ||
+ (in->is_multiversion() && in->first > fb.dnfirst));
}
- if (p->is_dirty())
+ if (fb.is_dirty())
in->_mark_dirty(logseg);
- if (p->is_dirty_parent())
- in->mark_dirty_parent(logseg, p->is_dirty_pool());
- if (p->need_snapflush())
+ if (fb.is_dirty_parent())
+ in->mark_dirty_parent(logseg, fb.is_dirty_pool());
+ if (fb.need_snapflush())
logseg->open_files.push_back(&in->item_open_file);
if (dn->is_auth())
in->state_set(CInode::STATE_AUTH);
}
// remote dentries
- for (list<remotebit>::const_iterator p = lump.get_dremote().begin();
- p != lump.get_dremote().end();
- ++p) {
- CDentry *dn = dir->lookup_exact_snap(p->dn, p->dnlast);
+ for (const auto& rb : lump.get_dremote()) {
+ CDentry *dn = dir->lookup_exact_snap(rb.dn, rb.dnlast);
if (!dn) {
- dn = dir->add_remote_dentry(p->dn, p->ino, p->d_type, p->dnfirst, p->dnlast);
- dn->set_version(p->dnv);
- if (p->dirty) dn->_mark_dirty(logseg);
+ dn = dir->add_remote_dentry(rb.dn, rb.ino, rb.d_type, rb.dnfirst, rb.dnlast);
+ dn->set_version(rb.dnv);
+ if (rb.dirty) dn->_mark_dirty(logseg);
dout(10) << "EMetaBlob.replay added " << *dn << dendl;
} else {
if (!dn->get_linkage()->is_null()) {
unlinked[dn->get_linkage()->get_inode()] = dir;
stringstream ss;
ss << "EMetaBlob.replay FIXME had dentry linked to wrong inode " << *dn
- << " " << *dn->get_linkage()->get_inode() << " should be remote " << p->ino;
+ << " " << *dn->get_linkage()->get_inode() << " should be remote " << rb.ino;
dout(0) << ss.str() << dendl;
}
dir->unlink_inode(dn, false);
}
- dir->link_remote_inode(dn, p->ino, p->d_type);
- dn->set_version(p->dnv);
- if (p->dirty) dn->_mark_dirty(logseg);
- dout(10) << "EMetaBlob.replay for [" << p->dnfirst << "," << p->dnlast << "] had " << *dn << dendl;
- dn->first = p->dnfirst;
- ceph_assert(dn->last == p->dnlast);
+ dir->link_remote_inode(dn, rb.ino, rb.d_type);
+ dn->set_version(rb.dnv);
+ if (rb.dirty) dn->_mark_dirty(logseg);
+ dout(10) << "EMetaBlob.replay for [" << rb.dnfirst << "," << rb.dnlast << "] had " << *dn << dendl;
+ dn->first = rb.dnfirst;
+ ceph_assert(dn->last == rb.dnlast);
}
if (lump.is_importing())
dn->state_set(CDentry::STATE_AUTH);
}
// null dentries
- for (list<nullbit>::const_iterator p = lump.get_dnull().begin();
- p != lump.get_dnull().end();
- ++p) {
- CDentry *dn = dir->lookup_exact_snap(p->dn, p->dnlast);
+ for (const auto& nb : lump.get_dnull()) {
+ CDentry *dn = dir->lookup_exact_snap(nb.dn, nb.dnlast);
if (!dn) {
- dn = dir->add_null_dentry(p->dn, p->dnfirst, p->dnlast);
- dn->set_version(p->dnv);
- if (p->dirty) dn->_mark_dirty(logseg);
+ dn = dir->add_null_dentry(nb.dn, nb.dnfirst, nb.dnlast);
+ dn->set_version(nb.dnv);
+ if (nb.dirty) dn->_mark_dirty(logseg);
dout(10) << "EMetaBlob.replay added (nullbit) " << *dn << dendl;
} else {
- dn->first = p->dnfirst;
+ dn->first = nb.dnfirst;
if (!dn->get_linkage()->is_null()) {
dout(10) << "EMetaBlob.replay unlinking " << *dn << dendl;
CInode *in = dn->get_linkage()->get_inode();
dir->unlink_inode(dn);
}
}
- dn->set_version(p->dnv);
- if (p->dirty) dn->_mark_dirty(logseg);
+ dn->set_version(nb.dnv);
+ if (nb.dirty) dn->_mark_dirty(logseg);
dout(10) << "EMetaBlob.replay had " << *dn << dendl;
- ceph_assert(dn->last == p->dnlast);
+ ceph_assert(dn->last == nb.dnlast);
}
olddir = dir;
if (lump.is_importing())
// if we are the srci importer, we'll also have some dirfrags we have to open up...
if (renamed_diri->authority() != CDIR_AUTH_UNDEF) {
- for (list<frag_t>::iterator p = renamed_dir_frags.begin(); p != renamed_dir_frags.end(); ++p) {
- CDir *dir = renamed_diri->get_dirfrag(*p);
+ for (const auto& p : renamed_dir_frags) {
+ CDir *dir = renamed_diri->get_dirfrag(p);
if (dir) {
// we already had the inode before, and we already adjusted this subtree accordingly.
dout(10) << " already had+adjusted rename import bound " << *dir << dendl;
ceph_assert(olddir);
continue;
}
- dir = renamed_diri->get_or_open_dirfrag(mds->mdcache, *p);
+ dir = renamed_diri->get_or_open_dirfrag(mds->mdcache, p);
dout(10) << " creating new rename import bound " << *dir << dendl;
dir->state_clear(CDir::STATE_AUTH);
mds->mdcache->adjust_subtree_auth(dir, CDIR_AUTH_UNDEF);
}
// table client transactions
- for (list<pair<__u8,version_t> >::iterator p = table_tids.begin();
- p != table_tids.end();
- ++p) {
- dout(10) << "EMetaBlob.replay noting " << get_mdstable_name(p->first)
- << " transaction " << p->second << dendl;
- MDSTableClient *client = mds->get_table_client(p->first);
+ for (const auto& p : table_tids) {
+ dout(10) << "EMetaBlob.replay noting " << get_mdstable_name(p.first)
+ << " transaction " << p.second << dendl;
+ MDSTableClient *client = mds->get_table_client(p.first);
if (client)
- client->got_journaled_agree(p->second, logseg);
+ client->got_journaled_agree(p.second, logseg);
}
// opened ino?
}
// truncating inodes
- for (list<inodeno_t>::iterator p = truncate_start.begin();
- p != truncate_start.end();
- ++p) {
- CInode *in = mds->mdcache->get_inode(*p);
+ for (const auto& ino : truncate_start) {
+ CInode *in = mds->mdcache->get_inode(ino);
ceph_assert(in);
mds->mdcache->add_recovered_truncate(in, logseg);
}
- for (map<inodeno_t,uint64_t>::iterator p = truncate_finish.begin();
- p != truncate_finish.end();
- ++p) {
- LogSegment *ls = mds->mdlog->get_segment(p->second);
+ for (const auto& p : truncate_finish) {
+ LogSegment *ls = mds->mdlog->get_segment(p.second);
if (ls) {
- CInode *in = mds->mdcache->get_inode(p->first);
+ CInode *in = mds->mdcache->get_inode(p.first);
ceph_assert(in);
mds->mdcache->remove_recovered_truncate(in, ls);
}
}
// client requests
- for (list<pair<metareqid_t, uint64_t> >::iterator p = client_reqs.begin();
- p != client_reqs.end();
- ++p) {
- if (p->first.name.is_client()) {
- dout(10) << "EMetaBlob.replay request " << p->first << " trim_to " << p->second << dendl;
+ for (const auto& p : client_reqs) {
+ if (p.first.name.is_client()) {
+ dout(10) << "EMetaBlob.replay request " << p.first << " trim_to " << p.second << dendl;
inodeno_t created = allocated_ino ? allocated_ino : used_preallocated_ino;
// if we allocated an inode, there should be exactly one client request id.
ceph_assert(created == inodeno_t() || client_reqs.size() == 1);
- Session *session = mds->sessionmap.get_session(p->first.name);
+ Session *session = mds->sessionmap.get_session(p.first.name);
if (session) {
- session->add_completed_request(p->first.tid, created);
- if (p->second)
- session->trim_completed_requests(p->second);
+ session->add_completed_request(p.first.tid, created);
+ if (p.second)
+ session->trim_completed_requests(p.second);
}
}
}
// client flushes
- for (list<pair<metareqid_t, uint64_t> >::iterator p = client_flushes.begin();
- p != client_flushes.end();
- ++p) {
- if (p->first.name.is_client()) {
- dout(10) << "EMetaBlob.replay flush " << p->first << " trim_to " << p->second << dendl;
- Session *session = mds->sessionmap.get_session(p->first.name);
+ for (const auto& p : client_flushes) {
+ if (p.first.name.is_client()) {
+ dout(10) << "EMetaBlob.replay flush " << p.first << " trim_to " << p.second << dendl;
+ Session *session = mds->sessionmap.get_session(p.first.name);
if (session) {
- session->add_completed_flush(p->first.tid);
- if (p->second)
- session->trim_completed_flushes(p->second);
+ session->add_completed_flush(p.first.tid);
+ if (p.second)
+ session->trim_completed_flushes(p.second);
}
}
}
{
bool modified = false;
map<inodeno_t, log_segment_seq_t> new_trunc_finish;
- for (std::map<inodeno_t, log_segment_seq_t>::iterator i = truncate_finish.begin();
- i != truncate_finish.end(); ++i) {
- if (old_to_new.count(i->second)) {
+ for (const auto& p : truncate_finish) {
+ auto q = old_to_new.find(p.second);
+ if (q != old_to_new.end()) {
dout(20) << __func__ << " applying segment seq mapping "
- << i->second << " -> " << old_to_new.find(i->second)->second << dendl;
- new_trunc_finish[i->first] = old_to_new.find(i->second)->second;
+ << p.second << " -> " << q->second << dendl;
+ new_trunc_finish.emplace(p.first, q->second);
modified = true;
} else {
dout(20) << __func__ << " no segment seq mapping found for "
- << i->second << dendl;
- new_trunc_finish[i->first] = i->second;
+ << p.second << dendl;
+ new_trunc_finish.insert(p);
}
}
- truncate_finish = new_trunc_finish;
+ truncate_finish.swap(new_trunc_finish);
return modified;
}
projects / ceph.git / commitdiff