frag_info_t frag_info;
nest_info_t nest_info;
- for (map_t::iterator i = items.begin(); i != items.end(); ++i) {
+ for (auto i = items.begin(); i != items.end(); ++i) {
if (i->second->last != CEPH_NOSNAP)
continue;
CDentry::linkage_t *dnl = i->second->get_linkage();
if (!good) {
if (!scrub) {
- for (map_t::iterator i = items.begin(); i != items.end(); ++i) {
+ for (auto i = items.begin(); i != items.end(); ++i) {
CDentry *dn = i->second;
if (dn->get_linkage()->is_primary()) {
CInode *in = dn->get_linkage()->inode;
CDentry *CDir::lookup(std::string_view name, snapid_t snap)
{
dout(20) << "lookup (" << snap << ", '" << name << "')" << dendl;
- map_t::iterator iter = items.lower_bound(dentry_key_t(snap, name,
- inode->hash_dentry_name(name)));
+ auto iter = items.lower_bound(dentry_key_t(snap, name, inode->hash_dentry_name(name)));
if (iter == items.end())
return 0;
if (iter->second->get_name() == name &&
}
CDentry *CDir::lookup_exact_snap(std::string_view name, snapid_t last) {
- map_t::iterator p = items.find(dentry_key_t(last, name,
- inode->hash_dentry_name(name)));
+ auto p = items.find(dentry_key_t(last, name, inode->hash_dentry_name(name)));
if (p == items.end())
return NULL;
return p->second;
void CDir::remove_null_dentries() {
dout(12) << __func__ << " " << *this << dendl;
- CDir::map_t::iterator p = items.begin();
+ auto p = items.begin();
while (p != items.end()) {
CDentry *dn = p->second;
++p;
// clear dirty only when the directory was not snapshotted
bool clear_dirty = !inode->snaprealm;
- CDir::map_t::iterator p = items.begin();
+ auto p = items.begin();
while (p != items.end()) {
CDentry *dn = p->second;
++p;
{
dout(10) << __func__ << " " << snaps << dendl;
- CDir::map_t::iterator p = items.begin();
+ auto p = items.begin();
while (p != items.end()) {
CDentry *dn = p->second;
++p;
auth_pin(this);
if (!waiting_on_dentry.empty()) {
- for (auto p = waiting_on_dentry.begin(); p != waiting_on_dentry.end(); ++p)
- dentry_waiters[p->first].swap(p->second);
+ for (const auto &p : waiting_on_dentry) {
+ auto &e = dentry_waiters[p.first];
+ for (const auto &waiter : p.second) {
+ e.push_back(waiter);
+ }
+ }
waiting_on_dentry.clear();
put(PIN_DNWAITER);
}
// repartition dentries
while (!items.empty()) {
- CDir::map_t::iterator p = items.begin();
+ auto p = items.begin();
CDentry *dn = p->second;
frag_t subfrag = inode->pick_dirfrag(dn->get_name());
f->steal_dentry(dn);
}
- for (auto& p : dentry_waiters) {
+ for (const auto &p : dentry_waiters) {
frag_t subfrag = inode->pick_dirfrag(p.first.name);
int n = (subfrag.value() & (subfrag.mask() ^ frag.mask())) >> subfrag.mask_shift();
CDir *f = subfrags[n];
if (f->waiting_on_dentry.empty())
f->get(PIN_DNWAITER);
- f->waiting_on_dentry[p.first].swap(p.second);
+ auto &e = f->waiting_on_dentry[p.first];
+ for (const auto &waiter : p.second) {
+ e.push_back(waiter);
+ }
}
// FIXME: handle dirty old rstat
if (!dentry_waiters.empty()) {
get(PIN_DNWAITER);
- for (auto& p : dentry_waiters) {
- waiting_on_dentry[p.first].swap(p.second);
+ for (const auto &p : dentry_waiters) {
+ auto &e = waiting_on_dentry[p.first];
+ for (const auto &waiter : p.second) {
+ e.push_back(waiter);
+ }
}
}
string_snap_t lb(dname, first);
string_snap_t ub(dname, last);
- compact_map<string_snap_t, list<MDSInternalContextBase*> >::iterator p = waiting_on_dentry.lower_bound(lb);
- while (p != waiting_on_dentry.end() &&
- !(ub < p->first)) {
+ auto it = waiting_on_dentry.lower_bound(lb);
+ while (it != waiting_on_dentry.end() &&
+ !(ub < it->first)) {
dout(10) << __func__ << " " << dname
<< " [" << first << "," << last << "] found waiter on snap "
- << p->first.snapid
+ << it->first.snapid
<< " on " << *this << dendl;
- ls.splice(ls.end(), p->second);
- waiting_on_dentry.erase(p++);
+ for (const auto &waiter : it->second) {
+ ls.push_back(waiter);
+ }
+ waiting_on_dentry.erase(it++);
}
if (waiting_on_dentry.empty())
{
dout(10) << __func__ << dendl;
if (!waiting_on_dentry.empty()) {
- for (compact_map<string_snap_t, list<MDSInternalContextBase*> >::iterator p = waiting_on_dentry.begin();
- p != waiting_on_dentry.end();
- ++p)
- ls.splice(ls.end(), p->second);
+ for (const auto &p : waiting_on_dentry) {
+ for (const auto &waiter : p.second) {
+ ls.push_back(waiter);
+ }
+ }
waiting_on_dentry.clear();
put(PIN_DNWAITER);
}
{
if ((mask & WAIT_DENTRY) && !waiting_on_dentry.empty()) {
// take all dentry waiters
- while (!waiting_on_dentry.empty()) {
- compact_map<string_snap_t, list<MDSInternalContextBase*> >::iterator p = waiting_on_dentry.begin();
- dout(10) << "take_waiting dentry " << p->first.name
- << " snap " << p->first.snapid << " on " << *this << dendl;
- ls.splice(ls.end(), p->second);
- waiting_on_dentry.erase(p);
+ for (const auto &p : waiting_on_dentry) {
+ dout(10) << "take_waiting dentry " << p.first.name
+ << " snap " << p.first.snapid << " on " << *this << dendl;
+ for (const auto &waiter : p.second) {
+ ls.push_back(waiter);
+ }
}
+ waiting_on_dentry.clear();
put(PIN_DNWAITER);
}
fnode_t *CDir::project_fnode()
{
assert(get_version() != 0);
- fnode_t *p = new fnode_t;
- *p = *get_projected_fnode();
- projected_fnode.push_back(p);
+ auto &p = projected_fnode.emplace_back(*get_projected_fnode());
if (scrub_infop && scrub_infop->last_scrub_dirty) {
- p->localized_scrub_stamp = scrub_infop->last_local.time;
- p->localized_scrub_version = scrub_infop->last_local.version;
- p->recursive_scrub_stamp = scrub_infop->last_recursive.time;
- p->recursive_scrub_version = scrub_infop->last_recursive.version;
+ p.localized_scrub_stamp = scrub_infop->last_local.time;
+ p.localized_scrub_version = scrub_infop->last_local.version;
+ p.recursive_scrub_stamp = scrub_infop->last_recursive.time;
+ p.recursive_scrub_version = scrub_infop->last_recursive.version;
scrub_infop->last_scrub_dirty = false;
scrub_maybe_delete_info();
}
- dout(10) << __func__ << " " << p << dendl;
- return p;
+ dout(10) << __func__ << " " << &p << dendl;
+ return &p;
}
void CDir::pop_and_dirty_projected_fnode(LogSegment *ls)
{
assert(!projected_fnode.empty());
- dout(15) << __func__ << " " << projected_fnode.front()
- << " v" << projected_fnode.front()->version << dendl;
- fnode = *projected_fnode.front();
+ auto &front = projected_fnode.front();
+ dout(15) << __func__ << " " << &front << " v" << front.version << dendl;
+ fnode = front;
_mark_dirty(ls);
- delete projected_fnode.front();
projected_fnode.pop_front();
}
}
if (c) add_waiter(WAIT_COMPLETE, c);
- if (!want_dn.empty()) wanted_items.insert(std::string(want_dn));
+ if (!want_dn.empty()) wanted_items.insert(mempool::mds_co::string(want_dn));
// already fetching?
if (state_test(CDir::STATE_FETCHING)) {
} else {
assert(c);
std::set<std::string> str_keys;
- for (auto p = keys.begin(); p != keys.end(); ++p) {
+ for (auto p : keys) {
string str;
- p->encode(str);
+ p.encode(str);
str_keys.insert(str);
}
rd.omap_get_vals_by_keys(str_keys, &fin->omap, &fin->ret2);
if (stale) {
if (!dn) {
- stale_items.insert(std::string(key));
+ stale_items.insert(mempool::mds_co::string(key));
*force_dirty = true;
}
return dn;
if (stale) {
if (!dn) {
- stale_items.insert(std::string(key));
+ stale_items.insert(mempool::mds_co::string(key));
*force_dirty = true;
}
return dn;
continue;
}
- if (dn && (wanted_items.count(dname) > 0 || !complete)) {
+ if (dn && (wanted_items.count(mempool::mds_co::string(dname)) > 0 || !complete)) {
dout(10) << " touching wanted dn " << *dn << dendl;
inode->mdcache->touch_dentry(dn);
}
object_locator_t oloc(cache->mds->mdsmap->get_metadata_pool());
if (!stale_items.empty()) {
- for (compact_set<string>::iterator p = stale_items.begin();
- p != stale_items.end();
- ++p) {
- to_remove.insert(*p);
- write_size += (*p).length();
+ for (const auto &p : stale_items) {
+ to_remove.insert(std::string(p));
+ write_size += p.length();
}
stale_items.clear();
}
// finishers?
bool were_waiters = !waiting_for_commit.empty();
- compact_map<version_t, list<MDSInternalContextBase*> >::iterator p = waiting_for_commit.begin();
- while (p != waiting_for_commit.end()) {
- compact_map<version_t, list<MDSInternalContextBase*> >::iterator n = p;
- ++n;
- if (p->first > committed_version) {
- dout(10) << " there are waiters for " << p->first << ", committing again" << dendl;
- _commit(p->first, -1);
+ auto it = waiting_for_commit.begin();
+ while (it != waiting_for_commit.end()) {
+ auto _it = it;
+ ++_it;
+ if (it->first > committed_version) {
+ dout(10) << " there are waiters for " << it->first << ", committing again" << dendl;
+ _commit(it->first, -1);
break;
}
- cache->mds->queue_waiters(p->second);
- waiting_for_commit.erase(p);
- p = n;
+ std::list<MDSInternalContextBase*> t;
+ for (const auto &waiter : it->second)
+ t.push_back(waiter);
+ cache->mds->queue_waiters(t);
+ waiting_for_commit.erase(it);
+ it = _it;
}
// try drop dentries in this dirfrag if it's about to be purged
frag_info_t c;
memset(&c, 0, sizeof(c));
- for (map_t::iterator it = items.begin();
+ for (auto it = items.begin();
it != items.end();
++it) {
CDentry *dn = it->second;
scrub_infop->others_scrubbing.clear();
scrub_infop->others_scrubbed.clear();
- for (map_t::iterator i = items.begin();
+ for (auto i = items.begin();
i != items.end();
++i) {
// TODO: handle snapshot scrubbing
scrub_infop->last_scrub_dirty = true;
}
-int CDir::_next_dentry_on_set(set<dentry_key_t>& dns, bool missing_okay,
+int CDir::_next_dentry_on_set(dentry_key_set &dns, bool missing_okay,
MDSInternalContext *cb, CDentry **dnout)
{
dentry_key_t dnkey;
#include <string>
#include <string_view>
-#include "include/counter.h"
-#include "include/types.h"
-#include "include/buffer_fwd.h"
+#include "common/DecayCounter.h"
#include "common/bloom_filter.hpp"
#include "common/config.h"
-#include "common/DecayCounter.h"
-
-#include "MDSCacheObject.h"
-
+#include "include/buffer_fwd.h"
+#include "include/counter.h"
+#include "include/types.h"
#include "CInode.h"
+#include "MDSCacheObject.h"
class CDentry;
class MDCache;
fnode_t fnode;
snapid_t first;
- compact_map<snapid_t,old_rstat_t> dirty_old_rstat; // [value.first,key]
+ mempool::mds_co::compact_map<snapid_t,old_rstat_t> dirty_old_rstat; // [value.first,key]
// my inodes with dirty rstat data
elist<CInode*> dirty_rstat_inodes;
protected:
version_t projected_version;
- std::list<fnode_t*> projected_fnode;
+ mempool::mds_co::list<fnode_t> projected_fnode;
public:
elist<CDentry*> dirty_dentries;
if (projected_fnode.empty())
return &fnode;
else
- return projected_fnode.back();
+ return &projected_fnode.back();
}
fnode_t *get_projected_fnode() {
if (projected_fnode.empty())
return &fnode;
else
- return projected_fnode.back();
+ return &projected_fnode.back();
}
fnode_t *project_fnode();
void log_mark_dirty();
public:
- typedef std::map<dentry_key_t, CDentry*> map_t;
+ typedef mempool::mds_co::map<dentry_key_t, CDentry*> dentry_key_map;
+ typedef mempool::mds_co::set<dentry_key_t> dentry_key_set;
class scrub_info_t {
public:
/// inodes we contain with dirty scrub stamps
- map<dentry_key_t,CInode*> dirty_scrub_stamps; // TODO: make use of this!
+ dentry_key_map dirty_scrub_stamps; // TODO: make use of this!
struct scrub_stamps {
version_t version;
utime_t time;
bool pending_scrub_error;
/// these are lists of children in each stage of scrubbing
- set<dentry_key_t> directories_to_scrub;
- set<dentry_key_t> directories_scrubbing;
- set<dentry_key_t> directories_scrubbed;
- set<dentry_key_t> others_to_scrub;
- set<dentry_key_t> others_scrubbing;
- set<dentry_key_t> others_scrubbed;
+ dentry_key_set directories_to_scrub;
+ dentry_key_set directories_scrubbing;
+ dentry_key_set directories_scrubbed;
+ dentry_key_set others_to_scrub;
+ dentry_key_set others_scrubbing;
+ dentry_key_set others_scrubbed;
ScrubHeaderRefConst header;
* list will be filled with all CDentry * which have been returned
* from scrub_dentry_next() but not sent back via scrub_dentry_finished().
*/
- void scrub_dentries_scrubbing(list<CDentry*> *out_dentries);
+ void scrub_dentries_scrubbing(std::list<CDentry*> *out_dentries);
/**
* Report to the CDir that a CDentry has been scrubbed. Call this
* for every CDentry returned from scrub_dentry_next().
* Check the given set (presumably one of those in scrub_info_t) for the
* next key to scrub and look it up (or fail!).
*/
- int _next_dentry_on_set(set<dentry_key_t>& dns, bool missing_okay,
+ int _next_dentry_on_set(dentry_key_set &dns, bool missing_okay,
MDSInternalContext *cb, CDentry **dnout);
protected:
- std::unique_ptr<scrub_info_t> scrub_infop;
+ std::unique_ptr<scrub_info_t> scrub_infop; // FIXME not in mempool
// contents of this directory
- map_t items; // non-null AND null
+ dentry_key_map items; // non-null AND null
unsigned num_head_items;
unsigned num_head_null;
unsigned num_snap_items;
version_t committing_version;
version_t committed_version;
- compact_set<string> stale_items;
+ mempool::mds_co::compact_set<mempool::mds_co::string> stale_items;
// lock nesting, freeze
static int num_frozen_trees;
// cache control (defined for authority; hints for replicas)
__s32 dir_rep;
- compact_set<__s32> dir_rep_by; // if dir_rep == REP_LIST
+ mempool::mds_co::compact_set<__s32> dir_rep_by; // if dir_rep == REP_LIST
// popularity
dirfrag_load_vec_t pop_me;
friend class C_IO_Dir_OMAP_FetchedMore;
friend class C_IO_Dir_Committed;
- std::unique_ptr<bloom_filter> bloom;
+ std::unique_ptr<bloom_filter> bloom; // XXX not part of mempool::mds_co
/* If you set up the bloom filter, you must keep it accurate!
* It's deleted when you mark_complete() and is deliberately not serialized.*/
const CInode *get_inode() const { return inode; }
CDir *get_parent_dir() { return inode->get_parent_dir(); }
- map_t::iterator begin() { return items.begin(); }
- map_t::iterator end() { return items.end(); }
- map_t::iterator lower_bound(dentry_key_t key) { return items.lower_bound(key); }
+ dentry_key_map::iterator begin() { return items.begin(); }
+ dentry_key_map::iterator end() { return items.end(); }
+ dentry_key_map::iterator lower_bound(dentry_key_t key) { return items.lower_bound(key); }
unsigned get_num_head_items() const { return num_head_items; }
unsigned get_num_head_null() const { return num_head_null; }
public:
- void split(int bits, list<CDir*>& subs, list<MDSInternalContextBase*>& waiters, bool replay);
- void merge(list<CDir*>& subs, list<MDSInternalContextBase*>& waiters, bool replay);
+ void split(int bits, std::list<CDir*>& subs, list<MDSInternalContextBase*>& waiters, bool replay);
+ void merge(std::list<CDir*>& subs, std::list<MDSInternalContextBase*>& waiters, bool replay);
bool should_split() const {
return (int)get_frag_size() > g_conf->mds_bal_split_size;
void prepare_new_fragment(bool replay);
void prepare_old_fragment(map<string_snap_t, std::list<MDSInternalContextBase*> >& dentry_waiters, bool replay);
void steal_dentry(CDentry *dn); // from another dir. used by merge/split.
- void finish_old_fragment(list<MDSInternalContextBase*>& waiters, bool replay);
+ void finish_old_fragment(std::list<MDSInternalContextBase*>& waiters, bool replay);
void init_fragment_pins();
void fetch(MDSInternalContextBase *c, std::string_view want_dn, bool ignore_authpinnability=false);
void fetch(MDSInternalContextBase *c, const std::set<dentry_key_t>& keys);
protected:
- compact_set<string> wanted_items;
+ mempool::mds_co::compact_set<mempool::mds_co::string> wanted_items;
void _omap_fetch(MDSInternalContextBase *fin, const std::set<dentry_key_t>& keys);
void _omap_fetch_more(
int pos,
const std::set<snapid_t> *snaps,
bool *force_dirty,
- list<CInode*> *undef_inodes);
+ std::list<CInode*> *undef_inodes);
/**
* Mark this fragment as BADFRAG (common part of go_bad and go_bad_dentry)
bool complete, int r);
// -- commit --
- compact_map<version_t, std::list<MDSInternalContextBase*> > waiting_for_commit;
+ mempool::mds_co::compact_map<version_t, mempool::mds_co::list<MDSInternalContextBase*> > waiting_for_commit;
void _commit(version_t want, int op_prio);
void _omap_commit(int op_prio);
void _encode_dentry(CDentry *dn, bufferlist& bl, const std::set<snapid_t> *snaps);
// -- waiters --
protected:
- compact_map< string_snap_t, std::list<MDSInternalContextBase*> > waiting_on_dentry;
+ mempool::mds_co::compact_map< string_snap_t, mempool::mds_co::list<MDSInternalContextBase*> > waiting_on_dentry; // FIXME string_snap_t not in mempool
public:
bool is_waiting_for_dentry(std::string_view dname, snapid_t snap) {
}
// dump any remaining dentries, for debugging purposes
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p)
- dout(14) << __func__ << " LEFTOVER dn " << *p->second << dendl;
+ for (const auto &p : dir->items)
+ dout(14) << __func__ << " LEFTOVER dn " << *p.second << dendl;
assert(dir->get_num_ref() == 0);
delete dir;
snapid_t fgfirst;
nest_info_t rstat;
nest_info_t accounted_rstat;
- compact_map<snapid_t,old_rstat_t> dirty_old_rstat;
+ decltype(CDir::dirty_old_rstat) dirty_old_rstat;
decode(fg, p);
decode(fgfirst, p);
decode(rstat, p);
dout(20) << fg << " dirty_old_rstat " << dir->dirty_old_rstat << dendl;
mdcache->project_rstat_frag_to_inode(pf->rstat, pf->accounted_rstat,
dir->first, CEPH_NOSNAP, this, true);
- for (compact_map<snapid_t,old_rstat_t>::iterator q = dir->dirty_old_rstat.begin();
- q != dir->dirty_old_rstat.end();
- ++q)
- mdcache->project_rstat_frag_to_inode(q->second.rstat, q->second.accounted_rstat,
- q->second.first, q->first, this, true);
+ for (auto &p : dir->dirty_old_rstat) {
+ mdcache->project_rstat_frag_to_inode(p.second.rstat, p.second.accounted_rstat,
+ p.second.first, p.first, this, true);
+ }
if (update) // dir contents not valid if frozen or non-auth
dir->check_rstats();
} else {
dout(7) << " find_exports in " << dir_pop << " " << *dir << " need " << need << " (" << needmin << " - " << needmax << ")" << dendl;
double subdir_sum = 0;
- for (CDir::map_t::iterator it = dir->begin();
- it != dir->end();
- ++it) {
+ for (auto it = dir->begin(); it != dir->end(); ++it) {
CInode *in = it->second->get_linkage()->get_inode();
if (!in) continue;
if (!in->is_dir()) continue;
dir->dump_load(f, now, decayrate);
f->close_section();
- for (CDir::map_t::iterator it = dir->begin(); it != dir->end(); ++it) {
+ for (auto it = dir->begin(); it != dir->end(); ++it) {
CInode *in = it->second->get_linkage()->get_inode();
if (!in || !in->is_dir())
continue;
if (!in->client_caps.empty()) {
const set<snapid_t>& snaps = in->find_snaprealm()->get_snaps();
// clone caps?
- for (auto p : in->client_caps) {
+ for (auto &p : in->client_caps) {
client_t client = p.first;
Capability *cap = p.second;
int issued = cap->need_snapflush() ? CEPH_CAP_ANY_WR : cap->issued();
first = ofirst;
// find any intersection with last
- compact_map<snapid_t,old_rstat_t>::iterator p = parent->dirty_old_rstat.lower_bound(last);
- if (p == parent->dirty_old_rstat.end()) {
+ auto it = parent->dirty_old_rstat.lower_bound(last);
+ if (it == parent->dirty_old_rstat.end()) {
dout(20) << " no dirty_old_rstat with last >= last " << last << dendl;
if (!parent->dirty_old_rstat.empty() && parent->dirty_old_rstat.rbegin()->first >= first) {
dout(20) << " last dirty_old_rstat ends at " << parent->dirty_old_rstat.rbegin()->first << dendl;
first = parent->dirty_old_rstat.rbegin()->first+1;
}
} else {
- // *p last is >= last
- if (p->second.first <= last) {
- // *p intersects [first,last]
- if (p->second.first < first) {
- dout(10) << " splitting off left bit [" << p->second.first << "," << first-1 << "]" << dendl;
- parent->dirty_old_rstat[first-1] = p->second;
- p->second.first = first;
+ // *it last is >= last
+ if (it->second.first <= last) {
+ // *it intersects [first,last]
+ if (it->second.first < first) {
+ dout(10) << " splitting off left bit [" << it->second.first << "," << first-1 << "]" << dendl;
+ parent->dirty_old_rstat[first-1] = it->second;
+ it->second.first = first;
}
- if (p->second.first > first)
- first = p->second.first;
- if (last < p->first) {
- dout(10) << " splitting off right bit [" << last+1 << "," << p->first << "]" << dendl;
- parent->dirty_old_rstat[last] = p->second;
- p->second.first = last+1;
+ if (it->second.first > first)
+ first = it->second.first;
+ if (last < it->first) {
+ dout(10) << " splitting off right bit [" << last+1 << "," << it->first << "]" << dendl;
+ parent->dirty_old_rstat[last] = it->second;
+ it->second.first = last+1;
}
} else {
- // *p is to the _right_ of [first,last]
- p = parent->dirty_old_rstat.lower_bound(first);
- // new *p last is >= first
- if (p->second.first <= last && // new *p isn't also to the right, and
- p->first >= first) { // it intersects our first bit,
- dout(10) << " staying to the right of [" << p->second.first << "," << p->first << "]..." << dendl;
- first = p->first+1;
+ // *it is to the _right_ of [first,last]
+ it = parent->dirty_old_rstat.lower_bound(first);
+ // new *it last is >= first
+ if (it->second.first <= last && // new *it isn't also to the right, and
+ it->first >= first) { // it intersects our first bit,
+ dout(10) << " staying to the right of [" << it->second.first << "," << it->first << "]..." << dendl;
+ first = it->first+1;
}
dout(10) << " projecting to new dirty_old_rstat [" << first << "," << last << "]" << dendl;
}
parent->resync_accounted_rstat();
if (g_conf->mds_snap_rstat) {
- for (compact_map<snapid_t,old_rstat_t>::iterator p = parent->dirty_old_rstat.begin();
- p != parent->dirty_old_rstat.end();
- ++p)
- project_rstat_frag_to_inode(p->second.rstat, p->second.accounted_rstat, p->second.first,
- p->first, pin, true);//false);
+ for (auto &p : parent->dirty_old_rstat) {
+ project_rstat_frag_to_inode(p.second.rstat, p.second.accounted_rstat, p.second.first,
+ p.first, pin, true);
+ }
}
parent->dirty_old_rstat.clear();
project_rstat_frag_to_inode(pf->rstat, pf->accounted_rstat, parent->first, CEPH_NOSNAP, pin, true);//false);
}
}
- for (auto p : dirs_to_add) {
+ for (auto &p : dirs_to_add) {
CDir *dir = p.second;
le->metablob.add_dir_context(dir, EMetaBlob::TO_ROOT);
le->metablob.add_dir(dir, false);
d->take_waiting(d_mask, waiters);
// inode waiters too
- for (CDir::map_t::iterator p = d->items.begin();
- p != d->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : d->items) {
+ CDentry *dn = p.second;
CDentry::linkage_t *dnl = dn->get_linkage();
if (dnl->is_primary()) {
dnl->get_inode()->take_waiting(i_mask, waiters);
CDir *subdir = *p++;
dout(10) << " removing dirfrag " << subdir << dendl;
- CDir::map_t::iterator q = subdir->items.begin();
- while (q != subdir->items.end()) {
- CDentry *dn = q->second;
- ++q;
+ auto it = subdir->items.begin();
+ while (it != subdir->items.end()) {
+ CDentry *dn = it->second;
+ ++it;
CDentry::linkage_t *dnl = dn->get_linkage();
if (dnl->is_primary()) {
CInode *tin = dnl->get_inode();
{
dout(7) << "trim_unlinked_inodes" << dendl;
list<CInode*> q;
- for (auto p : inode_map) {
+ for (auto &p : inode_map) {
CInode *in = p.second;
if (in->get_parent_dn() == NULL && !in->is_base()) {
dout(7) << " will trim from " << *in << dendl;
}
// dentries in this dir
- for (CDir::map_t::iterator q = dir->items.begin();
- q != dir->items.end();
- ++q) {
+ for (auto &p : dir->items) {
// dn
- CDentry *dn = q->second;
+ CDentry *dn = p.second;
CDentry::linkage_t *dnl = dn->get_linkage();
if (auth) {
dn->state_set(CDentry::STATE_AUTH);
if (mds->is_rejoin()) {
// WEAK
rejoin->add_weak_dirfrag(dir->dirfrag());
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
assert(dn->last == CEPH_NOSNAP);
CDentry::linkage_t *dnl = dn->get_linkage();
dout(15) << " add_weak_primary_dentry " << *dn << dendl;
rejoin->add_strong_dirfrag(dir->dirfrag(), dir->get_replica_nonce(), dir->get_dir_rep());
dir->state_set(CDir::STATE_REJOINING);
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end(); ) {
- CDentry *dn = p->second;
- ++p;
+ for (auto it = dir->items.begin(); it != dir->items.end(); ) {
+ CDentry *dn = it->second;
+ ++it;
dn->state_set(CDentry::STATE_REJOINING);
CDentry::linkage_t *dnl = dn->get_linkage();
CInode *in = dnl->is_primary() ? dnl->get_inode() : NULL;
}
// dentries
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
if (dn->is_replica(from) &&
(ack == NULL ||
}
};
- for (auto p : inode_map)
+ for (auto &p : inode_map)
scour_func(p.second);
- for (auto p : snap_inode_map)
+ for (auto &p : snap_inode_map)
scour_func(p.second);
}
CDir *dir = *p;
dir->clear_replica_map();
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
dn->clear_replica_map();
dout(10) << " trimming " << *dn << dendl;
it->second->add_dirfrag_base(dir);
}
- for (CDir::map_t::iterator q = dir->items.begin();
- q != dir->items.end();
- ++q) {
- CDentry *dn = q->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
CDentry::linkage_t *dnl = dn->get_linkage();
// inode
{
dout(10) << "reissue_all_caps" << dendl;
- for (auto p : inode_map) {
+ for (auto &p : inode_map) {
CInode *in = p.second;
if (in->is_head() && in->is_any_caps()) {
// called by MDSRank::active_start(). There shouldn't be any frozen subtree.
void MDCache::identify_files_to_recover()
{
dout(10) << "identify_files_to_recover" << dendl;
- for (auto p : inode_map) {
+ for (auto &p : inode_map) {
CInode *in = p.second;
if (!in->is_auth())
continue;
bool keep_dir = !can_trim_non_auth_dirfrag(dir);
- CDir::map_t::iterator j = dir->begin();
- CDir::map_t::iterator i = j;
+ auto j = dir->begin();
+ auto i = j;
while (j != dir->end()) {
i = j++;
CDentry *dn = i->second;
break;
}
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
CDentry::linkage_t *dnl = dn->get_linkage();
if (dnl->is_null())
continue;
dir->fetch(new C_MDC_RetryScanStray(this, dir->dirfrag()));
return;
}
- for (CDir::map_t::iterator q = dir->items.begin(); q != dir->items.end(); ++q) {
- CDentry *dn = q->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
dn->state_set(CDentry::STATE_STRAY);
CDentry::linkage_t *dnl = dn->get_projected_linkage();
if (dnl->is_primary()) {
//if (*it == except) continue;
dout(7) << "sending dir_update on " << *dir << " to " << *it << dendl;
+ std::set<int32_t> s;
+ for (const auto &r : dir->dir_rep_by) {
+ s.insert(r);
+ }
mds->send_message_mds(new MDirUpdate(mds->get_nodeid(),
dir->dirfrag(),
dir->dir_rep,
- dir->dir_rep_by,
+ s,
path,
bcast),
*it);
// Update if it already exists. Othwerwise it got updated by discover reply.
dout(5) << "dir_update on " << *dir << dendl;
dir->dir_rep = m->get_dir_rep();
- dir->dir_rep_by = m->get_dir_rep_by();
+ dir->dir_rep_by.clear();
+ for (const auto &e : m->get_dir_rep_by()) {
+ dir->dir_rep_by.insert(e);
+ }
}
// done
if (!dir->state_test(CDir::STATE_DNPINNEDFRAG)) {
dout(15) << " marking " << *dir << dendl;
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
dn->get(CDentry::PIN_FRAGMENTING);
assert(!dn->state_test(CDentry::STATE_FRAGMENTING));
dn->state_set(CDentry::STATE_FRAGMENTING);
if (dir->state_test(CDir::STATE_DNPINNEDFRAG)) {
dir->state_clear(CDir::STATE_DNPINNEDFRAG);
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
assert(dn->state_test(CDentry::STATE_FRAGMENTING));
dn->state_clear(CDentry::STATE_FRAGMENTING);
dn->put(CDentry::PIN_FRAGMENTING);
CDir *dir = *p;
dout(10) << " result frag " << *dir << dendl;
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
assert(dn->state_test(CDentry::STATE_FRAGMENTING));
dn->state_clear(CDentry::STATE_FRAGMENTING);
dn->put(CDentry::PIN_FRAGMENTING);
mds->server->force_clients_readonly();
// revoke write caps
- for (auto p : inode_map) {
+ for (auto &p : inode_map) {
CInode *in = p.second;
if (in->is_head())
mds->locker->eval(in, CEPH_CAP_LOCKS);
CDir *dir = *p;
dout(7) << " dirfrag " << *dir << dendl;
- for (CDir::map_t::iterator p = dir->items.begin();
- p != dir->items.end();
- ++p) {
- CDentry *dn = p->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
dout(7) << " dentry " << *dn << dendl;
CDentry::linkage_t *dnl = dn->get_linkage();
if (dnl->is_primary() && dnl->get_inode())
}
};
- for (auto p : inode_map)
+ for (auto &p : inode_map)
show_func(p.second);
- for (auto p : snap_inode_map)
+ for (auto &p : snap_inode_map)
show_func(p.second);
}
if (f) {
f->open_array_section("dentries");
}
- for (CDir::map_t::iterator q = dir->items.begin();
- q != dir->items.end();
- ++q) {
- CDentry *dn = q->second;
+ for (auto &p : dir->items) {
+ CDentry *dn = p.second;
if (f) {
f->open_object_section("dentry");
dn->dump(f);
return 1;
};
- for (auto p : inode_map) {
+ for (auto &p : inode_map) {
r = dump_func(p.second);
if (r < 0)
goto out;
}
- for (auto p : snap_inode_map) {
+ for (auto &p : snap_inode_map) {
r = dump_func(p.second);
if (r < 0)
goto out;
frag_info_t frag_info;
nest_info_t nest_info;
- for (CDir::map_t::iterator it = dir->begin(); it != dir->end(); ++it) {
+ for (auto it = dir->begin(); it != dir->end(); ++it) {
CDentry *dn = it->second;
if (dn->last != CEPH_NOSNAP)
continue;
assert(diri->get_projected_parent_dir()->inode->is_stray());
list<CDir*> ls;
diri->get_dirfrags(ls);
- for (auto p : ls) {
+ for (auto &p : ls) {
if (p->is_auth() && !(p->is_frozen() || p->is_freezing()))
p->try_remove_dentries_for_stray();
}
finished_queue.push_back(c);
progress_thread.signal();
}
- void queue_waiters(list<MDSInternalContextBase*>& ls) {
+ void queue_waiters(std::list<MDSInternalContextBase*>& ls) {
finished_queue.splice( finished_queue.end(), ls );
progress_thread.signal();
}
dfs.pop_front();
approx_size += frag_size;
- for (CDir::map_t::iterator p = dir->begin(); p != dir->end(); ++p) {
- CDentry *dn = p->second;
+ for (auto &p : *dir) {
+ CDentry *dn = p.second;
if (dn->get_linkage()->is_null()) {
approx_size += null_size;
continue;
// dentries
list<CDir*> subdirs;
- CDir::map_t::iterator it;
- for (it = dir->begin(); it != dir->end(); ++it) {
- CDentry *dn = it->second;
+ for (auto &p : *dir) {
+ CDentry *dn = p.second;
CInode *in = dn->get_linkage()->get_inode();
if (!dn->is_replicated())
}
// subdirs
- for (list<CDir*>::iterator it = subdirs.begin(); it != subdirs.end(); ++it)
- num_exported += encode_export_dir(exportbl, *it, exported_client_map, now);
+ for (auto &dir : subdirs)
+ num_exported += encode_export_dir(exportbl, dir, exported_client_map, now);
return num_exported;
}
// dentries
list<CDir*> subdirs;
- CDir::map_t::iterator it;
- for (it = dir->begin(); it != dir->end(); ++it) {
- CDentry *dn = it->second;
+ for (auto &p : *dir) {
+ CDentry *dn = p.second;
CInode *in = dn->get_linkage()->get_inode();
// dentry
CDir *t = rq.front();
rq.pop_front();
t->abort_export();
- for (CDir::map_t::iterator p = t->items.begin(); p != t->items.end(); ++p) {
- p->second->abort_export();
- if (!p->second->get_linkage()->is_primary())
+ for (auto &p : *t) {
+ CDentry *dn = p.second;
+ dn->abort_export();
+ if (!dn->get_linkage()->is_primary())
continue;
- CInode *in = p->second->get_linkage()->get_inode();
+ CInode *in = dn->get_linkage()->get_inode();
in->abort_export();
if (in->state_test(CInode::STATE_EVALSTALECAPS)) {
in->state_clear(CInode::STATE_EVALSTALECAPS);
if (cur->is_dirty())
cur->mark_clean();
- CDir::map_t::iterator it;
- for (it = cur->begin(); it != cur->end(); ++it) {
- CDentry *dn = it->second;
+ for (auto &p : *cur) {
+ CDentry *dn = p.second;
// dentry
dn->state_clear(CDentry::STATE_AUTH);
continue;
} else {
// touch everything i _do_ have
- for (CDir::map_t::iterator p = dir->begin(); p != dir->end(); ++p)
- if (!p->second->get_linkage()->is_null())
- mdcache->lru.lru_touch(p->second);
+ for (auto &p : *dir) {
+ if (!p.second->get_linkage()->is_null())
+ mdcache->lru.lru_touch(p.second);
+ }
// already issued caps and leases, reply immediately.
if (dnbl.length() > 0) {
#include "msg/Message.h"
class MDirUpdate : public Message {
- mds_rank_t from_mds = -1;
- dirfrag_t dirfrag;
- int32_t dir_rep = 5;
- int32_t discover = 5;
- compact_set<int32_t> dir_rep_by;
- filepath path;
- int tried_discover;
+public:
+ MDirUpdate() : Message(MSG_MDS_DIRUPDATE) {}
+ MDirUpdate(mds_rank_t f,
+ dirfrag_t dirfrag,
+ int dir_rep,
+ const std::set<int32_t>& dir_rep_by,
+ filepath& path,
+ bool discover = false) :
+ Message(MSG_MDS_DIRUPDATE), from_mds(f), dirfrag(dirfrag),
+ dir_rep(dir_rep), dir_rep_by(dir_rep_by), path(path) {
+ this->discover = discover ? 5 : 0;
+ }
- public:
mds_rank_t get_source_mds() const { return from_mds; }
dirfrag_t get_dirfrag() const { return dirfrag; }
int get_dir_rep() const { return dir_rep; }
- const compact_set<int>& get_dir_rep_by() const { return dir_rep_by; }
+ const std::set<int32_t>& get_dir_rep_by() const { return dir_rep_by; }
bool should_discover() const { return discover > tried_discover; }
const filepath& get_path() const { return path; }
bool has_tried_discover() const { return tried_discover > 0; }
void inc_tried_discover() { ++tried_discover; }
- MDirUpdate() : Message(MSG_MDS_DIRUPDATE), tried_discover(0) {}
- MDirUpdate(mds_rank_t f,
- dirfrag_t dirfrag,
- int dir_rep,
- compact_set<int>& dir_rep_by,
- filepath& path,
- bool discover = false) :
- Message(MSG_MDS_DIRUPDATE), tried_discover(0) {
- this->from_mds = f;
- this->dirfrag = dirfrag;
- this->dir_rep = dir_rep;
- this->dir_rep_by = dir_rep_by;
- this->discover = discover ? 5 : 0;
- this->path = path;
- }
-private:
- ~MDirUpdate() override {}
-
-public:
const char *get_type_name() const override { return "dir_update"; }
void print(ostream& out) const override {
out << "dir_update(" << get_dirfrag() << ")";
encode(dir_rep_by, payload);
encode(path, payload);
}
+
+private:
+ ~MDirUpdate() override {}
+
+ mds_rank_t from_mds = -1;
+ dirfrag_t dirfrag;
+ int32_t dir_rep = 5;
+ int32_t discover = 5;
+ std::set<int32_t> dir_rep_by;
+ filepath path;
+ int tried_discover = 0;
};
#endif
projects / ceph.git / commitdiff