derr << "created object store " << g_conf->osd_data;
if (!g_conf->osd_journal.empty())
*_dout << " journal " << g_conf->osd_journal;
- *_dout << " for osd" << whoami << " fsid " << mc.monmap.fsid << dendl;
+ *_dout << " for osd." << whoami << " fsid " << mc.monmap.fsid << dendl;
}
if (mkkey) {
common_init_finish(g_ceph_context);
hb_addr.set_port(0);
messenger_hbout->bind(hb_addr, getpid());
- cout << "starting osd" << whoami
+ cout << "starting osd." << whoami
<< " at " << client_messenger->get_ms_addr()
<< " osd_data " << g_conf->osd_data
<< " " << ((g_conf->osd_journal.empty()) ?
public:
const char *get_type_name() { return "osd_boot"; }
void print(ostream& out) {
- out << "osd_boot(osd" << sb.whoami << " v" << version << ")";
+ out << "osd_boot(osd." << sb.whoami << " v" << version << ")";
}
void encode_payload(CephContext *cct) {
for (int o = 0; o < osdmap.get_max_osd(); o++)
if (osdmap.is_down(o) && osdmap.is_in(o) &&
down_pending_out.count(o) == 0) {
- dout(10) << " adding osd" << o << " to down_pending_out map" << dendl;
+ dout(10) << " adding osd." << o << " to down_pending_out map" << dendl;
down_pending_out[o] = ceph_clock_now(g_ceph_context);
}
i++) {
int s = i->second ? i->second : CEPH_OSD_UP;
if (s & CEPH_OSD_UP)
- dout(2) << " osd" << i->first << " DOWN" << dendl;
+ dout(2) << " osd." << i->first << " DOWN" << dendl;
if (s & CEPH_OSD_EXISTS)
- dout(2) << " osd" << i->first << " DNE" << dendl;
+ dout(2) << " osd." << i->first << " DNE" << dendl;
}
for (map<int32_t,entity_addr_t>::iterator i = pending_inc.new_up_client.begin();
i != pending_inc.new_up_client.end();
i++) {
- dout(2) << " osd" << i->first << " UP " << i->second << dendl; //FIXME: insert cluster addresses too
+ dout(2) << " osd." << i->first << " UP " << i->second << dendl; //FIXME: insert cluster addresses too
}
for (map<int32_t,uint32_t>::iterator i = pending_inc.new_weight.begin();
i != pending_inc.new_weight.end();
i++) {
if (i->second == CEPH_OSD_OUT) {
- dout(2) << " osd" << i->first << " OUT" << dendl;
+ dout(2) << " osd." << i->first << " OUT" << dendl;
} else if (i->second == CEPH_OSD_IN) {
- dout(2) << " osd" << i->first << " IN" << dendl;
+ dout(2) << " osd." << i->first << " IN" << dendl;
} else {
- dout(2) << " osd" << i->first << " WEIGHT " << hex << i->second << dec << dendl;
+ dout(2) << " osd." << i->first << " WEIGHT " << hex << i->second << dec << dendl;
}
}
if (!osdmap.exists(from) ||
osdmap.get_addr(from) != m->get_orig_source_inst().addr ||
osdmap.is_down(from)) {
- dout(5) << "preprocess_failure from dead osd" << from << ", ignoring" << dendl;
+ dout(5) << "preprocess_failure from dead osd." << from << ", ignoring" << dendl;
send_incremental(m, m->get_epoch()+1);
goto didit;
}
while ((i != failed_notes.end()) && (i->first == target_osd)) {
if (i->second.first == reporter) {
++i->second.second;
- dout(10) << "adding new failure report from osd" << reporter
- << " on osd" << target_osd << dendl;
+ dout(10) << "adding new failure report from osd." << reporter
+ << " on osd." << target_osd << dendl;
reporter = -1;
}
++reporters;
(target_osd, pair<int, int>(reporter, 1)));
++reporters;
++reports;
- dout(10) << "osd" << reporter
- << " is adding failure report on osd" << target_osd << dendl;
+ dout(10) << "osd." << reporter
+ << " is adding failure report on osd." << target_osd << dendl;
}
if ((reporters >= g_conf->osd_min_down_reporters) &&
(reports >= g_conf->osd_min_down_reports)) {
- dout(1) << "have enough reports/reporters to mark osd" << target_osd
+ dout(1) << "have enough reports/reporters to mark osd." << target_osd
<< " as down" << dendl;
pending_inc.new_state[target_osd] = CEPH_OSD_UP;
paxos->wait_for_commit(new C_Reported(this, m));
&& (i->second.first != reporter))
++i;
if ((i == failed_notes.end()) || (i->second.first != reporter))
- dout(0) << "got an OSD not-failed report from osd" << reporter
+ dout(0) << "got an OSD not-failed report from osd." << reporter
<< " that hasn't reported failure! (or in previous epoch?)" << dendl;
else failed_notes.erase(i);
}
// does this osd exist?
if (from >= osdmap.get_max_osd()) {
- dout(1) << "boot from osd" << from << " >= max_osd " << osdmap.get_max_osd() << dendl;
+ dout(1) << "boot from osd." << from << " >= max_osd " << osdmap.get_max_osd() << dendl;
m->put();
return false;
}
(info.down_at-1) > last)
last = info.down_at-1;
- dout(10) << "prepare_boot osd" << from << " last_clean_interval "
+ dout(10) << "prepare_boot osd." << from << " last_clean_interval "
<< info.last_clean_first << "-" << info.last_clean_last
<< " -> " << first << "-" << last
<< dendl;
if (osdmap.is_down(o) && osdmap.is_in(o)) {
if (g_conf->mon_osd_down_out_interval > 0 &&
down.sec() >= g_conf->mon_osd_down_out_interval) {
- dout(10) << "tick marking osd" << o << " OUT after " << down
+ dout(10) << "tick marking osd." << o << " OUT after " << down
<< " sec (target " << g_conf->mon_osd_down_out_interval << ")" << dendl;
pending_inc.new_weight[o] = CEPH_OSD_OUT;
do_propose = true;
- mon->clog.info() << "osd" << o << " out (down for " << down << ")\n";
+ mon->clog.info() << "osd." << o << " out (down for " << down << ")\n";
} else
continue;
}
r = 0;
ss << "ok";
} else {
- ss << "osd" << who << " not up";
+ ss << "osd." << who << " not up";
r = -ENOENT;
}
} else ss << "specify osd number or *";
m->cmd[1] == "repair"),
osdmap.get_inst(osd));
r = 0;
- ss << "osd" << osd << " instructed to " << m->cmd[1];
+ ss << "osd." << osd << " instructed to " << m->cmd[1];
} else
- ss << "osd" << osd << " is not up";
+ ss << "osd." << osd << " is not up";
}
}
else if (m->cmd[1] == "lspools") {
for (unsigned j = 2; j < m->cmd.size(); j++) {
long osd = strtol(m->cmd[j].c_str(), 0, 10);
if (!osdmap.exists(osd)) {
- ss << "osd" << osd << " does not exist";
+ ss << "osd." << osd << " does not exist";
} else if (osdmap.is_down(osd)) {
- ss << "osd" << osd << " is already down";
+ ss << "osd." << osd << " is already down";
} else {
pending_inc.new_state[osd] = CEPH_OSD_UP;
if (any)
- ss << ", osd" << osd;
+ ss << ", osd." << osd;
else
- ss << "marked down osd" << osd;
+ ss << "marked down osd." << osd;
any = true;
}
}
for (unsigned j = 2; j < m->cmd.size(); j++) {
long osd = strtol(m->cmd[j].c_str(), 0, 10);
if (!osdmap.exists(osd)) {
- ss << "osd" << osd << " does not exist";
+ ss << "osd." << osd << " does not exist";
} else if (osdmap.is_out(osd)) {
- ss << "osd" << osd << " is already out";
+ ss << "osd." << osd << " is already out";
} else {
pending_inc.new_weight[osd] = CEPH_OSD_OUT;
if (any)
- ss << ", osd" << osd;
+ ss << ", osd." << osd;
else
- ss << "marked out osd" << osd;
+ ss << "marked out osd." << osd;
any = true;
}
}
for (unsigned j = 2; j < m->cmd.size(); j++) {
long osd = strtol(m->cmd[j].c_str(), 0, 10);
if (osdmap.is_in(osd)) {
- ss << "osd" << osd << " is already in";
+ ss << "osd." << osd << " is already in";
} else if (!osdmap.exists(osd)) {
- ss << "osd" << osd << " does not exist";
+ ss << "osd." << osd << " does not exist";
} else {
pending_inc.new_weight[osd] = CEPH_OSD_IN;
if (any)
- ss << ", osd" << osd;
+ ss << ", osd." << osd;
else
- ss << "marked in osd" << osd;
+ ss << "marked in osd." << osd;
any = true;
}
}
long ww = (int)((float)CEPH_OSD_IN*w);
if (osdmap.exists(osd)) {
pending_inc.new_weight[osd] = ww;
- ss << "reweighted osd" << osd << " to " << w << " (" << ios::hex << ww << ios::dec << ")";
+ ss << "reweighted osd." << osd << " to " << w << " (" << ios::hex << ww << ios::dec << ")";
getline(ss, rs);
paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, paxos->get_version()));
return true;
"--yes-i-really-mean-it if you really do.";
}
else if (!osdmap.exists(osd) || !osdmap.is_down(osd)) {
- ss << "osd" << osd << " is not down or doesn't exist";
+ ss << "osd." << osd << " is not down or doesn't exist";
} else {
epoch_t e = osdmap.get_info(osd).down_at;
pending_inc.new_lost[osd] = e;
}
done:
- dout(10) << " creating osd" << i << dendl;
+ dout(10) << " creating osd." << i << dendl;
pending_inc.new_state[i] |= CEPH_OSD_EXISTS;
ss << i;
getline(ss, rs);
for (unsigned j = 2; j < m->cmd.size(); j++) {
long osd = strtol(m->cmd[j].c_str(), 0, 10);
if (!osdmap.exists(osd)) {
- ss << "osd" << osd << " does not exist";
+ ss << "osd." << osd << " does not exist";
} else if (osdmap.is_up(osd)) {
- ss << "osd" << osd << " is still up";
+ ss << "osd." << osd << " is still up";
} else {
pending_inc.new_state[osd] = CEPH_OSD_EXISTS;
if (any)
- ss << ", osd" << osd;
+ ss << ", osd." << osd;
else
- ss << "marked dne osd" << osd;
+ ss << "marked dne osd." << osd;
any = true;
}
}
if (!stats->get_orig_source().is_osd() ||
!mon->osdmon()->osdmap.is_up(from) ||
stats->get_orig_source_inst() != mon->osdmon()->osdmap.get_inst(from)) {
- dout(1) << " ignoring stats from non-active osd" << dendl;
+ dout(1) << " ignoring stats from non-active osd." << dendl;
stats->put();
return false;
}
pending_inc.osd_stat_updates[from] = stats->osd_stat;
if (pg_map.osd_stat.count(from))
- dout(10) << " got osd" << from << " " << stats->osd_stat << " (was " << pg_map.osd_stat[from] << ")" << dendl;
+ dout(10) << " got osd." << from << " " << stats->osd_stat << " (was " << pg_map.osd_stat[from] << ")" << dendl;
else
- dout(10) << " got osd " << from << " " << stats->osd_stat << " (first report)" << dendl;
+ dout(10) << " got osd." << from << " " << stats->osd_stat << " (first report)" << dendl;
// apply to live map too (screw consistency)
/*
p != inc.new_weight.end();
p++)
if (p->second == CEPH_OSD_OUT) {
- dout(10) << "check_osd_map osd" << p->first << " went OUT" << dendl;
+ dout(10) << "check_osd_map osd." << p->first << " went OUT" << dendl;
pending_inc.osd_stat_rm.insert(p->first);
} else {
- dout(10) << "check_osd_map osd" << p->first << " is IN" << dendl;
+ dout(10) << "check_osd_map osd." << p->first << " is IN" << dendl;
pending_inc.osd_stat_rm.erase(p->first);
pending_inc.osd_stat_updates[p->first];
}
now - g_conf->mon_pg_create_interval < last_sent_pg_create[osd])
continue;
- dout(20) << "send_pg_creates " << pgid << " -> osd" << osd
+ dout(20) << "send_pg_creates " << pgid << " -> osd." << osd
<< " in epoch " << pg_map.pg_stat[pgid].created << dendl;
if (msg.count(osd) == 0)
msg[osd] = new MOSDPGCreate(mon->osdmon()->osdmap.get_epoch());
for (map<int, MOSDPGCreate*>::iterator p = msg.begin();
p != msg.end();
p++) {
- dout(10) << "sending pg_create to osd" << p->first << dendl;
+ dout(10) << "sending pg_create to osd." << p->first << dendl;
mon->messenger->send_message(p->second, mon->osdmon()->osdmap.get_inst(p->first));
last_sent_pg_create[p->first] = ceph_clock_now(g_ceph_context);
}
mon->try_send_message(new MOSDScrub(mon->monmap->fsid, pgs,
m->cmd[1] == "repair"),
mon->osdmon()->osdmap.get_inst(osd));
- ss << "instructing pg " << pgid << " on osd" << osd << " to " << m->cmd[1];
+ ss << "instructing pg " << pgid << " on osd." << osd << " to " << m->cmd[1];
r = 0;
} else
- ss << "pg " << pgid << " primary osd" << osd << " not up";
+ ss << "pg " << pgid << " primary osd." << osd << " not up";
} else
ss << "pg " << pgid << " has no primary osd";
} else
#define dout_prefix _prefix(*_dout, whoami, osdmap)
static ostream& _prefix(std::ostream* _dout, int whoami, OSDMap *osdmap) {
- return *_dout << "osd" << whoami << " " << (osdmap ? osdmap->get_epoch():0) << " ";
+ return *_dout << "osd." << whoami << " " << (osdmap ? osdmap->get_epoch():0) << " ";
}
const coll_t coll_t::META_COLL("meta");
// load up pgs (as they previously existed)
load_pgs();
- dout(2) << "superblock: i am osd" << superblock.whoami << dendl;
+ dout(2) << "superblock: i am osd." << superblock.whoami << dendl;
assert_warn(whoami == superblock.whoami);
if (whoami != superblock.whoami) {
derr << "OSD::init: logic error: superblock says osd"
- << superblock.whoami << " but i am osd" << whoami << dendl;
+ << superblock.whoami << " but i am osd." << whoami << dendl;
return -EINVAL;
}
}
if (whoami != superblock.whoami) {
- derr << "read_superblock superblock says osd" << superblock.whoami
- << ", but i (think i) am osd" << whoami << dendl;
+ derr << "read_superblock superblock says osd." << superblock.whoami
+ << ", but i (think i) am osd." << whoami << dendl;
return -1;
}
// have a stamp _AND_ i'm not new to the set
heartbeat_from_stamp[p] = old_from_stamp[p];
} else {
- dout(10) << "update_heartbeat_peers: new _from osd" << p
+ dout(10) << "update_heartbeat_peers: new _from osd." << p
<< " " << con->get_peer_addr() << dendl;
heartbeat_from_stamp[p] = ceph_clock_now(g_ceph_context);
MOSDPing *m = new MOSDPing(osdmap->get_fsid(), 0, heartbeat_epoch,
// share latest map with this peer, just to be nice.
if (osdmap->is_up(p->first) && !is_booting()) {
- dout(10) << "update_heartbeat_peers: sharing map with old _from peer osd" << p->first << dendl;
+ dout(10) << "update_heartbeat_peers: sharing map with old _from peer osd." << p->first << dendl;
_share_map_outgoing(osdmap->get_cluster_inst(p->first));
}
- dout(10) << "update_heartbeat_peers: will mark down old _from peer osd" << p->first
+ dout(10) << "update_heartbeat_peers: will mark down old _from peer osd." << p->first
<< " " << con->get_peer_addr()
<< " as of " << p->second << dendl;
if (!osdmap->is_up(p->first) && !is_booting()) {
- dout(10) << "update_heartbeat_peers: telling old peer osd" << p->first
+ dout(10) << "update_heartbeat_peers: telling old peer osd." << p->first
<< " " << old_con[p->first]->get_peer_addr()
<< " they are down" << dendl;
hbin_messenger->send_message(new MOSDPing(osdmap->get_fsid(), heartbeat_epoch,
p++) {
if (heartbeat_from_stamp.count(p->first) &&
heartbeat_from_stamp[p->first] < grace) {
- derr << "heartbeat_check: no heartbeat from osd" << p->first
+ derr << "heartbeat_check: no heartbeat from osd." << p->first
<< " since " << heartbeat_from_stamp[p->first]
<< " (cutoff " << grace << ")" << dendl;
queue_failure(p->first);
i != heartbeat_to.end();
i++) {
int peer = i->first;
- dout(30) << "heartbeat allocating ping for osd" << peer << dendl;
+ dout(30) << "heartbeat allocating ping for osd." << peer << dendl;
Message *m = new MOSDPing(osdmap->get_fsid(),
map_locked ? osdmap->get_epoch():0,
i->second, MOSDPing::HEARTBEAT);
m->set_priority(CEPH_MSG_PRIO_HIGH);
- dout(30) << "heartbeat sending ping to osd" << peer << dendl;
+ dout(30) << "heartbeat sending ping to osd." << peer << dendl;
hbout_messenger->send_message(m, heartbeat_to_con[peer]);
}
map<int,epoch_t>::iterator p = peer_map_epoch.find(peer);
if (p != peer_map_epoch.end()) {
if (p->second < e) {
- dout(10) << "note_peer_epoch osd" << peer << " has " << e << dendl;
+ dout(10) << "note_peer_epoch osd." << peer << " has " << e << dendl;
p->second = e;
} else {
- dout(30) << "note_peer_epoch osd" << peer << " has " << p->second << " >= " << e << dendl;
+ dout(30) << "note_peer_epoch osd." << peer << " has " << p->second << " >= " << e << dendl;
}
return p->second;
} else {
- dout(10) << "note_peer_epoch osd" << peer << " now has " << e << dendl;
+ dout(10) << "note_peer_epoch osd." << peer << " now has " << e << dendl;
peer_map_epoch[peer] = e;
return e;
}
map<int,epoch_t>::iterator p = peer_map_epoch.find(peer);
if (p != peer_map_epoch.end()) {
if (p->second <= as_of) {
- dout(10) << "forget_peer_epoch osd" << peer << " as_of " << as_of
+ dout(10) << "forget_peer_epoch osd." << peer << " as_of " << as_of
<< " had " << p->second << dendl;
peer_map_epoch.erase(p);
} else {
- dout(10) << "forget_peer_epoch osd" << peer << " as_of " << as_of
+ dout(10) << "forget_peer_epoch osd." << peer << " as_of " << as_of
<< " has " << p->second << " - not forgetting" << dendl;
}
}
// update_heartbeat_peers() will clean out peers i expect heartbeast _from_.
if (heartbeat_to.count(peer) &&
heartbeat_to[peer] < osdmap->get_epoch()) {
- dout(10) << "note_down_osd osd" << peer << " marking down hbout connection "
+ dout(10) << "note_down_osd osd." << peer << " marking down hbout connection "
<< heartbeat_to_con[peer]->get_peer_addr() << dendl;
hbout_messenger->mark_down(heartbeat_to_con[peer]);
heartbeat_to_con[peer]->put();
int from = m->get_source().num();
if (!osdmap->have_inst(from) ||
osdmap->get_cluster_addr(from) != m->get_source_inst().addr) {
- dout(0) << "from dead osd" << from << ", dropping, sharing map" << dendl;
+ dout(0) << "from dead osd." << from << ", dropping, sharing map" << dendl;
send_incremental_map(epoch, m->get_source_inst(), true);
// close after we send the map; don't reconnect
it != notify_list.end();
it++) {
if (it->first == whoami) {
- dout(7) << "do_notify osd" << it->first << " is self, skipping" << dendl;
+ dout(7) << "do_notify osd." << it->first << " is self, skipping" << dendl;
continue;
}
- dout(7) << "do_notify osd" << it->first << " on " << it->second.size() << " PGs" << dendl;
+ dout(7) << "do_notify osd." << it->first << " on " << it->second.size() << " PGs" << dendl;
MOSDPGNotify *m = new MOSDPGNotify(osdmap->get_epoch(), it->second);
_share_map_outgoing(osdmap->get_cluster_inst(it->first));
cluster_messenger->send_message(m, osdmap->get_cluster_inst(it->first));
pit != query_map.end();
pit++) {
int who = pit->first;
- dout(7) << "do_queries querying osd" << who
+ dout(7) << "do_queries querying osd." << who
<< " on " << pit->second.size() << " PGs" << dendl;
MOSDPGQuery *m = new MOSDPGQuery(osdmap->get_epoch(), pit->second);
_share_map_outgoing(osdmap->get_cluster_inst(who));
for (vector<PG::Info>::iterator i = p->second->pg_info.begin();
i != p->second->pg_info.end();
++i) {
- dout(20) << "Sending info " << *i << " to osd" << p->first << dendl;
+ dout(20) << "Sending info " << *i << " to osd." << p->first << dendl;
}
cluster_messenger->send_message(p->second, osdmap->get_cluster_inst(p->first));
}
if (pg->is_primary()) {
// peer is informing us of their last_complete_ondisk
- dout(10) << *pg << " replica osd" << from << " lcod " << m->trim_to << dendl;
+ dout(10) << *pg << " replica osd." << from << " lcod " << m->trim_to << dendl;
pg->peer_last_complete_ondisk[from] = m->trim_to;
if (pg->calc_min_last_complete_ondisk()) {
dout(10) << *pg << " min lcod now " << pg->min_last_complete_ondisk << dendl;
} else {
dout(7) << *pg << " misdirected op in " << op->get_map_epoch() << dendl;
clog.warn() << op->get_source_inst() << " misdirected "
- << op->get_reqid() << " " << pg->info.pgid << " to osd" << whoami
+ << op->get_reqid() << " " << pg->info.pgid << " to osd." << whoami
<< " not " << pg->acting
<< " in e" << op->get_map_epoch() << "/" << osdmap->get_epoch()
<< "\n";
out << "max_osd " << get_max_osd() << "\n";
for (int i=0; i<get_max_osd(); i++) {
if (exists(i)) {
- out << "osd" << i;
+ out << "osd." << i;
out << (is_up(i) ? " up ":" down");
out << (is_in(i) ? " in ":" out");
if (is_in(i))
rweights[i] = 0;
for (j=0; j<nper; j++, o++) {
if (o == nosd) break;
- ldout(cct, 20) << "added osd" << o << dendl;
+ ldout(cct, 20) << "added osd." << o << dendl;
items[j] = o;
weights[j] = 0x10000;
//w[j] = weights[o] ? (0x10000 - (int)(weights[o] * 0x10000)):0x10000;
std::string PG::gen_prefix() const {
stringstream out;
- out << "osd" << osd->whoami
+ out << "osd." << osd->whoami
<< " " << (osd->osdmap ? osd->osdmap->get_epoch():0)
<< " " << *this << " ";
return out.str();
void PG::proc_master_log(ObjectStore::Transaction& t, Info &oinfo, Log &olog, Missing& omissing, int from)
{
- dout(10) << "proc_master_log for osd" << from << ": " << olog << " " << omissing << dendl;
+ dout(10) << "proc_master_log for osd." << from << ": " << olog << " " << omissing << dendl;
assert(!is_active() && is_primary());
// merge log into our own log to build master log. no need to
// non-divergent).
merge_log(t, oinfo, olog, from);
peer_info[from] = oinfo;
- dout(10) << " peer osd" << from << " now " << oinfo << " " << omissing << dendl;
+ dout(10) << " peer osd." << from << " now " << oinfo << " " << omissing << dendl;
might_have_unfound.insert(from);
search_for_missing(oinfo, &omissing, from);
void PG::proc_replica_log(ObjectStore::Transaction& t, Info &oinfo, Log &olog, Missing& omissing, int from)
{
- dout(10) << "proc_replica_log for osd" << from << ": " << oinfo << " " << olog << " " << omissing << dendl;
+ dout(10) << "proc_replica_log for osd." << from << ": " << oinfo << " " << olog << " " << omissing << dendl;
// This was a side effect in _process_pg_info. At this point I don't
// think it's necessary, since we're in the GetMissing state,
}
if (lu < oinfo.last_update) {
- dout(10) << " peer osd" << from << " last_update now " << lu << dendl;
+ dout(10) << " peer osd." << from << " last_update now " << lu << dendl;
oinfo.last_update = lu;
if (lu < oinfo.last_complete)
oinfo.last_complete = lu;
}
peer_info[from] = oinfo;
- dout(10) << " peer osd" << from << " now " << oinfo << " " << omissing << dendl;
+ dout(10) << " peer osd." << from << " now " << oinfo << " " << omissing << dendl;
might_have_unfound.insert(from);
search_for_missing(oinfo, &omissing, from);
{
map<int,PG::Info>::iterator p = peer_info.find(from);
if (p != peer_info.end() && p->second.last_update == oinfo.last_update) {
- dout(10) << " got dup osd" << from << " info " << oinfo << ", identical to ours" << dendl;
+ dout(10) << " got dup osd." << from << " info " << oinfo << ", identical to ours" << dendl;
return false;
}
- dout(10) << " got osd" << from << " " << oinfo << dendl;
+ dout(10) << " got osd." << from << " " << oinfo << dendl;
assert(is_primary());
peer_info[from] = oinfo;
might_have_unfound.insert(from);
// stray?
if (!is_acting(from)) {
- dout(10) << " osd" << from << " has stray content: " << oinfo << dendl;
+ dout(10) << " osd." << from << " has stray content: " << oinfo << dendl;
stray_set.insert(from);
if (is_clean()) {
purge_strays();
void PG::merge_log(ObjectStore::Transaction& t,
Info &oinfo, Log &olog, int fromosd)
{
- dout(10) << "merge_log " << olog << " from osd" << fromosd
+ dout(10) << "merge_log " << olog << " from osd." << fromosd
<< " into " << log << dendl;
// Check preconditions
eversion_t need = p->second.need;
if (oinfo.last_update < need) {
dout(10) << "search_for_missing " << soid << " " << need
- << " also missing on osd" << fromosd
+ << " also missing on osd." << fromosd
<< " (last_update " << oinfo.last_update << " < needed " << need << ")"
<< dendl;
continue;
// Without the peer's missing set, we don't know whether it has this
// particular object or not.
dout(10) << __func__ << " " << soid << " " << need
- << " might also be missing on osd" << fromosd << dendl;
+ << " might also be missing on osd." << fromosd << dendl;
continue;
}
if (omissing->is_missing(soid)) {
dout(10) << "search_for_missing " << soid << " " << need
- << " also missing on osd" << fromosd << dendl;
+ << " also missing on osd." << fromosd << dendl;
continue;
}
}
dout(10) << "search_for_missing " << soid << " " << need
- << " is on osd" << fromosd << dendl;
+ << " is on osd." << fromosd << dendl;
map<hobject_t, set<int> >::iterator ml = missing_loc.find(soid);
if (ml == missing_loc.end()) {
int peer(*m);
if (!osd->osdmap->is_up(peer)) {
- dout(20) << __func__ << " skipping down osd" << peer << dendl;
+ dout(20) << __func__ << " skipping down osd." << peer << dendl;
continue;
}
// should be on its way.
// TODO: coalsce requested_* into a single data structure
if (peer_missing.find(peer) != peer_missing.end()) {
- dout(20) << __func__ << ": osd" << peer
+ dout(20) << __func__ << ": osd." << peer
<< ": we already have Missing" << dendl;
continue;
}
if (peer_log_requested.find(peer) != peer_log_requested.end()) {
- dout(20) << __func__ << ": osd" << peer
+ dout(20) << __func__ << ": osd." << peer
<< ": in peer_log_requested" << dendl;
continue;
}
if (peer_backlog_requested.find(peer) != peer_backlog_requested.end()) {
- dout(20) << __func__ << ": osd" << peer
+ dout(20) << __func__ << ": osd." << peer
<< ": in peer_backlog_requested" << dendl;
continue;
}
if (peer_missing_requested.find(peer) != peer_missing_requested.end()) {
- dout(20) << __func__ << ": osd" << peer
+ dout(20) << __func__ << ": osd." << peer
<< ": in peer_missing_requested" << dendl;
continue;
}
// Request missing
- dout(10) << __func__ << ": osd" << peer << ": requesting Missing"
+ dout(10) << __func__ << ": osd." << peer << ": requesting Missing"
<< dendl;
peer_missing_requested.insert(peer);
query_map[peer][info.pgid] =
int peer = *a;
map<int, Missing>::const_iterator pm = peer_missing.find(peer);
if (pm == peer_missing.end()) {
- dout(10) << __func__ << ": osd" << peer << " don't have missing set" << dendl;
+ dout(10) << __func__ << ": osd." << peer << " don't have missing set" << dendl;
uptodate = false;
continue;
}
if (pm->second.num_missing()) {
- dout(10) << __func__ << ": osd" << peer << " has " << pm->second.num_missing() << " missing" << dendl;
+ dout(10) << __func__ << ": osd." << peer << " has " << pm->second.num_missing() << " missing" << dendl;
uptodate = false;
}
}
// did someone in the prior set go down?
if (osdmap->is_down(o) && prior.down.count(o) == 0) {
- dout(10) << "prior_set_affected: osd" << o << " now down" << dendl;
+ dout(10) << "prior_set_affected: osd." << o << " now down" << dendl;
return true;
}
int o = *p;
if (osdmap->is_up(o)) {
- dout(10) << "prior_set_affected: osd" << *p << " now up" << dendl;
+ dout(10) << "prior_set_affected: osd." << *p << " now up" << dendl;
return true;
}
// did someone in the prior set get lost or destroyed?
if (!osdmap->exists(o)) {
- dout(10) << "prior_set_affected: osd" << o << " no longer exists" << dendl;
+ dout(10) << "prior_set_affected: osd." << o << " no longer exists" << dendl;
return true;
}
if (pinfo.lost_at > pinfo.up_from) {
set<int>::const_iterator pl = prior.lost.find(o);
if (pl == prior.lost.end()) {
- dout(10) << "prior_set_affected: osd" << o << " now lost" << dendl;
+ dout(10) << "prior_set_affected: osd." << o << " now lost" << dendl;
return true;
}
}
p != prior.up_thru.end();
++p)
if (p->second != osdmap->get_up_thru(p->first)) {
- dout(10) << "prior_set_affected: primary osd" << p->first
+ dout(10) << "prior_set_affected: primary osd." << p->first
<< " up_thru " << p->second
<< " -> " << osdmap->get_up_thru(p->first)
<< dendl;
const Info &best_info = all_info.find(newest_update_osd)->second;
dout(10) << "choose_acting best_info is " << best_info
- << " from osd" << newest_update_osd << dendl;
+ << " from osd." << newest_update_osd << dendl;
for (vector<int>::const_iterator i = up.begin();
i != up.end();
++i) {
if (best_info.log_tail <= cur_info.last_update || best_info.log_backlog) {
// Can be brought up to date without stopping to generate a backlog
want.push_back(*i);
- dout(10) << " osd" << *i << " (up) accepted" << dendl;
+ dout(10) << " osd." << *i << " (up) accepted" << dendl;
} else {
- dout(10) << " osd" << *i << " (up) REJECTED" << dendl;
+ dout(10) << " osd." << *i << " (up) REJECTED" << dendl;
}
}
if (best_info.log_tail <= i->second.last_update || best_info.log_backlog) {
// Can be brought up to date without stopping to generate a backlog
want.push_back(i->first);
- dout(10) << " osd" << i->first << " (stray) accepted" << dendl;
+ dout(10) << " osd." << i->first << " (stray) accepted" << dendl;
} else {
- dout(10) << " osd" << i->first << " (stray) REJECTED" << dendl;
+ dout(10) << " osd." << i->first << " (stray) REJECTED" << dendl;
}
}
i != all_info.end();
++i) {
if (prior_set.cur.find(i->first) == prior_set.cur.end()) {
- dout(10) << "osd" << i->first << " not in current prior set, skipping" << dendl;
+ dout(10) << "osd." << i->first << " not in current prior set, skipping" << dendl;
continue;
}
}
dout(10) << "choose_log_location newest_update " << newest_update
- << " on osd" << pull_from << dendl;
+ << " on osd." << pull_from << dendl;
if (!choose_acting(pull_from)) {
return false;
continue;
if (pi.last_update < best_info->log_tail) {
- dout(10) << "must generate backlog for up but !acting peer osd" << *it
+ dout(10) << "must generate backlog for up but !acting peer osd." << *it
<< " whose last_update " << pi.last_update
<< " < best_info->tail " << best_info->log_tail << dendl;
need_backlog = true;
const Info& pi = peer_info.find(*it)->second;
if (pi.last_complete < pi.log_tail && !pi.log_backlog &&
pi.last_complete < info.log_tail) {
- dout(10) << "must generate backlog for replica peer osd" << *it
+ dout(10) << "must generate backlog for replica peer osd." << *it
<< " who has a last_complete " << pi.last_complete
<< " < their log.tail " << pi.log_tail << " and no backlog" << dendl;
need_backlog = true;
MOSDPGLog *m = 0;
- dout(10) << "activate peer osd" << peer << " " << pi << dendl;
+ dout(10) << "activate peer osd." << peer << " " << pi << dendl;
bool need_old_log_entries = pi.log_tail > pi.last_complete && !pi.log_backlog;
if (pi.last_update == info.last_update && !need_old_log_entries) {
// empty log
if (!pi.is_empty() && activator_map) {
- dout(10) << "activate peer osd" << peer << " is up to date, queueing in pending_activators" << dendl;
+ dout(10) << "activate peer osd." << peer << " is up to date, queueing in pending_activators" << dendl;
if (activator_map->count(peer) == 0)
(*activator_map)[peer] = new MOSDPGInfo(osd->osdmap->get_epoch());
(*activator_map)[peer]->pg_info.push_back(info);
} else {
- dout(10) << "activate peer osd" << peer << " is up to date, but sending pg_log anyway" << dendl;
+ dout(10) << "activate peer osd." << peer << " is up to date, but sending pg_log anyway" << dendl;
m = new MOSDPGLog(osd->osdmap->get_epoch(), info);
}
}
if (need_old_log_entries) {
// the replica's tail is after it's last_complete and it has no backlog.
// ick, this shouldn't normally happen. but we can compensate!
- dout(10) << "activate peer osd" << peer << " has last_complete < log tail and no backlog, compensating" << dendl;
+ dout(10) << "activate peer osd." << peer << " has last_complete < log tail and no backlog, compensating" << dendl;
if (log.tail <= pi.last_complete) {
// _our_ log is sufficient, phew!
m->log.copy_after(log, pi.last_complete);
}
if (m) {
- dout(10) << "activate peer osd" << peer << " sending " << m->log << " " << m->missing << dendl;
+ dout(10) << "activate peer osd." << peer << " sending " << m->log << " " << m->missing << dendl;
//m->log.print(cout);
osd->cluster_messenger->send_message(m, osd->osdmap->get_cluster_inst(peer));
}
// update our missing
if (pm.num_missing() == 0) {
pi.last_complete = pi.last_update;
- dout(10) << "activate peer osd" << peer << " already uptodate, " << pi << dendl;
+ dout(10) << "activate peer osd." << peer << " already uptodate, " << pi << dendl;
} else {
- dout(10) << "activate peer osd" << peer << " " << pi
+ dout(10) << "activate peer osd." << peer << " " << pi
<< " missing " << pm << dendl;
}
}
p != stray_set.end();
p++) {
if (osd->osdmap->is_up(*p)) {
- dout(10) << "sending PGRemove to osd" << *p << dendl;
+ dout(10) << "sending PGRemove to osd." << *p << dendl;
osd->queue_for_removal(*p, info.pgid);
stray_purged.insert(*p);
} else {
- dout(10) << "not sending PGRemove to down osd" << *p << dendl;
+ dout(10) << "not sending PGRemove to down osd." << *p << dendl;
}
peer_info.erase(*p);
}
int from = op->get_source().num();
- dout(10) << " got osd" << from << " scrub map" << dendl;
+ dout(10) << " got osd." << from << " scrub map" << dendl;
bufferlist::iterator p = op->get_data().begin();
if (scrub_received_maps.count(from)) {
ScrubMap incoming;
void PG::_request_scrub_map(int replica, eversion_t version)
{
- dout(10) << "scrub requesting scrubmap from osd" << replica << dendl;
+ dout(10) << "scrub requesting scrubmap from osd." << replica << dendl;
MOSDRepScrub *repscrubop = new MOSDRepScrub(info.pgid, version,
osd->osdmap->get_epoch());
osd->cluster_messenger->send_message(repscrubop,
::decode(reserved, p);
if (scrub_reserved_peers.find(from) != scrub_reserved_peers.end()) {
- dout(10) << " already had osd" << from << " reserved" << dendl;
+ dout(10) << " already had osd." << from << " reserved" << dendl;
} else {
if (reserved) {
- dout(10) << " osd" << from << " scrub reserve = success" << dendl;
+ dout(10) << " osd." << from << " scrub reserve = success" << dendl;
scrub_reserved_peers.insert(from);
} else {
/* One decline stops this pg from being scheduled for scrubbing. */
- dout(10) << " osd" << from << " scrub reserve = fail" << dendl;
+ dout(10) << " osd." << from << " scrub reserve = fail" << dendl;
scrub_reserve_failed = true;
}
sched_scrub();
void PG::scrub_reserve_replicas()
{
for (unsigned i=1; i<acting.size(); i++) {
- dout(10) << "scrub requesting reserve from osd" << acting[i] << dendl;
+ dout(10) << "scrub requesting reserve from osd." << acting[i] << dendl;
vector<OSDOp> scrub(1);
scrub[0].op.op = CEPH_OSD_OP_SCRUB_RESERVE;
hobject_t poid;
void PG::scrub_unreserve_replicas()
{
for (unsigned i=1; i<acting.size(); i++) {
- dout(10) << "scrub requesting unreserve from osd" << acting[i] << dendl;
+ dout(10) << "scrub requesting unreserve from osd." << acting[i] << dendl;
vector<OSDOp> scrub(1);
scrub[0].op.op = CEPH_OSD_OP_SCRUB_UNRESERVE;
hobject_t poid;
j->second->objects[*k],
ss)) {
cur_inconsistent.insert(j->first);
- errorstream << info.pgid << " osd" << acting[j->first]
+ errorstream << info.pgid << " osd." << acting[j->first]
<< ": soid " << *k << ss.str() << std::endl;
}
}
} else {
cur_missing.insert(j->first);
errorstream << info.pgid
- << " osd" << acting[j->first]
+ << " osd." << acting[j->first]
<< " missing " << *k << std::endl;
}
}
map<hobject_t, int> authoritative;
map<int,ScrubMap *> maps;
- dout(2) << "scrub osd" << acting[0] << " has "
+ dout(2) << "scrub osd." << acting[0] << " has "
<< primary_scrubmap.objects.size() << " items" << dendl;
maps[0] = &primary_scrubmap;
for (unsigned i=1; i<acting.size(); i++) {
- dout(2) << "scrub osd" << acting[i] << " has "
+ dout(2) << "scrub osd." << acting[i] << " has "
<< scrub_received_maps[acting[i]].objects.size() << " items" << dendl;
maps[i] = &scrub_received_maps[acting[i]];
}
boost::statechart::result
PG::RecoveryState::Primary::react(const MNotifyRec& notevt) {
- dout(7) << "handle_pg_notify from osd" << notevt.from << dendl;
+ dout(7) << "handle_pg_notify from osd." << notevt.from << dendl;
PG *pg = context< RecoveryMachine >().pg;
if (pg->peer_info.count(notevt.from) &&
pg->peer_info[notevt.from].last_update == notevt.info.last_update) {
- dout(10) << *pg << " got dup osd" << notevt.from << " info " << notevt.info
+ dout(10) << *pg << " got dup osd." << notevt.from << " info " << notevt.info
<< ", identical to ours" << dendl;
} else {
pg->proc_replica_info(notevt.from, notevt.info);
map<int,PG::Info>::iterator p = pg->peer_info.begin();
while (p != pg->peer_info.end()) {
if (!osdmap.is_up(p->first)) {
- dout(10) << " dropping down osd" << p->first << " info " << p->second << dendl;
+ dout(10) << " dropping down osd." << p->first << " info " << p->second << dendl;
pg->peer_missing.erase(p->first);
pg->peer_info.erase(p++);
} else
pg->info.history.same_acting_since);
assert(infoevt.info.history.last_epoch_started >=
pg->info.history.same_acting_since);
- dout(10) << " peer osd" << infoevt.from << " activated and committed"
+ dout(10) << " peer osd." << infoevt.from << " activated and committed"
<< dendl;
pg->peer_activated.insert(infoevt.from);
}
boost::statechart::result
PG::RecoveryState::Active::react(const MLogRec& logevt) {
- dout(10) << "searching osd" << logevt.from
+ dout(10) << "searching osd." << logevt.from
<< " log for unfound items" << dendl;
PG *pg = context< RecoveryMachine >().pg;
bool got_missing = pg->search_for_missing(logevt.msg->info,
continue;
}
if (pg->peer_info.count(peer)) {
- dout(10) << " have osd" << peer << " info " << pg->peer_info[peer] << dendl;
+ dout(10) << " have osd." << peer << " info " << pg->peer_info[peer] << dendl;
continue;
}
if (peer_info_requested.count(peer)) {
- dout(10) << " already requested info from osd" << peer << dendl;
+ dout(10) << " already requested info from osd." << peer << dendl;
} else if (!pg->osd->osdmap->is_up(peer)) {
- dout(10) << " not querying info from down osd" << peer << dendl;
+ dout(10) << " not querying info from down osd." << peer << dendl;
} else {
- dout(10) << " querying info from osd" << peer << dendl;
+ dout(10) << " querying info from osd." << peer << dendl;
context< RecoveryMachine >().send_query(peer, Query(Query::INFO, pg->info.history));
peer_info_requested.insert(peer);
}
}
if (newest_update_osd != pg->osd->whoami) {
- dout(10) << " requesting master log from osd" << newest_update_osd << dendl;
+ dout(10) << " requesting master log from osd." << newest_update_osd << dendl;
context<RecoveryMachine>().send_query(newest_update_osd,
wait_on_backlog ?
Query(Query::BACKLOG, pg->info.history) :
assert(!msg);
if (logevt.from != newest_update_osd) {
dout(10) << "GetLog: discarding log from "
- << "non-newest_update_osd osd" << logevt.from << dendl;
+ << "non-newest_update_osd osd." << logevt.from << dendl;
return discard_event();
}
dout(10) << "GetLog: recieved master log from osd"
// pull anything.
// FIXME: we can do better here. if last_update==last_complete we
// can infer the rest!
- dout(10) << " osd" << *i << " has no missing, identical log" << dendl;
+ dout(10) << " osd." << *i << " has no missing, identical log" << dendl;
pg->peer_missing[*i];
pg->search_for_missing(pi, &pg->peer_missing[*i], *i);
continue;
eversion_t since(pi.history.last_epoch_started, 0);
if (pi.last_update < pg->info.log_tail) {
// Replica needs to generate a backlog for merge_log to catch deletions
- dout(10) << " requesting log+missing since " << since << " from osd" << *i << dendl;
+ dout(10) << " requesting log+missing since " << since << " from osd." << *i << dendl;
context< RecoveryMachine >().send_query(*i, Query(Query::BACKLOG, pg->info.history));
} else if (pi.log_tail <= since) {
- dout(10) << " requesting log+missing since " << since << " from osd" << *i << dendl;
+ dout(10) << " requesting log+missing since " << since << " from osd." << *i << dendl;
context< RecoveryMachine >().send_query(*i, Query(Query::LOG, since, pg->info.history));
} else if (pi.log_backlog) {
- dout(10) << " requesting backlog+missing from osd" << *i
+ dout(10) << " requesting backlog+missing from osd." << *i
<< " (want since " << since << " < log.tail " << pi.log_tail << ")"
<< dendl;
context< RecoveryMachine >().send_query(*i, Query(Query::BACKLOG, pg->info.history));
} else {
// hmm, is this case valid?
- dout(10) << " requesting fulllog+missing from osd" << *i
+ dout(10) << " requesting fulllog+missing from osd." << *i
<< " (want since " << since << " < log.tail " << pi.log_tail << ")"
<< dendl;
context< RecoveryMachine >().send_query(*i, Query(Query::FULLLOG, pg->info.history));
boost::statechart::result PG::RecoveryState::WaitUpThru::react(const MLogRec& logevt)
{
- dout(10) << "searching osd" << logevt.from
+ dout(10) << "searching osd." << logevt.from
<< " log for unfound items" << dendl;
PG *pg = context< RecoveryMachine >().pg;
bool got_missing = pg->search_for_missing(logevt.msg->info,
void PG::RecoveryState::handle_notify(int from, PG::Info& i,
RecoveryCtx *rctx)
{
- dout(10) << "handle_notify " << i << " from osd" << from << dendl;
+ dout(10) << "handle_notify " << i << " from osd." << from << dendl;
start_handle(rctx);
machine.process_event(MNotifyRec(from, i));
end_handle();
void PG::RecoveryState::handle_info(int from, PG::Info& i,
RecoveryCtx *rctx)
{
- dout(10) << "handle_info " << i << " from osd" << from << dendl;
+ dout(10) << "handle_info " << i << " from osd." << from << dendl;
start_handle(rctx);
machine.process_event(MInfoRec(from, i));
end_handle();
MOSDPGLog *msg,
RecoveryCtx *rctx)
{
- dout(10) << "handle_log " << *msg << " from osd" << from << dendl;
+ dout(10) << "handle_log " << *msg << " from osd." << from << dendl;
start_handle(rctx);
machine.process_event(MLogRec(from, msg));
end_handle();
void PG::RecoveryState::handle_query(int from, const PG::Query& q,
RecoveryCtx *rctx)
{
- dout(10) << "handle_query " << q << " from osd" << from << dendl;
+ dout(10) << "handle_query " << q << " from osd." << from << dendl;
start_handle(rctx);
machine.process_event(MQuery(from, q));
end_handle();
if (pinfo && (pinfo->up_from > interval.last &&
!(pinfo->last_clean_first <= interval.first &&
pinfo->last_clean_last >= interval.last))) {
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " up_from " << pinfo->up_from
<< " and last clean interval " << pinfo->last_clean_first << "-" << pinfo->last_clean_last
<< " does not include us" << dendl;
down.insert(o);
if (started_since_joining.size()) {
if (pinfo)
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " is down, but marked lost at " << pinfo->lost_at
<< ", and " << started_since_joining << " have started since joining pg"
<< dendl;
else
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " no longer exists, and " << started_since_joining << " have started since joining pg"
<< dendl;
} else {
if (pinfo)
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " is down, but marked lost at " << pinfo->lost_at
<< ", and NO acting osds have started since joining pg, so i may not have any pg state :/"
<< dendl;
else
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " no longer exists, and NO acting osds have started since joining pg, so i may not have any pg state :/"
<< dendl;
need_down++;
}
} else {
- dout(10) << "build_prior prior osd" << o
+ dout(10) << "build_prior prior osd." << o
<< " is down" << dendl;
need_down++;
down.insert(o);
#undef dout_prefix
#define dout_prefix _prefix(_dout, this, osd->whoami, osd->osdmap)
static ostream& _prefix(std::ostream *_dout, PG *pg, int whoami, OSDMap *osdmap) {
- return *_dout << "osd" << whoami
+ return *_dout << "osd." << whoami
<< " " << (osdmap ? osdmap->get_epoch():0) << " " << *pg << " ";
}
dout(7) << "repop_ack rep_tid " << repop->rep_tid << " op " << *op
<< " result " << result
<< " ack_type " << ack_type
- << " from osd" << fromosd
+ << " from osd." << fromosd
<< dendl;
else
dout(7) << "repop_ack rep_tid " << repop->rep_tid << " (no op) "
<< " result " << result
<< " ack_type " << ack_type
- << " from osd" << fromosd
+ << " from osd." << fromosd
<< dendl;
if (ack_type & CEPH_OSD_FLAG_ONDISK) {
// send commit.
dout(10) << "sub_op_modify_commit on op " << *rm->op
- << ", sending commit to osd" << rm->ackerosd
+ << ", sending commit to osd." << rm->ackerosd
<< dendl;
log_subop_stats(rm->op, l_osd_sop_w_inb, l_osd_sop_w_lat);
dout(7) << "pull " << soid
<< " v " << v
<< " on osds " << missing_loc[soid]
- << " from osd" << fromosd
+ << " from osd." << fromosd
<< dendl;
map<hobject_t, interval_set<uint64_t> > clone_subsets;
dout(10) << "send_pull_op " << soid << " " << v
<< " first=" << first
- << " data " << data_subset << " from osd" << fromosd
+ << " data " << data_subset << " from osd." << fromosd
<< " tid " << tid << dendl;
MOSDSubOp *subop = new MOSDSubOp(rid, info.pgid, soid, false, CEPH_OSD_FLAG_ACK,
const object_info_t& oi = obc->obs.oi;
uint64_t size = obc->obs.oi.size;
- dout(10) << "push_to_replica " << soid << " v" << oi.version << " size " << size << " to osd" << peer << dendl;
+ dout(10) << "push_to_replica " << soid << " v" << oi.version << " size " << size << " to osd." << peer << dendl;
map<hobject_t, interval_set<uint64_t> > clone_subsets;
interval_set<uint64_t> data_subset;
head.snap = CEPH_NOSNAP;
if (peer_missing[peer].is_missing(head) &&
peer_missing[peer].have_old(head) == oi.prior_version) {
- dout(10) << "push_to_replica osd" << peer << " has correct old " << head
+ dout(10) << "push_to_replica osd." << peer << " has correct old " << head
<< " v" << oi.prior_version
<< ", pushing " << soid << " attrs as a clone op" << dendl;
interval_set<uint64_t> data_subset;
object_info_t oi(bv);
if (oi.version != version) {
- osd->clog.error() << info.pgid << " push " << soid << " v " << version << " to osd" << peer
+ osd->clog.error() << info.pgid << " push " << soid << " v " << version << " to osd." << peer
<< " failed because local copy is " << oi.version << "\n";
return -1;
}
<< " size " << size
<< " subset " << data_subset
<< " data " << bl.length()
- << " to osd" << peer
+ << " to osd." << peer
<< dendl;
osd->logger->inc(l_osd_push);
const hobject_t& soid = reply->get_poid();
if (pushing.count(soid) == 0) {
- dout(10) << "huh, i wasn't pushing " << soid << " to osd" << peer
+ dout(10) << "huh, i wasn't pushing " << soid << " to osd." << peer
<< ", or anybody else"
<< dendl;
} else if (pushing[soid].count(peer) == 0) {
- dout(10) << "huh, i wasn't pushing " << soid << " to osd" << peer
+ dout(10) << "huh, i wasn't pushing " << soid << " to osd." << peer
<< dendl;
} else {
push_info_t *pi = &pushing[soid][peer];
int from = op->get_source().num();
map<hobject_t,set<int> >::iterator p = missing_loc.find(soid);
if (p != missing_loc.end()) {
- dout(0) << "_failed_push " << soid << " from osd" << from
+ dout(0) << "_failed_push " << soid << " from osd." << from
<< ", reps on " << p->second << dendl;
p->second.erase(from); // forget about this (bad) peer replica
if (p->second.empty())
missing_loc.erase(p);
} else {
- dout(0) << "_failed_push " << soid << " from osd" << from
+ dout(0) << "_failed_push " << soid << " from osd." << from
<< " but not in missing_loc ???" << dendl;
}
++j;
continue;
}
- dout(10) << "Reseting pulls from osd" << j->first
+ dout(10) << "Reseting pulls from osd." << j->first
<< ", osdmap has it marked down" << dendl;
for (set<hobject_t>::iterator i = j->second.begin();
if (!peer_missing[peer].is_missing(soid, v)) {
missing_loc[soid].insert(peer);
dout(10) << info.pgid << " unexpectedly missing " << soid << " v" << v
- << ", there should be a copy on osd" << peer << dendl;
+ << ", there should be a copy on osd." << peer << dendl;
uhoh = false;
}
}
assert(pm != peer_missing.end());
size_t m_sz = pm->second.num_missing();
- dout(10) << " peer osd" << peer << " missing " << m_sz << " objects." << dendl;
- dout(20) << " peer osd" << peer << " missing " << pm->second.missing << dendl;
+ dout(10) << " peer osd." << peer << " missing " << m_sz << " objects." << dendl;
+ dout(20) << " peer osd." << peer << " missing " << pm->second.missing << dendl;
// oldest first!
const Missing &m(pm->second);
inline ostream& operator<<(ostream& out, const OSDSuperblock& sb)
{
return out << "sb(" << sb.fsid
- << " osd" << sb.whoami
+ << " osd." << sb.whoami
<< " e" << sb.current_epoch
<< " [" << sb.oldest_map << "," << sb.newest_map << "]"
<< " lci=[" << sb.mounted << "," << sb.clean_thru << "]"
void Objecter::reopen_session(OSDSession *s)
{
entity_inst_t inst = osdmap->get_inst(s->osd);
- ldout(cct, 10) << "reopen_session osd" << s->osd << " session, addr now " << inst << dendl;
+ ldout(cct, 10) << "reopen_session osd." << s->osd << " session, addr now " << inst << dendl;
if (s->con) {
messenger->mark_down(s->con);
s->con->put();
void Objecter::close_session(OSDSession *s)
{
- ldout(cct, 10) << "close_session for osd" << s->osd << dendl;
+ ldout(cct, 10) << "close_session for osd." << s->osd << dendl;
if (s->con) {
messenger->mark_down(s->con);
s->con->put();
void Objecter::kick_requests(OSDSession *session)
{
- ldout(cct, 10) << "kick_requests for osd" << session->osd << dendl;
+ ldout(cct, 10) << "kick_requests for osd." << session->osd << dendl;
// resend ops
for (xlist<Op*>::iterator p = session->ops.begin(); !p.end(); ++p)
p++) {
Op *op = p->second;
if (op->session && op->stamp < cutoff) {
- ldout(cct, 2) << " tid " << p->first << " on osd" << op->session->osd << " is laggy" << dendl;
+ ldout(cct, 2) << " tid " << p->first << " on osd." << op->session->osd << " is laggy" << dendl;
toping.insert(op->session);
}
}
ldout(cct, 10) << "op_submit oid " << op->oid
<< " " << op->oloc
<< " " << op->ops << " tid " << op->tid
- << " osd" << (op->session ? op->session->osd : -1)
+ << " osd." << (op->session ? op->session->osd : -1)
<< dendl;
assert(op->flags & (CEPH_OSD_FLAG_READ|CEPH_OSD_FLAG_WRITE));
if (p)
op->used_replica = true;
osd = acting[p];
- ldout(cct, 10) << " chose random osd" << osd << " of " << acting << dendl;
+ ldout(cct, 10) << " chose random osd." << osd << " of " << acting << dendl;
} else if (read && (op->flags & CEPH_OSD_FLAG_LOCALIZE_READS)) {
// look for a local replica
unsigned i;
for (i = acting.size()-1; i > 0; i++)
if (osdmap->get_addr(i).is_same_host(messenger->get_myaddr())) {
op->used_replica = true;
- ldout(cct, 10) << " chose local osd" << acting[i] << " of " << acting << dendl;
+ ldout(cct, 10) << " chose local osd." << acting[i] << " of " << acting << dendl;
break;
}
osd = acting[i];
void Objecter::send_op(Op *op)
{
- ldout(cct, 15) << "send_op " << op->tid << " to osd" << op->session->osd << dendl;
+ ldout(cct, 15) << "send_op " << op->tid << " to osd." << op->session->osd << dendl;
int flags = op->flags;
if (op->oncommit)
//
int osd = osdmap->identify_osd(con->get_peer_addr());
if (osd >= 0) {
- ldout(cct, 1) << "ms_handle_reset on osd" << osd << dendl;
+ ldout(cct, 1) << "ms_handle_reset on osd." << osd << dendl;
map<int,OSDSession*>::iterator p = osd_sessions.find(osd);
if (p != osd_sessions.end()) {
OSDSession *session = p->second;
ldout(cct, 20) << "dump_active .. " << num_homeless_ops << " homeless" << dendl;
for (hash_map<tid_t,Op*>::iterator p = ops.begin(); p != ops.end(); p++) {
Op *op = p->second;
- ldout(cct, 20) << op->tid << "\t" << op->pgid << "\tosd" << (op->session ? op->session->osd : -1)
+ ldout(cct, 20) << op->tid << "\t" << op->pgid << "\tosd." << (op->session ? op->session->osd : -1)
<< "\t" << op->oid << "\t" << op->ops << dendl;
}
}
uint64_t avg = 0;
for (int i=0; i<n; i++) {
- cout << "osd" << i << "\t" << count[i] << std::endl;
+ cout << "osd." << i << "\t" << count[i] << std::endl;
avg += count[i];
}
avg /= n;
projects / ceph.git / commitdiff