{
Mutex::Locker l(_ref_id_lock);
auto tag_counts_entry = _tag_counts.find(tag);
- assert(_tag_counts_entry != _tag_counts.end());
+ assert(tag_counts_entry != _tag_counts.end());
--tag_counts_entry->second;
if (tag_counts_entry->second == 0) {
_tag_counts.erase(tag_counts_entry);
BackTrace bt(0);
stringstream ss;
bt.print(ss);
- dout(20) << __func__ << ": " << info.pgid << " got id " << id << dendl;
+ dout(20) << __func__ << ": " << info.pgid << " got id " << id << " (new) ref==" << ref << dendl;
assert(!_live_ids.count(id));
_live_ids.insert(make_pair(id, ss.str()));
return id;
void PG::put_with_id(uint64_t id)
{
- dout(20) << __func__ << ": " << info.pgid << " put id " << id << dendl;
+ dout(20) << __func__ << ": " << info.pgid << " put id " << id << " (current) ref==" << ref << dendl;
{
Mutex::Locker l(_ref_id_lock);
assert(_live_ids.count(id));
peer_features(CEPH_FEATURES_SUPPORTED_DEFAULT),
acting_features(CEPH_FEATURES_SUPPORTED_DEFAULT),
upacting_features(CEPH_FEATURES_SUPPORTED_DEFAULT),
- last_epoch(0),
- scrub_sleep_lock("PG::scrub_sleep_lock"),
- scrub_sleep_timer(o->cct, scrub_sleep_lock, false /* relax locking */)
+ last_epoch(0)
{
#ifdef PG_DEBUG_REFS
osd->add_pgid(p, this);
PG::~PG()
{
pgstate_history.set_pg_in_destructor();
- Mutex::Locker l(scrub_sleep_lock);
- scrub_sleep_timer.shutdown();
#ifdef PG_DEBUG_REFS
osd->remove_pgid(info.pgid, this);
#endif
derr << info.pgid << " required past_interval bounds are"
<< " empty [" << rpib << ") but past_intervals is not: "
<< past_intervals << dendl;
- assert(past_intervals.empty());
}
} else {
if (past_intervals.empty()) {
const vector<int> &up,
pg_shard_t up_primary,
const map<pg_shard_t, pg_info_t> &all_info,
- bool compat_mode,
bool restrict_to_up_acting,
vector<int> *_want,
set<pg_shard_t> *backfill,
const vector<int> &up,
pg_shard_t up_primary,
const map<pg_shard_t, pg_info_t> &all_info,
- bool compat_mode,
bool restrict_to_up_acting,
vector<int> *want,
set<pg_shard_t> *backfill,
* as far backwards as necessary to pick up any peers which can
* be log recovered by auth_log_shard's log */
ss << " shard " << up_cand << " (up) backfill " << cur_info << std::endl;
- if (compat_mode) {
- if (backfill->empty()) {
- backfill->insert(up_cand);
- want->push_back(*i);
- acting_backfill->insert(up_cand);
- }
- } else {
- backfill->insert(up_cand);
- acting_backfill->insert(up_cand);
- }
+ backfill->insert(up_cand);
+ acting_backfill->insert(up_cand);
} else {
want->push_back(*i);
acting_backfill->insert(up_cand);
assert(!auth_log_shard->second.is_incomplete());
auth_log_shard_id = auth_log_shard->first;
- // Determine if compatibility needed
- bool compat_mode = !cct->_conf->osd_debug_override_acting_compat;
- if (compat_mode) {
- bool all_support = true;
- OSDMapRef osdmap = get_osdmap();
-
- for (map<pg_shard_t, pg_info_t>::iterator it = all_info.begin();
- it != all_info.end();
- ++it) {
- pg_shard_t peer = it->first;
-
- const osd_xinfo_t& xi = osdmap->get_xinfo(peer.osd);
- if (!(xi.features & CEPH_FEATURE_OSD_ERASURE_CODES)) {
- all_support = false;
- break;
- }
- }
- if (all_support)
- compat_mode = false;
- }
-
set<pg_shard_t> want_backfill, want_acting_backfill;
vector<int> want;
pg_shard_t want_primary;
up,
up_primary,
all_info,
- compat_mode,
restrict_to_up_acting,
&want,
&want_backfill,
up,
up_primary,
all_info,
- compat_mode,
restrict_to_up_acting,
&want,
&want_backfill,
if (want_acting == up) {
// There can't be any pending backfill if
// want is the same as crush map up OSDs.
- assert(compat_mode || want_backfill.empty());
+ assert(want_backfill.empty());
vector<int> empty;
osd->queue_want_pg_temp(info.pgid.pgid, empty);
} else
for (list<pg_log_entry_t>::iterator p = m->log.log.begin();
p != m->log.log.end();
++p)
- if (p->soid <= pi.last_backfill)
+ if (p->soid <= pi.last_backfill &&
+ !p->is_error())
pm.add_next_event(*p);
}
AllReplicasActivated())));
}
-bool PG::requeue_scrub()
+bool PG::requeue_scrub(bool high_priority)
{
assert(is_locked());
if (scrub_queued) {
} else {
dout(10) << __func__ << ": queueing" << dendl;
scrub_queued = true;
- osd->queue_for_scrub(this);
+ osd->queue_for_scrub(this, high_priority);
return true;
}
}
if ((info.stats.state & PG_STATE_UNDERSIZED) == 0)
info.stats.last_fullsized = now;
- publish = true;
+ // do not send pgstat to mon anymore once we are luminous, since mgr takes
+ // care of this by sending MMonMgrReport to mon.
+ publish =
+ osd->osd->get_osdmap()->require_osd_release < CEPH_RELEASE_LUMINOUS;
pg_stats_publish_valid = true;
pg_stats_publish = pre_publish;
dirty_info = true;
dirty_big_info = true;
write_if_dirty(*t);
-
- scrub_sleep_timer.init();
}
#pragma GCC diagnostic ignored "-Wpragmas"
--scrubber.waiting_on;
scrubber.waiting_on_whom.erase(m->from);
if (scrubber.waiting_on == 0) {
- requeue_scrub();
+ if (ops_blocked_by_scrub()) {
+ requeue_scrub(true);
+ } else {
+ requeue_scrub(false);
+ }
}
}
scrubber.waiting_on_whom.erase(m->from);
if (scrubber.waiting_on == 0) {
- requeue_scrub();
+ if (ops_blocked_by_scrub()) {
+ requeue_scrub(true);
+ } else {
+ requeue_scrub(false);
+ }
}
}
{
if (cct->_conf->osd_scrub_sleep > 0 &&
(scrubber.state == PG::Scrubber::NEW_CHUNK ||
- scrubber.state == PG::Scrubber::INACTIVE) && scrubber.needs_sleep) {
+ scrubber.state == PG::Scrubber::INACTIVE) &&
+ scrubber.needs_sleep) {
ceph_assert(!scrubber.sleeping);
dout(20) << __func__ << " state is INACTIVE|NEW_CHUNK, sleeping" << dendl;
+
// Do an async sleep so we don't block the op queue
- auto scrub_requeue_callback = new FunctionContext([this](int r) {
- lock();
- scrubber.sleeping = false;
- scrubber.needs_sleep = false;
- dout(20) << __func__ << " slept for "
- << ceph_clock_now() - scrubber.sleep_start
- << ", re-queuing scrub" << dendl;
- scrub_queued = false;
- requeue_scrub();
- scrubber.sleep_start = utime_t();
- unlock();
- });
- Mutex::Locker l(scrub_sleep_lock);
- scrub_sleep_timer.add_event_after(cct->_conf->osd_scrub_sleep, scrub_requeue_callback);
+ OSDService *osds = osd;
+ spg_t pgid = get_pgid();
+ int state = scrubber.state;
+ auto scrub_requeue_callback =
+ new FunctionContext([osds, pgid, state](int r) {
+ PG *pg = osds->osd->lookup_lock_pg(pgid);
+ if (pg == nullptr) {
+ lgeneric_dout(osds->osd->cct, 20)
+ << "scrub_requeue_callback: Could not find "
+ << "PG " << pgid << " can't complete scrub requeue after sleep"
+ << dendl;
+ return;
+ }
+ pg->scrubber.sleeping = false;
+ pg->scrubber.needs_sleep = false;
+ lgeneric_dout(pg->cct, 20)
+ << "scrub_requeue_callback: slept for "
+ << ceph_clock_now() - pg->scrubber.sleep_start
+ << ", re-queuing scrub with state " << state << dendl;
+ pg->scrub_queued = false;
+ pg->requeue_scrub();
+ pg->scrubber.sleep_start = utime_t();
+ pg->unlock();
+ });
+ Mutex::Locker l(osd->scrub_sleep_lock);
+ osd->scrub_sleep_timer.add_event_after(cct->_conf->osd_scrub_sleep,
+ scrub_requeue_callback);
scrubber.sleeping = true;
scrubber.sleep_start = ceph_clock_now();
return;
return (!scrubber.authoritative.empty() && repair);
}
+bool PG::ops_blocked_by_scrub() const {
+ return (waiting_for_scrub.size() != 0);
+}
+
// the part that actually finalizes a scrub
void PG::scrub_finish()
{
}
bool PG::append_log_entries_update_missing(
- const mempool::osd::list<pg_log_entry_t> &entries,
+ const mempool::osd
_pglog::list<pg_log_entry_t> &entries,
ObjectStore::Transaction &t)
{
assert(!entries.empty());
void PG::merge_new_log_entries(
- const mempool::osd::list<pg_log_entry_t> &entries,
+ const mempool::osd
_pglog::list<pg_log_entry_t> &entries,
ObjectStore::Transaction &t)
{
dout(10) << __func__ << " " << entries << dendl;
projects / ceph.git / blobdiff