mds_client.c (7c1332b8cb5b27656cf6ab1f5fe808a8eb8bb2c0) mds_client.c (2600d2dd5085ab6fb09540226138a60055abf335)
1#include "ceph_debug.h"
2
3#include <linux/wait.h>
4#include <linux/sched.h>
5
6#include "mds_client.h"
7#include "mon_client.h"
8#include "super.h"

--- 295 unchanged lines hidden (view full) ---

304
305static bool __have_session(struct ceph_mds_client *mdsc, int mds)
306{
307 if (mds >= mdsc->max_sessions)
308 return false;
309 return mdsc->sessions[mds];
310}
311
1#include "ceph_debug.h"
2
3#include <linux/wait.h>
4#include <linux/sched.h>
5
6#include "mds_client.h"
7#include "mon_client.h"
8#include "super.h"

--- 295 unchanged lines hidden (view full) ---

304
305static bool __have_session(struct ceph_mds_client *mdsc, int mds)
306{
307 if (mds >= mdsc->max_sessions)
308 return false;
309 return mdsc->sessions[mds];
310}
311
312static int __verify_registered_session(struct ceph_mds_client *mdsc,
313 struct ceph_mds_session *s)
314{
315 if (s->s_mds >= mdsc->max_sessions ||
316 mdsc->sessions[s->s_mds] != s)
317 return -ENOENT;
318 return 0;
319}
320
312/*
313 * create+register a new session for given mds.
314 * called under mdsc->mutex.
315 */
316static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,
317 int mds)
318{
319 struct ceph_mds_session *s;

--- 57 unchanged lines hidden (view full) ---

377fail_realloc:
378 kfree(s);
379 return ERR_PTR(-ENOMEM);
380}
381
382/*
383 * called under mdsc->mutex
384 */
321/*
322 * create+register a new session for given mds.
323 * called under mdsc->mutex.
324 */
325static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,
326 int mds)
327{
328 struct ceph_mds_session *s;

--- 57 unchanged lines hidden (view full) ---

386fail_realloc:
387 kfree(s);
388 return ERR_PTR(-ENOMEM);
389}
390
391/*
392 * called under mdsc->mutex
393 */
385static void unregister_session(struct ceph_mds_client *mdsc,
394static void __unregister_session(struct ceph_mds_client *mdsc,
386 struct ceph_mds_session *s)
387{
395 struct ceph_mds_session *s)
396{
388 dout("unregister_session mds%d %p\n", s->s_mds, s);
397 dout("__unregister_session mds%d %p\n", s->s_mds, s);
398 BUG_ON(mdsc->sessions[s->s_mds] != s);
389 mdsc->sessions[s->s_mds] = NULL;
390 ceph_con_close(&s->s_con);
391 ceph_put_mds_session(s);
392}
393
394/*
395 * drop session refs in request.
396 *

--- 1338 unchanged lines hidden (view full) ---

1735static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
1736{
1737 struct ceph_mds_client *mdsc = session->s_mdsc;
1738 struct ceph_mds_request *req;
1739 struct ceph_mds_reply_head *head = msg->front.iov_base;
1740 struct ceph_mds_reply_info_parsed *rinfo; /* parsed reply info */
1741 u64 tid;
1742 int err, result;
399 mdsc->sessions[s->s_mds] = NULL;
400 ceph_con_close(&s->s_con);
401 ceph_put_mds_session(s);
402}
403
404/*
405 * drop session refs in request.
406 *

--- 1338 unchanged lines hidden (view full) ---

1745static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
1746{
1747 struct ceph_mds_client *mdsc = session->s_mdsc;
1748 struct ceph_mds_request *req;
1749 struct ceph_mds_reply_head *head = msg->front.iov_base;
1750 struct ceph_mds_reply_info_parsed *rinfo; /* parsed reply info */
1751 u64 tid;
1752 int err, result;
1743 int mds;
1753 int mds = session->s_mds;
1744
1754
1745 if (msg->hdr.src.name.type != CEPH_ENTITY_TYPE_MDS)
1746 return;
1747 if (msg->front.iov_len < sizeof(*head)) {
1748 pr_err("mdsc_handle_reply got corrupt (short) reply\n");
1749 ceph_msg_dump(msg);
1750 return;
1751 }
1752
1753 /* get request, session */
1754 tid = le64_to_cpu(msg->hdr.tid);
1755 mutex_lock(&mdsc->mutex);
1756 req = __lookup_request(mdsc, tid);
1757 if (!req) {
1758 dout("handle_reply on unknown tid %llu\n", tid);
1759 mutex_unlock(&mdsc->mutex);
1760 return;
1761 }
1762 dout("handle_reply %p\n", req);
1755 if (msg->front.iov_len < sizeof(*head)) {
1756 pr_err("mdsc_handle_reply got corrupt (short) reply\n");
1757 ceph_msg_dump(msg);
1758 return;
1759 }
1760
1761 /* get request, session */
1762 tid = le64_to_cpu(msg->hdr.tid);
1763 mutex_lock(&mdsc->mutex);
1764 req = __lookup_request(mdsc, tid);
1765 if (!req) {
1766 dout("handle_reply on unknown tid %llu\n", tid);
1767 mutex_unlock(&mdsc->mutex);
1768 return;
1769 }
1770 dout("handle_reply %p\n", req);
1763 mds = le64_to_cpu(msg->hdr.src.name.num);
1764
1765 /* correct session? */
1766 if (!req->r_session && req->r_session != session) {
1767 pr_err("mdsc_handle_reply got %llu on session mds%d"
1768 " not mds%d\n", tid, session->s_mds,
1769 req->r_session ? req->r_session->s_mds : -1);
1770 mutex_unlock(&mdsc->mutex);
1771 goto out;

--- 107 unchanged lines hidden (view full) ---

1879 return;
1880}
1881
1882
1883
1884/*
1885 * handle mds notification that our request has been forwarded.
1886 */
1771
1772 /* correct session? */
1773 if (!req->r_session && req->r_session != session) {
1774 pr_err("mdsc_handle_reply got %llu on session mds%d"
1775 " not mds%d\n", tid, session->s_mds,
1776 req->r_session ? req->r_session->s_mds : -1);
1777 mutex_unlock(&mdsc->mutex);
1778 goto out;

--- 107 unchanged lines hidden (view full) ---

1886 return;
1887}
1888
1889
1890
1891/*
1892 * handle mds notification that our request has been forwarded.
1893 */
1887static void handle_forward(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
1894static void handle_forward(struct ceph_mds_client *mdsc,
1895 struct ceph_mds_session *session,
1896 struct ceph_msg *msg)
1888{
1889 struct ceph_mds_request *req;
1890 u64 tid;
1891 u32 next_mds;
1892 u32 fwd_seq;
1893 u8 must_resend;
1894 int err = -EINVAL;
1895 void *p = msg->front.iov_base;
1896 void *end = p + msg->front.iov_len;
1897{
1898 struct ceph_mds_request *req;
1899 u64 tid;
1900 u32 next_mds;
1901 u32 fwd_seq;
1902 u8 must_resend;
1903 int err = -EINVAL;
1904 void *p = msg->front.iov_base;
1905 void *end = p + msg->front.iov_len;
1897 int from_mds, state;
1906 int state;
1898
1907
1899 if (msg->hdr.src.name.type != CEPH_ENTITY_TYPE_MDS)
1900 goto bad;
1901 from_mds = le64_to_cpu(msg->hdr.src.name.num);
1902
1903 ceph_decode_need(&p, end, sizeof(u64)+2*sizeof(u32), bad);
1904 tid = ceph_decode_64(&p);
1905 next_mds = ceph_decode_32(&p);
1906 fwd_seq = ceph_decode_32(&p);
1907 must_resend = ceph_decode_8(&p);
1908
1909 WARN_ON(must_resend); /* shouldn't happen. */
1910
1911 mutex_lock(&mdsc->mutex);
1912 req = __lookup_request(mdsc, tid);
1913 if (!req) {
1914 dout("forward %llu dne\n", tid);
1915 goto out; /* dup reply? */
1916 }
1917
1908 ceph_decode_need(&p, end, sizeof(u64)+2*sizeof(u32), bad);
1909 tid = ceph_decode_64(&p);
1910 next_mds = ceph_decode_32(&p);
1911 fwd_seq = ceph_decode_32(&p);
1912 must_resend = ceph_decode_8(&p);
1913
1914 WARN_ON(must_resend); /* shouldn't happen. */
1915
1916 mutex_lock(&mdsc->mutex);
1917 req = __lookup_request(mdsc, tid);
1918 if (!req) {
1919 dout("forward %llu dne\n", tid);
1920 goto out; /* dup reply? */
1921 }
1922
1923 if (next_mds >= mdsc->max_sessions)
1924 goto out;
1925
1918 state = mdsc->sessions[next_mds]->s_state;
1919 if (fwd_seq <= req->r_num_fwd) {
1920 dout("forward %llu to mds%d - old seq %d <= %d\n",
1921 tid, next_mds, req->r_num_fwd, fwd_seq);
1922 } else {
1923 /* resend. forward race not possible; mds would drop */
1924 dout("forward %llu to mds%d (we resend)\n", tid, next_mds);
1925 req->r_num_fwd = fwd_seq;

--- 14 unchanged lines hidden (view full) ---

1940 * handle a mds session control message
1941 */
1942static void handle_session(struct ceph_mds_session *session,
1943 struct ceph_msg *msg)
1944{
1945 struct ceph_mds_client *mdsc = session->s_mdsc;
1946 u32 op;
1947 u64 seq;
1926 state = mdsc->sessions[next_mds]->s_state;
1927 if (fwd_seq <= req->r_num_fwd) {
1928 dout("forward %llu to mds%d - old seq %d <= %d\n",
1929 tid, next_mds, req->r_num_fwd, fwd_seq);
1930 } else {
1931 /* resend. forward race not possible; mds would drop */
1932 dout("forward %llu to mds%d (we resend)\n", tid, next_mds);
1933 req->r_num_fwd = fwd_seq;

--- 14 unchanged lines hidden (view full) ---

1948 * handle a mds session control message
1949 */
1950static void handle_session(struct ceph_mds_session *session,
1951 struct ceph_msg *msg)
1952{
1953 struct ceph_mds_client *mdsc = session->s_mdsc;
1954 u32 op;
1955 u64 seq;
1948 int mds;
1956 int mds = session->s_mds;
1949 struct ceph_mds_session_head *h = msg->front.iov_base;
1950 int wake = 0;
1951
1957 struct ceph_mds_session_head *h = msg->front.iov_base;
1958 int wake = 0;
1959
1952 if (msg->hdr.src.name.type != CEPH_ENTITY_TYPE_MDS)
1953 return;
1954 mds = le64_to_cpu(msg->hdr.src.name.num);
1955
1956 /* decode */
1957 if (msg->front.iov_len != sizeof(*h))
1958 goto bad;
1959 op = le32_to_cpu(h->op);
1960 seq = le64_to_cpu(h->seq);
1961
1962 mutex_lock(&mdsc->mutex);
1960 /* decode */
1961 if (msg->front.iov_len != sizeof(*h))
1962 goto bad;
1963 op = le32_to_cpu(h->op);
1964 seq = le64_to_cpu(h->seq);
1965
1966 mutex_lock(&mdsc->mutex);
1967 if (op == CEPH_SESSION_CLOSE)
1968 __unregister_session(mdsc, session);
1963 /* FIXME: this ttl calculation is generous */
1964 session->s_ttl = jiffies + HZ*mdsc->mdsmap->m_session_autoclose;
1965 mutex_unlock(&mdsc->mutex);
1966
1967 mutex_lock(&session->s_mutex);
1968
1969 dout("handle_session mds%d %s %p state %s seq %llu\n",
1970 mds, ceph_session_op_name(op), session,

--- 14 unchanged lines hidden (view full) ---

1985 break;
1986
1987 case CEPH_SESSION_RENEWCAPS:
1988 if (session->s_renew_seq == seq)
1989 renewed_caps(mdsc, session, 1);
1990 break;
1991
1992 case CEPH_SESSION_CLOSE:
1969 /* FIXME: this ttl calculation is generous */
1970 session->s_ttl = jiffies + HZ*mdsc->mdsmap->m_session_autoclose;
1971 mutex_unlock(&mdsc->mutex);
1972
1973 mutex_lock(&session->s_mutex);
1974
1975 dout("handle_session mds%d %s %p state %s seq %llu\n",
1976 mds, ceph_session_op_name(op), session,

--- 14 unchanged lines hidden (view full) ---

1991 break;
1992
1993 case CEPH_SESSION_RENEWCAPS:
1994 if (session->s_renew_seq == seq)
1995 renewed_caps(mdsc, session, 1);
1996 break;
1997
1998 case CEPH_SESSION_CLOSE:
1993 unregister_session(mdsc, session);
1994 remove_session_caps(session);
1995 wake = 1; /* for good measure */
1996 complete(&mdsc->session_close_waiters);
1997 kick_requests(mdsc, mds, 0); /* cur only */
1998 break;
1999
2000 case CEPH_SESSION_STALE:
2001 pr_info("mds%d caps went stale, renewing\n",

--- 262 unchanged lines hidden (view full) ---

2264
2265 if (memcmp(ceph_mdsmap_get_addr(oldmap, i),
2266 ceph_mdsmap_get_addr(newmap, i),
2267 sizeof(struct ceph_entity_addr))) {
2268 if (s->s_state == CEPH_MDS_SESSION_OPENING) {
2269 /* the session never opened, just close it
2270 * out now */
2271 __wake_requests(mdsc, &s->s_waiting);
1999 remove_session_caps(session);
2000 wake = 1; /* for good measure */
2001 complete(&mdsc->session_close_waiters);
2002 kick_requests(mdsc, mds, 0); /* cur only */
2003 break;
2004
2005 case CEPH_SESSION_STALE:
2006 pr_info("mds%d caps went stale, renewing\n",

--- 262 unchanged lines hidden (view full) ---

2269
2270 if (memcmp(ceph_mdsmap_get_addr(oldmap, i),
2271 ceph_mdsmap_get_addr(newmap, i),
2272 sizeof(struct ceph_entity_addr))) {
2273 if (s->s_state == CEPH_MDS_SESSION_OPENING) {
2274 /* the session never opened, just close it
2275 * out now */
2276 __wake_requests(mdsc, &s->s_waiting);
2272 unregister_session(mdsc, s);
2277 __unregister_session(mdsc, s);
2273 } else {
2274 /* just close it */
2275 mutex_unlock(&mdsc->mutex);
2276 mutex_lock(&s->s_mutex);
2277 mutex_lock(&mdsc->mutex);
2278 ceph_con_close(&s->s_con);
2279 mutex_unlock(&s->s_mutex);
2280 s->s_state = CEPH_MDS_SESSION_RESTARTING;

--- 43 unchanged lines hidden (view full) ---

2324void __ceph_mdsc_drop_dentry_lease(struct dentry *dentry)
2325{
2326 struct ceph_dentry_info *di = ceph_dentry(dentry);
2327
2328 ceph_put_mds_session(di->lease_session);
2329 di->lease_session = NULL;
2330}
2331
2278 } else {
2279 /* just close it */
2280 mutex_unlock(&mdsc->mutex);
2281 mutex_lock(&s->s_mutex);
2282 mutex_lock(&mdsc->mutex);
2283 ceph_con_close(&s->s_con);
2284 mutex_unlock(&s->s_mutex);
2285 s->s_state = CEPH_MDS_SESSION_RESTARTING;

--- 43 unchanged lines hidden (view full) ---

2329void __ceph_mdsc_drop_dentry_lease(struct dentry *dentry)
2330{
2331 struct ceph_dentry_info *di = ceph_dentry(dentry);
2332
2333 ceph_put_mds_session(di->lease_session);
2334 di->lease_session = NULL;
2335}
2336
2332static void handle_lease(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
2337static void handle_lease(struct ceph_mds_client *mdsc,
2338 struct ceph_mds_session *session,
2339 struct ceph_msg *msg)
2333{
2334 struct super_block *sb = mdsc->client->sb;
2335 struct inode *inode;
2340{
2341 struct super_block *sb = mdsc->client->sb;
2342 struct inode *inode;
2336 struct ceph_mds_session *session;
2337 struct ceph_inode_info *ci;
2338 struct dentry *parent, *dentry;
2339 struct ceph_dentry_info *di;
2343 struct ceph_inode_info *ci;
2344 struct dentry *parent, *dentry;
2345 struct ceph_dentry_info *di;
2340 int mds;
2346 int mds = session->s_mds;
2341 struct ceph_mds_lease *h = msg->front.iov_base;
2342 struct ceph_vino vino;
2343 int mask;
2344 struct qstr dname;
2345 int release = 0;
2346
2347 struct ceph_mds_lease *h = msg->front.iov_base;
2348 struct ceph_vino vino;
2349 int mask;
2350 struct qstr dname;
2351 int release = 0;
2352
2347 if (msg->hdr.src.name.type != CEPH_ENTITY_TYPE_MDS)
2348 return;
2349 mds = le64_to_cpu(msg->hdr.src.name.num);
2350 dout("handle_lease from mds%d\n", mds);
2351
2352 /* decode */
2353 if (msg->front.iov_len < sizeof(*h) + sizeof(u32))
2354 goto bad;
2355 vino.ino = le64_to_cpu(h->ino);
2356 vino.snap = CEPH_NOSNAP;
2357 mask = le16_to_cpu(h->mask);
2358 dname.name = (void *)h + sizeof(*h) + sizeof(u32);
2359 dname.len = msg->front.iov_len - sizeof(*h) - sizeof(u32);
2360 if (dname.len != get_unaligned_le32(h+1))
2361 goto bad;
2362
2353 dout("handle_lease from mds%d\n", mds);
2354
2355 /* decode */
2356 if (msg->front.iov_len < sizeof(*h) + sizeof(u32))
2357 goto bad;
2358 vino.ino = le64_to_cpu(h->ino);
2359 vino.snap = CEPH_NOSNAP;
2360 mask = le16_to_cpu(h->mask);
2361 dname.name = (void *)h + sizeof(*h) + sizeof(u32);
2362 dname.len = msg->front.iov_len - sizeof(*h) - sizeof(u32);
2363 if (dname.len != get_unaligned_le32(h+1))
2364 goto bad;
2365
2363 /* find session */
2364 mutex_lock(&mdsc->mutex);
2365 session = __ceph_lookup_mds_session(mdsc, mds);
2366 mutex_unlock(&mdsc->mutex);
2367 if (!session) {
2368 pr_err("handle_lease got lease but no session mds%d\n", mds);
2369 return;
2370 }
2371
2372 mutex_lock(&session->s_mutex);
2373 session->s_seq++;
2374
2375 /* lookup inode */
2376 inode = ceph_find_inode(sb, vino);
2377 dout("handle_lease '%s', mask %d, ino %llx %p\n",
2378 ceph_lease_op_name(h->action), mask, vino.ino, inode);
2379 if (inode == NULL) {

--- 52 unchanged lines hidden (view full) ---

2432 /* let's just reuse the same message */
2433 h->action = CEPH_MDS_LEASE_REVOKE_ACK;
2434 ceph_msg_get(msg);
2435 ceph_con_send(&session->s_con, msg);
2436
2437out:
2438 iput(inode);
2439 mutex_unlock(&session->s_mutex);
2366 mutex_lock(&session->s_mutex);
2367 session->s_seq++;
2368
2369 /* lookup inode */
2370 inode = ceph_find_inode(sb, vino);
2371 dout("handle_lease '%s', mask %d, ino %llx %p\n",
2372 ceph_lease_op_name(h->action), mask, vino.ino, inode);
2373 if (inode == NULL) {

--- 52 unchanged lines hidden (view full) ---

2426 /* let's just reuse the same message */
2427 h->action = CEPH_MDS_LEASE_REVOKE_ACK;
2428 ceph_msg_get(msg);
2429 ceph_con_send(&session->s_con, msg);
2430
2431out:
2432 iput(inode);
2433 mutex_unlock(&session->s_mutex);
2440 ceph_put_mds_session(session);
2441 return;
2442
2443bad:
2444 pr_err("corrupt lease message\n");
2445 ceph_msg_dump(msg);
2446}
2447
2448void ceph_mdsc_lease_send_msg(struct ceph_mds_session *session,

--- 340 unchanged lines hidden (view full) ---

2789 timeout);
2790 mutex_lock(&mdsc->mutex);
2791 }
2792
2793 /* tear down remaining sessions */
2794 for (i = 0; i < mdsc->max_sessions; i++) {
2795 if (mdsc->sessions[i]) {
2796 session = get_session(mdsc->sessions[i]);
2434 return;
2435
2436bad:
2437 pr_err("corrupt lease message\n");
2438 ceph_msg_dump(msg);
2439}
2440
2441void ceph_mdsc_lease_send_msg(struct ceph_mds_session *session,

--- 340 unchanged lines hidden (view full) ---

2782 timeout);
2783 mutex_lock(&mdsc->mutex);
2784 }
2785
2786 /* tear down remaining sessions */
2787 for (i = 0; i < mdsc->max_sessions; i++) {
2788 if (mdsc->sessions[i]) {
2789 session = get_session(mdsc->sessions[i]);
2797 unregister_session(mdsc, session);
2790 __unregister_session(mdsc, session);
2798 mutex_unlock(&mdsc->mutex);
2799 mutex_lock(&session->s_mutex);
2800 remove_session_caps(session);
2801 mutex_unlock(&session->s_mutex);
2802 ceph_put_mds_session(session);
2803 mutex_lock(&mdsc->mutex);
2804 }
2805 }

--- 80 unchanged lines hidden (view full) ---

2886 return;
2887}
2888
2889static struct ceph_connection *con_get(struct ceph_connection *con)
2890{
2891 struct ceph_mds_session *s = con->private;
2892
2893 if (get_session(s)) {
2791 mutex_unlock(&mdsc->mutex);
2792 mutex_lock(&session->s_mutex);
2793 remove_session_caps(session);
2794 mutex_unlock(&session->s_mutex);
2795 ceph_put_mds_session(session);
2796 mutex_lock(&mdsc->mutex);
2797 }
2798 }

--- 80 unchanged lines hidden (view full) ---

2879 return;
2880}
2881
2882static struct ceph_connection *con_get(struct ceph_connection *con)
2883{
2884 struct ceph_mds_session *s = con->private;
2885
2886 if (get_session(s)) {
2894 dout("mdsc con_get %p %d -> %d\n", s,
2895 atomic_read(&s->s_ref) - 1, atomic_read(&s->s_ref));
2887 dout("mdsc con_get %p ok (%d)\n", s, atomic_read(&s->s_ref));
2896 return con;
2897 }
2898 dout("mdsc con_get %p FAIL\n", s);
2899 return NULL;
2900}
2901
2902static void con_put(struct ceph_connection *con)
2903{
2904 struct ceph_mds_session *s = con->private;
2905
2888 return con;
2889 }
2890 dout("mdsc con_get %p FAIL\n", s);
2891 return NULL;
2892}
2893
2894static void con_put(struct ceph_connection *con)
2895{
2896 struct ceph_mds_session *s = con->private;
2897
2906 dout("mdsc con_put %p %d -> %d\n", s, atomic_read(&s->s_ref),
2907 atomic_read(&s->s_ref) - 1);
2908 ceph_put_mds_session(s);
2898 ceph_put_mds_session(s);
2899 dout("mdsc con_put %p (%d)\n", s, atomic_read(&s->s_ref));
2909}
2910
2911/*
2912 * if the client is unresponsive for long enough, the mds will kill
2913 * the session entirely.
2914 */
2915static void peer_reset(struct ceph_connection *con)
2916{

--- 4 unchanged lines hidden (view full) ---

2921}
2922
2923static void dispatch(struct ceph_connection *con, struct ceph_msg *msg)
2924{
2925 struct ceph_mds_session *s = con->private;
2926 struct ceph_mds_client *mdsc = s->s_mdsc;
2927 int type = le16_to_cpu(msg->hdr.type);
2928
2900}
2901
2902/*
2903 * if the client is unresponsive for long enough, the mds will kill
2904 * the session entirely.
2905 */
2906static void peer_reset(struct ceph_connection *con)
2907{

--- 4 unchanged lines hidden (view full) ---

2912}
2913
2914static void dispatch(struct ceph_connection *con, struct ceph_msg *msg)
2915{
2916 struct ceph_mds_session *s = con->private;
2917 struct ceph_mds_client *mdsc = s->s_mdsc;
2918 int type = le16_to_cpu(msg->hdr.type);
2919
2920 mutex_lock(&mdsc->mutex);
2921 if (__verify_registered_session(mdsc, s) < 0) {
2922 mutex_unlock(&mdsc->mutex);
2923 goto out;
2924 }
2925 mutex_unlock(&mdsc->mutex);
2926
2929 switch (type) {
2930 case CEPH_MSG_MDS_MAP:
2931 ceph_mdsc_handle_map(mdsc, msg);
2932 break;
2933 case CEPH_MSG_CLIENT_SESSION:
2934 handle_session(s, msg);
2935 break;
2936 case CEPH_MSG_CLIENT_REPLY:
2937 handle_reply(s, msg);
2938 break;
2939 case CEPH_MSG_CLIENT_REQUEST_FORWARD:
2927 switch (type) {
2928 case CEPH_MSG_MDS_MAP:
2929 ceph_mdsc_handle_map(mdsc, msg);
2930 break;
2931 case CEPH_MSG_CLIENT_SESSION:
2932 handle_session(s, msg);
2933 break;
2934 case CEPH_MSG_CLIENT_REPLY:
2935 handle_reply(s, msg);
2936 break;
2937 case CEPH_MSG_CLIENT_REQUEST_FORWARD:
2940 handle_forward(mdsc, msg);
2938 handle_forward(mdsc, s, msg);
2941 break;
2942 case CEPH_MSG_CLIENT_CAPS:
2943 ceph_handle_caps(s, msg);
2944 break;
2945 case CEPH_MSG_CLIENT_SNAP:
2939 break;
2940 case CEPH_MSG_CLIENT_CAPS:
2941 ceph_handle_caps(s, msg);
2942 break;
2943 case CEPH_MSG_CLIENT_SNAP:
2946 ceph_handle_snap(mdsc, msg);
2944 ceph_handle_snap(mdsc, s, msg);
2947 break;
2948 case CEPH_MSG_CLIENT_LEASE:
2945 break;
2946 case CEPH_MSG_CLIENT_LEASE:
2949 handle_lease(mdsc, msg);
2947 handle_lease(mdsc, s, msg);
2950 break;
2951
2952 default:
2953 pr_err("received unknown message type %d %s\n", type,
2954 ceph_msg_type_name(type));
2955 }
2948 break;
2949
2950 default:
2951 pr_err("received unknown message type %d %s\n", type,
2952 ceph_msg_type_name(type));
2953 }
2954out:
2956 ceph_msg_put(msg);
2957}
2958
2959/*
2960 * authentication
2961 */
2962static int get_authorizer(struct ceph_connection *con,
2963 void **buf, int *len, int *proto,

--- 69 unchanged lines hidden --- 		2955 ceph_msg_put(msg);
2956}
2957
2958/*
2959 * authentication
2960 */
2961static int get_authorizer(struct ceph_connection *con,
2962 void **buf, int *len, int *proto,

--- 69 unchanged lines hidden ---