Lines Matching defs:mds
53 * mds reply parsing
126 pr_err("problem parsing mds trace %d\n", err);
202 * parse entire mds reply
244 pr_err("mds parse_reply err %d\n", err);
299 int mds)
303 if (mds >= mdsc->max_sessions || mdsc->sessions[mds] == NULL)
305 session = mdsc->sessions[mds];
312 static bool __have_session(struct ceph_mds_client *mdsc, int mds)
314 if (mds >= mdsc->max_sessions)
316 return mdsc->sessions[mds];
329 * create+register a new session for given mds.
333 int mds)
341 s->s_mds = mds;
351 s->s_con.peer_name.num = cpu_to_le64(mds);
371 dout("register_session mds%d\n", mds);
372 if (mds >= mdsc->max_sessions) {
373 int newmax = 1 << get_count_order(mds+1);
388 mdsc->sessions[mds] = s;
391 ceph_con_open(&s->s_con, ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
406 dout("__unregister_session mds%d %p\n", s->s_mds, s);
556 * Choose mds to send request to next. If there is a hint set in the
557 * request (e.g., due to a prior forward hint from the mds), use that.
559 * appropriate mds. If all else fails, choose randomly.
577 int mds = -1;
582 * is there a specific mds we should try? ignore hint if we have
583 * no session and the mds is not up (active or recovering).
588 dout("choose_mds using resend_mds mds%d\n",
641 mds = frag.dist[r];
643 "frag %u mds%d (%d/%d)\n",
645 frag.frag, frag.mds,
647 return mds;
652 * authoritative mds. */
654 if (frag.mds >= 0) {
655 /* choose auth mds */
656 mds = frag.mds;
658 "frag %u mds%d (auth)\n",
659 inode, ceph_vinop(inode), frag.frag, mds);
660 return mds;
675 mds = cap->session->s_mds;
676 dout("choose_mds %p %llx.%llx mds%d (%scap %p)\n",
677 inode, ceph_vinop(inode), mds,
680 return mds;
683 mds = ceph_mdsmap_get_random_mds(mdsc->mdsmap);
684 dout("choose_mds chose random mds%d\n", mds);
685 return mds;
718 int mds = session->s_mds;
720 /* wait for mds to go active? */
721 mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds);
722 dout("open_session to mds%d (%s)\n", mds,
736 * open sessions for any export targets for the given mds
745 int i, mds = session->s_mds;
748 if (mds >= mdsc->mdsmap->m_max_mds)
750 mi = &mdsc->mdsmap->m_info[mds];
751 dout("open_export_target_sessions for mds%d (%d targets)\n",
766 dout(" mds%d target mds%d %p is %s\n", session->s_mds,
823 dout("iterate_session_caps %p mds%d\n", session, session->s_mds);
958 dout("wake_up_session_caps %p mds%d\n", session, session->s_mds);
977 pr_info("mds%d caps stale\n", session->s_mds);
980 /* do not try to renew caps until a recovering mds has reconnected
984 dout("send_renew_caps ignoring mds%d (%s)\n",
989 dout("send_renew_caps to mds%d (%s)\n", session->s_mds,
1019 pr_info("mds%d caps renewed\n", session->s_mds);
1022 pr_info("mds%d caps still stale\n", session->s_mds);
1025 dout("renewed_caps mds%d ttl now %lu, was %s, now %s\n",
1042 dout("request_close_session mds%d state %s seq %lld\n",
1123 dout("trim_caps mds%d start: %d / %d, trim %d\n",
1128 dout("trim_caps mds%d done: %d / %d, trimmed %d\n",
1152 dout("add_cap_releases %p mds%d extra %d\n", session, session->s_mds,
1208 int mds, ret = 1;
1212 for (mds = 0; ret && mds < mdsc->max_sessions; mds++) {
1213 struct ceph_mds_session *session = mdsc->sessions[mds];
1231 "seq %lld <= %lld to mds%d\n", inode,
1259 dout("send_cap_releases mds%d\n", session->s_mds);
1267 dout("send_cap_releases mds%d %p\n", session->s_mds, msg);
1281 dout("discard_cap_releases mds%d\n", session->s_mds);
1289 dout("discard_cap_releases mds%d %p %u\n", session->s_mds, msg, num);
1301 dout("discard_cap_releases mds%d %p %u\n", session->s_mds, msg,
1317 * Create an mds request.
1530 int mds)
1601 mds, req->r_inode_drop, req->r_inode_unless, 0);
1604 mds, req->r_dentry_drop, req->r_dentry_unless);
1607 mds, req->r_old_dentry_drop, req->r_old_dentry_unless);
1611 mds, req->r_old_inode_drop, req->r_old_inode_unless, 0);
1651 int mds)
1657 req->r_mds = mds;
1661 ceph_get_cap_for_mds(ceph_inode(req->r_inode), mds);
1701 msg = create_request_message(mdsc, req, mds);
1731 int mds = -1;
1744 mds = __choose_mds(mdsc, req);
1745 if (mds < 0 ||
1746 ceph_mdsmap_get_state(mdsc->mdsmap, mds) < CEPH_MDS_STATE_ACTIVE) {
1747 dout("do_request no mds or not active, waiting for map\n");
1753 session = __ceph_lookup_mds_session(mdsc, mds);
1755 session = register_session(mdsc, mds);
1761 dout("do_request mds%d session %p state %s\n", mds, session,
1774 req->r_resend_mds = -1; /* forget any previous mds hint */
1779 err = __prepare_send_request(mdsc, req, mds);
1811 * Wake up threads with requests pending for @mds, so that they can
1812 * resubmit their requests to a possibly different mds.
1814 static void kick_requests(struct ceph_mds_client *mdsc, int mds)
1819 dout("kick_requests mds%d\n", mds);
1825 req->r_session->s_mds == mds) {
1844 * Synchrously perform an mds request. Take care of all of the
1942 * Handle mds reply.
1956 int mds = session->s_mds;
1977 pr_err("mdsc_handle_reply got %llu on session mds%d"
1978 " not mds%d\n", tid, session->s_mds,
1987 pr_warning("got a dup %s reply on %llu from mds%d\n",
1988 head->safe ? "safe" : "unsafe", tid, mds);
1993 pr_warning("got unsafe after safe on %llu from mds%d\n",
1994 tid, mds);
2049 dout("got safe reply %llu, mds%d\n", tid, mds);
2070 pr_err("mdsc_handle_reply got corrupt reply mds%d\n", mds);
2125 * handle mds notification that our request has been forwarded.
2146 dout("forward tid %llu to mds%d - req dne\n", tid, next_mds);
2154 dout("forward tid %llu to mds%d - old seq %d <= %d\n",
2157 /* resend. forward race not possible; mds would drop */
2158 dout("forward tid %llu to mds%d (we resend)\n", tid, next_mds);
2176 * handle a mds session control message
2184 int mds = session->s_mds;
2202 dout("handle_session mds%d %s %p state %s seq %llu\n",
2203 mds, ceph_session_op_name(op), session,
2208 pr_info("mds%d came back\n", session->s_mds);
2214 pr_info("mds%d reconnect success\n", session->s_mds);
2229 pr_info("mds%d reconnect denied\n", session->s_mds);
2233 kick_requests(mdsc, mds);
2237 pr_info("mds%d caps went stale, renewing\n",
2251 pr_err("mdsc_handle_session bad op %d mds%d\n", op, mds);
2264 pr_err("mdsc_handle_session corrupt message mds%d len %d\n", mds,
2280 dout("replay_unsafe_requests mds%d\n", session->s_mds);
2392 * clear which snap realms the mds cares about, we send everything we
2405 int mds = session->s_mds;
2410 pr_info("mds%d reconnect start\n", mds);
2426 ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
2451 * snaprealms. we provide mds with the ino, seq (version), and
2452 * parent for all of our realms. If the mds has any newer info,
2494 pr_err("error %d preparing reconnect for mds%d\n", err, mds);
2523 dout("check_new_map mds%d state %s%s -> %s%s (session %s)\n",
2548 /* kick any requests waiting on the recovering mds */
2551 continue; /* nothing new with this mds */
2565 * kick request on any mds that has gone active.
2571 pr_info("mds%d recovery completed\n", s->s_mds);
2587 dout(" connecting to export targets of laggy mds%d\n",
2620 int mds = session->s_mds;
2628 dout("handle_lease from mds%d\n", mds);
2729 dout("lease_send_msg inode %p dentry %p %s to mds%d\n",
2785 /* we do have a lease on this dentry; note mds and seq */
2791 dout("lease_release inode %p dentry %p mask %d to mds%d\n",
2823 * delayed work -- periodically trim expired leases, renew caps with mds
2855 dout("resending session close request for mds%d\n",
2864 pr_info("mds%d hung\n", s->s_mds);
2868 /* this mds is failed or recovering, just wait */
2935 * Wait for safe replies on open mds requests. If we time out, drop
2984 * wait for all write mds requests to flush.
3133 * handle mds map update.
3176 mdsc->mdsmap = newmap; /* first mds map */
3214 * if the client is unresponsive for long enough, the mds will kill
3222 pr_warning("mds%d closed our session\n", s->s_mds);