bool wait_for_active = true;
if (mds->is_stopping()) {
- if (m->get_source().is_mds())
- wait_for_active = false;
+ wait_for_active = false;
} else if (mds->is_clientreplay()) {
if (req->is_queued_for_replay()) {
wait_for_active = false;
if (session->is_opening() ||
session->is_open() ||
session->is_stale() ||
- session->is_killing()) {
+ session->is_killing() ||
+ terminating_sessions) {
dout(10) << "currently open|opening|stale|killing, dropping this req" << dendl;
// set client metadata for session opened by prepare_force_open_sessions
if (!m->client_meta.empty())
});
if (blacklisted) {
- dout(10) << "ignoring blacklisted client " << session->info.inst.addr << dendl;
+ dout(10) << "rejecting blacklisted client " << session->info.inst.addr << dendl;
+ mds->send_message_client(new MClientSession(CEPH_SESSION_REJECT), session);
m->put();
return;
}
* - sessions learned from other MDSs during a cross-MDS rename
*/
version_t Server::prepare_force_open_sessions(map<client_t,entity_inst_t>& cm,
- map<client_t,uint64_t>& sseqmap)
+ map<client_t, pair<Session*,uint64_t> >& smap)
{
version_t pv = mds->sessionmap.get_projected();
dout(10) << "prepare_force_open_sessions " << pv
<< " on " << cm.size() << " clients"
<< dendl;
- for (map<client_t,entity_inst_t>::iterator p = cm.begin(); p != cm.end(); ++p) {
+ mds->objecter->with_osdmap(
+ [this, &cm](const OSDMap &osd_map) {
+ for (auto p = cm.begin(); p != cm.end(); ) {
+ if (osd_map.is_blacklisted(p->second.addr)) {
+ dout(10) << " ignoring blacklisted client." << p->first
+ << " (" << p->second.addr << ")" << dendl;
+ cm.erase(p++);
+ } else {
+ ++p;
+ }
+ }
+ });
+
+ for (map<client_t,entity_inst_t>::iterator p = cm.begin(); p != cm.end(); ++p) {
Session *session = mds->sessionmap.get_or_add_session(p->second);
pv = mds->sessionmap.mark_projected(session);
+ uint64_t sseq;
if (session->is_closed() ||
session->is_closing() ||
- session->is_killing())
- sseqmap[p->first] = mds->sessionmap.set_state(session, Session::STATE_OPENING);
- else
+ session->is_killing()) {
+ sseq = mds->sessionmap.set_state(session, Session::STATE_OPENING);
+ } else {
assert(session->is_open() ||
session->is_opening() ||
session->is_stale());
+ sseq = 0;
+ }
+ smap[p->first] = make_pair(session, sseq);
session->inc_importing();
}
return pv;
}
-void Server::finish_force_open_sessions(map<client_t,entity_inst_t>& cm,
- map<client_t,uint64_t>& sseqmap,
+void Server::finish_force_open_sessions(const map<client_t,pair<Session*,uint64_t> >& smap,
bool dec_import)
{
/*
* client trying to close a session and an MDS doing an import
* trying to force open a session...
*/
- dout(10) << "finish_force_open_sessions on " << cm.size() << " clients,"
+ dout(10) << "finish_force_open_sessions on " << smap.size() << " clients,"
<< " initial v " << mds->sessionmap.get_version() << dendl;
-
-
- for (map<client_t,entity_inst_t>::iterator p = cm.begin(); p != cm.end(); ++p) {
- Session *session = mds->sessionmap.get_session(p->second.name);
- assert(session);
-
- if (sseqmap.count(p->first)) {
- uint64_t sseq = sseqmap[p->first];
+ for (auto &it : smap) {
+ Session *session = it.second.first;
+ uint64_t sseq = it.second.second;
+ if (sseq > 0) {
if (session->get_state_seq() != sseq) {
dout(10) << "force_open_sessions skipping changed " << session->info.inst << dendl;
} else {
void Server::reconnect_clients(MDSInternalContext *reconnect_done_)
{
reconnect_done = reconnect_done_;
- mds->sessionmap.get_client_set(client_reconnect_gather);
+
+ set<Session*> sessions;
+ mds->sessionmap.get_client_session_set(sessions);
+ for (auto session : sessions) {
+ if (session->is_open())
+ client_reconnect_gather.insert(session->get_client());
+ }
if (client_reconnect_gather.empty()) {
dout(7) << "reconnect_clients -- no sessions, doing nothing." << dendl;
<< ") from " << m->get_source_inst()
<< " after " << delay << " (allowed interval " << g_conf->mds_reconnect_timeout << ")";
deny = true;
- } else if (session->is_closed()) {
+ } else if (!session->is_open()) {
dout(1) << " session is closed, ignoring reconnect, sending close" << dendl;
mds->clog->info() << "denied reconnect attempt (mds is "
<< ceph_mds_state_name(mds->get_state())
mdcache->rejoin_recovered_caps(p->first, from, p->second, MDS_RANK_NONE);
}
}
+ mdcache->rejoin_recovered_client(session->get_client(), session->info.inst);
// remove from gather set
client_reconnect_gather.erase(from);
} else {
mdcache->request_finish(mdr);
}
+ m->put();
return;
}
}
return;
}
- CInode *ref = rdlock_path_pin_ref(mdr, 0, rdlocks, false, false, NULL, !is_lookup);
+ bool want_auth = false;
+ int mask = req->head.args.getattr.mask;
+ if (mask & CEPH_STAT_RSTAT)
+ want_auth = true; // set want_auth for CEPH_STAT_RSTAT mask
+
+ CInode *ref = rdlock_path_pin_ref(mdr, 0, rdlocks, want_auth, false, NULL,
+ !is_lookup);
if (!ref) return;
/*
mdr->snapid <= cap->client_follows))
issued = cap->issued();
- int mask = req->head.args.getattr.mask;
if ((mask & CEPH_CAP_LINK_SHARED) && !(issued & CEPH_CAP_LINK_EXCL))
rdlocks.insert(&ref->linklock);
if ((mask & CEPH_CAP_AUTH_SHARED) && !(issued & CEPH_CAP_AUTH_EXCL))
if (!check_access(mdr, ref, MAY_READ))
return;
+ utime_t now = ceph_clock_now();
+ mdr->set_mds_stamp(now);
+
// note which caps are requested, so we return at least a snapshot
// value for them. (currently this matters for xattrs and inline data)
mdr->getattr_caps = mask;
- mds->balancer->hit_inode(ceph_clock_now(), ref, META_POP_IRD,
+ mds->balancer->hit_inode(now, ref, META_POP_IRD,
req->get_source().num());
// reply
if (!check_access(mdr, cur, mask))
return;
+ utime_t now = ceph_clock_now();
+ mdr->set_mds_stamp(now);
+
if (cur->is_file() || cur->is_dir()) {
if (mdr->snapid == CEPH_NOSNAP) {
// register new cap
// hit pop
if (cmode & CEPH_FILE_MODE_WR)
- mds->balancer->hit_inode(mdr->get_mds_stamp(), cur, META_POP_IWR);
+ mds->balancer->hit_inode(now, cur, META_POP_IWR);
else
- mds->balancer->hit_inode(mdr->get_mds_stamp(), cur, META_POP_IRD,
+ mds->balancer->hit_inode(now, cur, META_POP_IRD,
mdr->client_request->get_source().num());
CDentry *dn = 0;
// dirty inode, dn, dir
newi->inode.version--; // a bit hacky, see C_MDS_mknod_finish
newi->mark_dirty(newi->inode.version+1, mdr->ls);
- newi->_mark_dirty_parent(mdr->ls, true);
+ newi->mark_dirty_parent(mdr->ls, true);
mdr->apply();
MDRequestRef null_ref;
get_mds()->mdcache->send_dentry_link(dn, null_ref);
- get_mds()->balancer->hit_inode(mdr->get_mds_stamp(), newi, META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ get_mds()->balancer->hit_inode(now, newi, META_POP_IWR);
server->respond_to_request(mdr, 0);
get_mds()->mdcache->truncate_inode(in, mdr->ls);
}
- get_mds()->balancer->hit_inode(mdr->get_mds_stamp(), in, META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ get_mds()->balancer->hit_inode(now, in, META_POP_IWR);
server->respond_to_request(mdr, 0);
}
pi.inode.version = cur->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
// log + wait
// prepare
auto &pi = in->project_inode();
pi.inode.version = in->pre_dirty();
- pi.inode.mtime = pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.mtime = pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
uint64_t old_size = std::max<uint64_t>(pi.inode.size, mdr->client_request->head.args.open.old_size);
// add the old pool to the inode
pi.inode.add_old_pool(old_layout.pool_id);
pi.inode.version = cur->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
// log + wait
int64_t old_pool = pi.inode.layout.pool_id;
pi.inode.add_old_pool(old_pool);
pi.inode.layout = layout;
- pi.inode.ctime = mdr->get_op_stamp();
pip = &pi.inode;
} else if (name.compare(0, 10, "ceph.quota") == 0) {
if (!cur->is_dir() || cur->is_root()) {
mdr->no_early_reply = true;
pip = &pi.inode;
+
+ client_t exclude_ct = mdr->get_client();
+ mdcache->broadcast_quota_to_client(cur, exclude_ct);
} else if (name.find("ceph.dir.pin") == 0) {
if (!cur->is_dir() || cur->is_root()) {
respond_to_request(mdr, -EINVAL);
}
pip->change_attr++;
- pip->ctime = mdr->get_op_stamp();
+ pip->ctime = pip->rstat.rctime = mdr->get_op_stamp();
pip->version = cur->pre_dirty();
if (cur->is_file())
pip->update_backtrace();
mdr->apply();
- get_mds()->balancer->hit_inode(mdr->get_mds_stamp(), in, META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ get_mds()->balancer->hit_inode(now, in, META_POP_IWR);
server->respond_to_request(mdr, 0);
}
// project update
auto &pi = cur->project_inode(true);
pi.inode.version = cur->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
pi.inode.xattr_version++;
auto &px = *pi.xattrs;
auto &pi = cur->project_inode(true);
auto &px = *pi.xattrs;
pi.inode.version = cur->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
pi.inode.xattr_version++;
px.erase(mempool::mds_co::string(boost::string_view(name)));
// a new version of hte inode since it's just been created)
newi->inode.version--;
newi->mark_dirty(newi->inode.version + 1, mdr->ls);
- newi->_mark_dirty_parent(mdr->ls, true);
+ newi->mark_dirty_parent(mdr->ls, true);
// mkdir?
if (newi->inode.is_dir()) {
get_mds()->locker->share_inode_max_size(newi);
// hit pop
- get_mds()->balancer->hit_inode(mdr->get_mds_stamp(), newi, META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ get_mds()->balancer->hit_inode(now, newi, META_POP_IWR);
// reply
server->respond_to_request(mdr, 0);
// project inode update
auto &pi = targeti->project_inode();
pi.inode.nlink++;
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
pi.inode.version = tipv;
mdcache->send_dentry_link(dn, null_ref);
// bump target popularity
- mds->balancer->hit_inode(mdr->get_mds_stamp(), targeti, META_POP_IWR);
- mds->balancer->hit_dir(mdr->get_mds_stamp(), dn->get_dir(), META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_inode(now, targeti, META_POP_IWR);
+ mds->balancer->hit_dir(now, dn->get_dir(), META_POP_IWR);
// reply
respond_to_request(mdr, 0);
mdcache->send_dentry_unlink(dn, NULL, null_ref);
// bump target popularity
- mds->balancer->hit_inode(mdr->get_mds_stamp(), targeti, META_POP_IWR);
- mds->balancer->hit_dir(mdr->get_mds_stamp(), dn->get_dir(), META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_inode(now, targeti, META_POP_IWR);
+ mds->balancer->hit_dir(now, dn->get_dir(), META_POP_IWR);
// reply
respond_to_request(mdr, 0);
mdr->apply();
// hit pop
- mds->balancer->hit_inode(mdr->get_mds_stamp(), targeti, META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_inode(now, targeti, META_POP_IWR);
// done.
mdr->slave_request->put();
}
// inode
- pi.inode.ctime = rollback.old_ctime;
+ pi.inode.ctime = pi.inode.rstat.rctime = rollback.old_ctime;
if (rollback.was_inc)
pi.inode.nlink--;
else
}
mdr->add_projected_inode(in); // do this _after_ my dn->pre_dirty().. we apply that one manually.
pi.inode.version = in->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.change_attr++;
pi.inode.nlink--;
if (pi.inode.nlink == 0)
mdcache->adjust_subtree_after_rename(strayin, dn->get_dir(), true);
// bump pop
- mds->balancer->hit_dir(mdr->get_mds_stamp(), dn->get_dir(), META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_dir(now, dn->get_dir(), META_POP_IWR);
// reply
respond_to_request(mdr, 0);
assert(g_conf->mds_kill_rename_at != 6);
// bump popularity
- mds->balancer->hit_dir(mdr->get_mds_stamp(), srcdn->get_dir(), META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_dir(now, srcdn->get_dir(), META_POP_IWR);
if (destdnl->is_remote() && in->is_auth())
- mds->balancer->hit_inode(mdr->get_mds_stamp(), in, META_POP_IWR);
+ mds->balancer->hit_inode(now, in, META_POP_IWR);
// did we import srci? if so, explicitly ack that import that, before we unlock and reply.
bufferlist::iterator blp = mdr->more()->inode_import.begin();
// imported caps
- ::decode(mdr->more()->imported_client_map, blp);
- ::encode(mdr->more()->imported_client_map, *client_map_bl,
- mds->mdsmap->get_up_features());
- prepare_force_open_sessions(mdr->more()->imported_client_map, mdr->more()->sseq_map);
+ map<client_t,entity_inst_t> client_map;
+ decode(client_map, blp);
+ prepare_force_open_sessions(client_map, mdr->more()->imported_session_map);
+ encode(client_map, *client_map_bl, mds->mdsmap->get_up_features());
list<ScatterLock*> updated_scatterlocks;
mdcache->migrator->decode_import_inode(srcdn, blp, srcdn->authority().first, mdr->ls,
if (!silent) {
if (spi) {
- spi->ctime = mdr->get_op_stamp();
+ spi->ctime = spi->rstat.rctime = mdr->get_op_stamp();
spi->change_attr++;
if (linkmerge)
spi->nlink--;
}
if (tpi) {
- tpi->ctime = mdr->get_op_stamp();
+ tpi->ctime = tpi->rstat.rctime = mdr->get_op_stamp();
tpi->change_attr++;
{
std::string t;
map<client_t,Capability::Import> imported_caps;
// finish cap imports
- finish_force_open_sessions(mdr->more()->imported_client_map, mdr->more()->sseq_map);
+ finish_force_open_sessions(mdr->more()->imported_session_map);
if (mdr->more()->cap_imports.count(destdnl->get_inode())) {
mdcache->migrator->finish_import_inode_caps(destdnl->get_inode(),
- mdr->more()->srcdn_auth_mds, true,
- mdr->more()->cap_imports[destdnl->get_inode()],
- imported_caps);
+ mdr->more()->srcdn_auth_mds, true,
+ mdr->more()->imported_session_map,
+ mdr->more()->cap_imports[destdnl->get_inode()],
+ imported_caps);
}
mdr->more()->inode_import.clear();
destdnl = destdn->get_linkage();
// bump popularity
- mds->balancer->hit_dir(mdr->get_mds_stamp(), srcdn->get_dir(), META_POP_IWR);
+ utime_t now = ceph_clock_now();
+ mds->balancer->hit_dir(now, srcdn->get_dir(), META_POP_IWR);
if (destdnl->get_inode() && destdnl->get_inode()->is_auth())
- mds->balancer->hit_inode(mdr->get_mds_stamp(), destdnl->get_inode(),
- META_POP_IWR);
+ mds->balancer->hit_inode(now, destdnl->get_inode(), META_POP_IWR);
// done.
mdr->slave_request->put();
::decode(peer_imported, bp);
dout(10) << " finishing inode export on " << *destdnl->get_inode() << dendl;
- mdcache->migrator->finish_export_inode(destdnl->get_inode(),
- mdr->get_mds_stamp(),
+ mdcache->migrator->finish_export_inode(destdnl->get_inode(), ceph_clock_now(),
mdr->slave_to_mds, peer_imported, finished);
mds->queue_waiters(finished); // this includes SINGLEAUTH waiters.
} else
pip = in->get_projected_inode();
if (pip->ctime == rollback.ctime)
- pip->ctime = rollback.orig_src.old_ctime;
+ pip->ctime = pip->rstat.rctime = rollback.orig_src.old_ctime;
}
if (srcdn && srcdn->authority().first == whoami) {
} else
ti = target->get_projected_inode();
if (ti->ctime == rollback.ctime)
- ti->ctime = rollback.orig_dest.old_ctime;
+ ti->ctime = ti->rstat.rctime = rollback.orig_dest.old_ctime;
if (MDS_INO_IS_STRAY(rollback.orig_src.dirfrag.ino)) {
if (MDS_INO_IS_STRAY(rollback.orig_dest.dirfrag.ino))
assert(!rollback.orig_dest.ino && !rollback.orig_dest.remote_ino);
info.stamp = mdr->get_op_stamp();
auto &pi = diri->project_inode(false, true);
- pi.inode.ctime = info.stamp;
+ pi.inode.ctime = pi.inode.rstat.rctime = info.stamp;
pi.inode.version = diri->pre_dirty();
// project the snaprealm
// journal
auto &pi = diri->project_inode(false, true);
pi.inode.version = diri->pre_dirty();
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
mdr->ls = mdlog->get_current_segment();
EUpdate *le = new EUpdate(mdlog, "rmsnap");
// journal
auto &pi = diri->project_inode(false, true);
- pi.inode.ctime = mdr->get_op_stamp();
+ pi.inode.ctime = pi.inode.rstat.rctime = mdr->get_op_stamp();
pi.inode.version = diri->pre_dirty();
// project the snaprealm
projects / ceph.git / blobdiff