Lines Matching refs:mds
71 * mds reply parsing
402 pr_err("problem parsing mds trace %d\n", err);
741 * parse entire mds reply
786 pr_err("mds parse_reply err %d\n", err);
929 int mds)
931 if (mds >= mdsc->max_sessions || !mdsc->sessions[mds])
933 return ceph_get_mds_session(mdsc->sessions[mds]);
936 static bool __have_session(struct ceph_mds_client *mdsc, int mds)
938 if (mds >= mdsc->max_sessions || !mdsc->sessions[mds])
954 * create+register a new session for given mds.
958 int mds)
965 if (mds >= mdsc->mdsmap->possible_max_rank)
972 if (mds >= mdsc->max_sessions) {
973 int newmax = 1 << get_count_order(mds + 1);
989 dout("%s: mds%d\n", __func__, mds);
991 s->s_mds = mds;
1012 mdsc->sessions[mds] = s;
1016 ceph_con_open(&s->s_con, CEPH_ENTITY_TYPE_MDS, mds,
1017 ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
1032 dout("__unregister_session mds%d %p\n", s->s_mds, s);
1057 int mds;
1060 for (mds = 0; mds < mdsc->max_sessions; ++mds) {
1063 s = __ceph_lookup_mds_session(mdsc, mds);
1263 * Choose mds to send request to next. If there is a hint set in the
1264 * request (e.g., due to a prior forward hint from the mds), use that.
1266 * appropriate mds. If all else fails, choose randomly.
1278 int mds = -1;
1286 * is there a specific mds we should try? ignore hint if we have
1287 * no session and the mds is not up (active or recovering).
1292 dout("%s using resend_mds mds%d\n", __func__,
1364 mds = frag.dist[r];
1365 dout("%s %p %llx.%llx frag %u mds%d (%d/%d)\n",
1367 frag.frag, mds, (int)r, frag.ndist);
1368 if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >=
1370 !ceph_mdsmap_is_laggy(mdsc->mdsmap, mds))
1376 * authoritative mds. */
1377 if (frag.mds >= 0) {
1378 /* choose auth mds */
1379 mds = frag.mds;
1380 dout("%s %p %llx.%llx frag %u mds%d (auth)\n",
1382 frag.frag, mds);
1383 if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >=
1386 mds))
1405 mds = cap->session->s_mds;
1406 dout("%s %p %llx.%llx mds%d (%scap %p)\n", __func__,
1407 inode, ceph_vinop(inode), mds,
1412 return mds;
1418 mds = ceph_mdsmap_get_random_mds(mdsc->mdsmap);
1419 dout("%s chose random mds%d\n", __func__, mds);
1420 return mds;
1638 int mds = session->s_mds;
1643 /* wait for mds to go active? */
1644 mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds);
1645 dout("open_session to mds%d (%s)\n", mds,
1659 * open sessions for any export targets for the given mds
1690 dout("open_export_target_session to mds%d\n", target);
1704 int i, mds = session->s_mds;
1706 if (mds >= mdsc->mdsmap->possible_max_rank)
1709 mi = &mdsc->mdsmap->m_info[mds];
1710 dout("open_export_target_sessions for mds%d (%d targets)\n",
1738 dout("dispose_cap_releases mds%d\n", session->s_mds);
1759 dout("cleanup_session_requests mds%d\n", session->s_mds);
1791 int (*cb)(struct inode *, int mds, void *),
1800 dout("iterate_session_caps %p mds%d\n", session, session->s_mds);
1804 int mds;
1813 mds = cap->mds;
1825 ret = cb(inode, mds, arg);
1858 static int remove_session_caps_cb(struct inode *inode, int mds, void *arg)
1866 cap = __get_cap_for_mds(ci, mds);
1947 static int wake_up_session_cb(struct inode *inode, int mds, void *arg)
1961 cap = __get_cap_for_mds(ci, mds);
1962 /* mds did not re-issue stale cap */
1974 dout("wake_up_session_caps %p mds%d\n", session, session->s_mds);
1993 pr_info("mds%d caps stale\n", session->s_mds);
1996 /* do not try to renew caps until a recovering mds has reconnected
2000 dout("send_renew_caps ignoring mds%d (%s)\n",
2005 dout("send_renew_caps to mds%d (%s)\n", session->s_mds,
2020 dout("send_flushmsg_ack to mds%d (%s)s seq %lld\n",
2049 pr_info("mds%d caps renewed\n", session->s_mds);
2052 pr_info("mds%d caps still stale\n", session->s_mds);
2055 dout("renewed_caps mds%d ttl now %lu, was %s, now %s\n",
2071 dout("request_close_session mds%d state %s seq %lld\n",
2127 static int trim_caps_cb(struct inode *inode, int mds, void *arg)
2138 cap = __get_cap_for_mds(ci, mds);
2159 * of lock mds request will re-add auth caps. */
2212 dout("trim_caps mds%d start: %d / %d, trim %d\n",
2218 dout("trim_caps mds%d done: %d / %d, trimmed %d\n",
2327 dout("send_cap_releases mds%d %p\n", session->s_mds, msg);
2347 dout("send_cap_releases mds%d %p\n", session->s_mds, msg);
2352 pr_err("send_cap_releases mds%d, failed to allocate message\n",
2479 * Create an mds request.
2862 int mds = session->s_mds;
3013 mds, req->r_inode_drop, req->r_inode_unless,
3017 req->r_parent, mds, req->r_dentry_drop,
3025 req->r_old_dentry_dir, mds,
3035 mds, req->r_old_inode_drop, req->r_old_inode_unless, 0);
3100 int mds = session->s_mds;
3129 ceph_get_cap_for_mds(ceph_inode(req->r_inode), mds);
3234 int mds = -1;
3281 mds = __choose_mds(mdsc, req, &random);
3282 if (mds < 0 ||
3283 ceph_mdsmap_get_state(mdsc->mdsmap, mds) < CEPH_MDS_STATE_ACTIVE) {
3288 dout("do_request no mds or not active, waiting for map\n");
3294 session = __ceph_lookup_mds_session(mdsc, mds);
3296 session = register_session(mdsc, mds);
3304 dout("do_request mds%d session %p state %s\n", mds, session,
3346 /* retry the same mds later */
3348 req->r_resend_mds = mds;
3355 req->r_resend_mds = -1; /* forget any previous mds hint */
3395 if (ci->i_ceph_flags & CEPH_I_ASYNC_CREATE && mds != cap->mds) {
3406 cap->mds = mds;
3453 * Wake up threads with requests pending for @mds, so that they can
3454 * resubmit their requests to a possibly different mds.
3456 static void kick_requests(struct ceph_mds_client *mdsc, int mds)
3461 dout("kick_requests mds%d\n", mds);
3470 req->r_session->s_mds == mds) {
3578 * Synchrously perform an mds request. Take care of all of the
3618 * Handle mds reply.
3633 int mds = session->s_mds;
3655 pr_err("mdsc_handle_reply got %llu on session mds%d"
3656 " not mds%d\n", tid, session->s_mds,
3665 pr_warn("got a dup %s reply on %llu from mds%d\n",
3666 head->safe ? "safe" : "unsafe", tid, mds);
3671 pr_warn("got unsafe after safe on %llu from mds%d\n",
3672 tid, mds);
3695 dout("got safe reply %llu, mds%d\n", tid, mds);
3745 pr_err("mdsc_handle_reply got corrupt reply mds%d(tid:%lld)\n", mds, tid);
3832 * handle mds notification that our request has been forwarded.
3855 dout("forward tid %llu to mds%d - req dne\n", tid, next_mds);
3878 /* resend. forward race not possible; mds would drop */
3879 dout("forward tid %llu to mds%d (we resend)\n", tid, next_mds);
3930 * handle a mds session control message
3936 int mds = session->s_mds;
3983 pr_warn("mds%d session blocklisted\n", session->s_mds);
3999 dout("handle_session mds%d %s %p state %s seq %llu\n",
4000 mds, ceph_session_op_name(op), session,
4005 pr_info("mds%d came back\n", session->s_mds);
4011 pr_info("mds%d reconnect success\n", session->s_mds);
4015 pr_notice("mds%d is already opened\n", session->s_mds);
4044 pr_info("mds%d reconnect denied\n", session->s_mds);
4053 pr_info("mds%d caps went stale, renewing\n",
4084 pr_info("mds%d rejected session\n", session->s_mds);
4094 pr_err("mdsc_handle_session bad op %d mds%d\n", op, mds);
4103 kick_requests(mdsc, mds);
4111 pr_err("mdsc_handle_session corrupt message mds%d len %d\n", mds,
4149 dout("replay_unsafe_requests mds%d\n", session->s_mds);
4291 static int reconnect_caps_cb(struct inode *inode, int mds, void *arg)
4323 cap = __get_cap_for_mds(ci, mds);
4490 * snaprealms. we provide mds with the ino, seq (version), and
4491 * parent for all of our realms. If the mds has any newer info,
4540 * clear which snap realms the mds cares about, we send everything we
4550 int mds = session->s_mds;
4557 pr_info("mds%d reconnect start\n", mds);
4598 CEPH_ENTITY_TYPE_MDS, mds,
4599 ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
4708 pr_err("error %d preparing reconnect for mds%d\n", err, mds);
4745 dout("check_new_map mds%d state %s%s -> %s%s (session %s)\n",
4753 /* force close session for stopped mds */
4782 continue; /* nothing new with this mds */
4797 * kick request on any mds that has gone active.
4803 pr_info("mds%d recovery completed\n", s->s_mds);
4852 dout("send reconnect to export target mds.%d\n", i);
4868 dout(" connecting to export targets of laggy mds%d\n",
4900 int mds = session->s_mds;
4907 dout("handle_lease from mds%d\n", mds);
5011 dout("lease_send_msg identry %p %s to mds%d\n",
5066 pr_info("mds%d hung\n", s->s_mds);
5093 dout("resending session close request for mds%d\n", s->s_mds);
5096 pr_err("unable to close session to mds%d: %d\n",
5102 * delayed work -- periodically trim expired leases, renew caps with mds. If
5250 * Wait for safe replies on open mds requests. If we time out, drop
5290 dout("request mdlog flush to mds%d (%s)s seq %lld\n", s->s_mds,
5295 pr_err("failed to request mdlog flush to mds%d (%s) seq %lld\n",
5327 * flush the mdlog and wait for all write mds requests to flush.
5495 int mds;
5500 for (mds = 0; mds < mdsc->max_sessions; mds++) {
5501 session = __ceph_lookup_mds_session(mdsc, mds);
5520 kick_requests(mdsc, mds);
5636 * handle mds map update.
5678 mdsc->mdsmap = newmap; /* first mds map */
5717 * if the client is unresponsive for long enough, the mds will kill
5725 pr_warn("mds%d closed our session\n", s->s_mds);