| // SPDX-License-Identifier: GPL-2.0 |
| #include <linux/ceph/ceph_debug.h> |
| |
| #include <linux/fs.h> |
| #include <linux/wait.h> |
| #include <linux/slab.h> |
| #include <linux/gfp.h> |
| #include <linux/sched.h> |
| #include <linux/debugfs.h> |
| #include <linux/seq_file.h> |
| #include <linux/ratelimit.h> |
| #include <linux/bits.h> |
| #include <linux/ktime.h> |
| #include <linux/bitmap.h> |
| |
| #include "super.h" |
| #include "mds_client.h" |
| |
| #include <linux/ceph/ceph_features.h> |
| #include <linux/ceph/messenger.h> |
| #include <linux/ceph/decode.h> |
| #include <linux/ceph/pagelist.h> |
| #include <linux/ceph/auth.h> |
| #include <linux/ceph/debugfs.h> |
| |
| #define RECONNECT_MAX_SIZE (INT_MAX - PAGE_SIZE) |
| |
| /* |
| * A cluster of MDS (metadata server) daemons is responsible for |
| * managing the file system namespace (the directory hierarchy and |
| * inodes) and for coordinating shared access to storage. Metadata is |
| * partitioning hierarchically across a number of servers, and that |
| * partition varies over time as the cluster adjusts the distribution |
| * in order to balance load. |
| * |
| * The MDS client is primarily responsible to managing synchronous |
| * metadata requests for operations like open, unlink, and so forth. |
| * If there is a MDS failure, we find out about it when we (possibly |
| * request and) receive a new MDS map, and can resubmit affected |
| * requests. |
| * |
| * For the most part, though, we take advantage of a lossless |
| * communications channel to the MDS, and do not need to worry about |
| * timing out or resubmitting requests. |
| * |
| * We maintain a stateful "session" with each MDS we interact with. |
| * Within each session, we sent periodic heartbeat messages to ensure |
| * any capabilities or leases we have been issues remain valid. If |
| * the session times out and goes stale, our leases and capabilities |
| * are no longer valid. |
| */ |
| |
| struct ceph_reconnect_state { |
| struct ceph_mds_session *session; |
| int nr_caps, nr_realms; |
| struct ceph_pagelist *pagelist; |
| unsigned msg_version; |
| bool allow_multi; |
| }; |
| |
| static void __wake_requests(struct ceph_mds_client *mdsc, |
| struct list_head *head); |
| static void ceph_cap_release_work(struct work_struct *work); |
| static void ceph_cap_reclaim_work(struct work_struct *work); |
| |
| static const struct ceph_connection_operations mds_con_ops; |
| |
| |
| /* |
| * mds reply parsing |
| */ |
| |
| static int parse_reply_info_quota(void **p, void *end, |
| struct ceph_mds_reply_info_in *info) |
| { |
| u8 struct_v, struct_compat; |
| u32 struct_len; |
| |
| ceph_decode_8_safe(p, end, struct_v, bad); |
| ceph_decode_8_safe(p, end, struct_compat, bad); |
| /* struct_v is expected to be >= 1. we only |
| * understand encoding with struct_compat == 1. */ |
| if (!struct_v || struct_compat != 1) |
| goto bad; |
| ceph_decode_32_safe(p, end, struct_len, bad); |
| ceph_decode_need(p, end, struct_len, bad); |
| end = *p + struct_len; |
| ceph_decode_64_safe(p, end, info->max_bytes, bad); |
| ceph_decode_64_safe(p, end, info->max_files, bad); |
| *p = end; |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| /* |
| * parse individual inode info |
| */ |
| static int parse_reply_info_in(void **p, void *end, |
| struct ceph_mds_reply_info_in *info, |
| u64 features) |
| { |
| int err = 0; |
| u8 struct_v = 0; |
| |
| if (features == (u64)-1) { |
| u32 struct_len; |
| u8 struct_compat; |
| ceph_decode_8_safe(p, end, struct_v, bad); |
| ceph_decode_8_safe(p, end, struct_compat, bad); |
| /* struct_v is expected to be >= 1. we only understand |
| * encoding with struct_compat == 1. */ |
| if (!struct_v || struct_compat != 1) |
| goto bad; |
| ceph_decode_32_safe(p, end, struct_len, bad); |
| ceph_decode_need(p, end, struct_len, bad); |
| end = *p + struct_len; |
| } |
| |
| ceph_decode_need(p, end, sizeof(struct ceph_mds_reply_inode), bad); |
| info->in = *p; |
| *p += sizeof(struct ceph_mds_reply_inode) + |
| sizeof(*info->in->fragtree.splits) * |
| le32_to_cpu(info->in->fragtree.nsplits); |
| |
| ceph_decode_32_safe(p, end, info->symlink_len, bad); |
| ceph_decode_need(p, end, info->symlink_len, bad); |
| info->symlink = *p; |
| *p += info->symlink_len; |
| |
| ceph_decode_copy_safe(p, end, &info->dir_layout, |
| sizeof(info->dir_layout), bad); |
| ceph_decode_32_safe(p, end, info->xattr_len, bad); |
| ceph_decode_need(p, end, info->xattr_len, bad); |
| info->xattr_data = *p; |
| *p += info->xattr_len; |
| |
| if (features == (u64)-1) { |
| /* inline data */ |
| ceph_decode_64_safe(p, end, info->inline_version, bad); |
| ceph_decode_32_safe(p, end, info->inline_len, bad); |
| ceph_decode_need(p, end, info->inline_len, bad); |
| info->inline_data = *p; |
| *p += info->inline_len; |
| /* quota */ |
| err = parse_reply_info_quota(p, end, info); |
| if (err < 0) |
| goto out_bad; |
| /* pool namespace */ |
| ceph_decode_32_safe(p, end, info->pool_ns_len, bad); |
| if (info->pool_ns_len > 0) { |
| ceph_decode_need(p, end, info->pool_ns_len, bad); |
| info->pool_ns_data = *p; |
| *p += info->pool_ns_len; |
| } |
| |
| /* btime */ |
| ceph_decode_need(p, end, sizeof(info->btime), bad); |
| ceph_decode_copy(p, &info->btime, sizeof(info->btime)); |
| |
| /* change attribute */ |
| ceph_decode_64_safe(p, end, info->change_attr, bad); |
| |
| /* dir pin */ |
| if (struct_v >= 2) { |
| ceph_decode_32_safe(p, end, info->dir_pin, bad); |
| } else { |
| info->dir_pin = -ENODATA; |
| } |
| |
| /* snapshot birth time, remains zero for v<=2 */ |
| if (struct_v >= 3) { |
| ceph_decode_need(p, end, sizeof(info->snap_btime), bad); |
| ceph_decode_copy(p, &info->snap_btime, |
| sizeof(info->snap_btime)); |
| } else { |
| memset(&info->snap_btime, 0, sizeof(info->snap_btime)); |
| } |
| |
| /* snapshot count, remains zero for v<=3 */ |
| if (struct_v >= 4) { |
| ceph_decode_64_safe(p, end, info->rsnaps, bad); |
| } else { |
| info->rsnaps = 0; |
| } |
| |
| *p = end; |
| } else { |
| if (features & CEPH_FEATURE_MDS_INLINE_DATA) { |
| ceph_decode_64_safe(p, end, info->inline_version, bad); |
| ceph_decode_32_safe(p, end, info->inline_len, bad); |
| ceph_decode_need(p, end, info->inline_len, bad); |
| info->inline_data = *p; |
| *p += info->inline_len; |
| } else |
| info->inline_version = CEPH_INLINE_NONE; |
| |
| if (features & CEPH_FEATURE_MDS_QUOTA) { |
| err = parse_reply_info_quota(p, end, info); |
| if (err < 0) |
| goto out_bad; |
| } else { |
| info->max_bytes = 0; |
| info->max_files = 0; |
| } |
| |
| info->pool_ns_len = 0; |
| info->pool_ns_data = NULL; |
| if (features & CEPH_FEATURE_FS_FILE_LAYOUT_V2) { |
| ceph_decode_32_safe(p, end, info->pool_ns_len, bad); |
| if (info->pool_ns_len > 0) { |
| ceph_decode_need(p, end, info->pool_ns_len, bad); |
| info->pool_ns_data = *p; |
| *p += info->pool_ns_len; |
| } |
| } |
| |
| if (features & CEPH_FEATURE_FS_BTIME) { |
| ceph_decode_need(p, end, sizeof(info->btime), bad); |
| ceph_decode_copy(p, &info->btime, sizeof(info->btime)); |
| ceph_decode_64_safe(p, end, info->change_attr, bad); |
| } |
| |
| info->dir_pin = -ENODATA; |
| /* info->snap_btime and info->rsnaps remain zero */ |
| } |
| return 0; |
| bad: |
| err = -EIO; |
| out_bad: |
| return err; |
| } |
| |
| static int parse_reply_info_dir(void **p, void *end, |
| struct ceph_mds_reply_dirfrag **dirfrag, |
| u64 features) |
| { |
| if (features == (u64)-1) { |
| u8 struct_v, struct_compat; |
| u32 struct_len; |
| ceph_decode_8_safe(p, end, struct_v, bad); |
| ceph_decode_8_safe(p, end, struct_compat, bad); |
| /* struct_v is expected to be >= 1. we only understand |
| * encoding whose struct_compat == 1. */ |
| if (!struct_v || struct_compat != 1) |
| goto bad; |
| ceph_decode_32_safe(p, end, struct_len, bad); |
| ceph_decode_need(p, end, struct_len, bad); |
| end = *p + struct_len; |
| } |
| |
| ceph_decode_need(p, end, sizeof(**dirfrag), bad); |
| *dirfrag = *p; |
| *p += sizeof(**dirfrag) + sizeof(u32) * le32_to_cpu((*dirfrag)->ndist); |
| if (unlikely(*p > end)) |
| goto bad; |
| if (features == (u64)-1) |
| *p = end; |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| static int parse_reply_info_lease(void **p, void *end, |
| struct ceph_mds_reply_lease **lease, |
| u64 features) |
| { |
| if (features == (u64)-1) { |
| u8 struct_v, struct_compat; |
| u32 struct_len; |
| ceph_decode_8_safe(p, end, struct_v, bad); |
| ceph_decode_8_safe(p, end, struct_compat, bad); |
| /* struct_v is expected to be >= 1. we only understand |
| * encoding whose struct_compat == 1. */ |
| if (!struct_v || struct_compat != 1) |
| goto bad; |
| ceph_decode_32_safe(p, end, struct_len, bad); |
| ceph_decode_need(p, end, struct_len, bad); |
| end = *p + struct_len; |
| } |
| |
| ceph_decode_need(p, end, sizeof(**lease), bad); |
| *lease = *p; |
| *p += sizeof(**lease); |
| if (features == (u64)-1) |
| *p = end; |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| /* |
| * parse a normal reply, which may contain a (dir+)dentry and/or a |
| * target inode. |
| */ |
| static int parse_reply_info_trace(void **p, void *end, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features) |
| { |
| int err; |
| |
| if (info->head->is_dentry) { |
| err = parse_reply_info_in(p, end, &info->diri, features); |
| if (err < 0) |
| goto out_bad; |
| |
| err = parse_reply_info_dir(p, end, &info->dirfrag, features); |
| if (err < 0) |
| goto out_bad; |
| |
| ceph_decode_32_safe(p, end, info->dname_len, bad); |
| ceph_decode_need(p, end, info->dname_len, bad); |
| info->dname = *p; |
| *p += info->dname_len; |
| |
| err = parse_reply_info_lease(p, end, &info->dlease, features); |
| if (err < 0) |
| goto out_bad; |
| } |
| |
| if (info->head->is_target) { |
| err = parse_reply_info_in(p, end, &info->targeti, features); |
| if (err < 0) |
| goto out_bad; |
| } |
| |
| if (unlikely(*p != end)) |
| goto bad; |
| return 0; |
| |
| bad: |
| err = -EIO; |
| out_bad: |
| pr_err("problem parsing mds trace %d\n", err); |
| return err; |
| } |
| |
| /* |
| * parse readdir results |
| */ |
| static int parse_reply_info_readdir(void **p, void *end, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features) |
| { |
| u32 num, i = 0; |
| int err; |
| |
| err = parse_reply_info_dir(p, end, &info->dir_dir, features); |
| if (err < 0) |
| goto out_bad; |
| |
| ceph_decode_need(p, end, sizeof(num) + 2, bad); |
| num = ceph_decode_32(p); |
| { |
| u16 flags = ceph_decode_16(p); |
| info->dir_end = !!(flags & CEPH_READDIR_FRAG_END); |
| info->dir_complete = !!(flags & CEPH_READDIR_FRAG_COMPLETE); |
| info->hash_order = !!(flags & CEPH_READDIR_HASH_ORDER); |
| info->offset_hash = !!(flags & CEPH_READDIR_OFFSET_HASH); |
| } |
| if (num == 0) |
| goto done; |
| |
| BUG_ON(!info->dir_entries); |
| if ((unsigned long)(info->dir_entries + num) > |
| (unsigned long)info->dir_entries + info->dir_buf_size) { |
| pr_err("dir contents are larger than expected\n"); |
| WARN_ON(1); |
| goto bad; |
| } |
| |
| info->dir_nr = num; |
| while (num) { |
| struct ceph_mds_reply_dir_entry *rde = info->dir_entries + i; |
| /* dentry */ |
| ceph_decode_32_safe(p, end, rde->name_len, bad); |
| ceph_decode_need(p, end, rde->name_len, bad); |
| rde->name = *p; |
| *p += rde->name_len; |
| dout("parsed dir dname '%.*s'\n", rde->name_len, rde->name); |
| |
| /* dentry lease */ |
| err = parse_reply_info_lease(p, end, &rde->lease, features); |
| if (err) |
| goto out_bad; |
| /* inode */ |
| err = parse_reply_info_in(p, end, &rde->inode, features); |
| if (err < 0) |
| goto out_bad; |
| /* ceph_readdir_prepopulate() will update it */ |
| rde->offset = 0; |
| i++; |
| num--; |
| } |
| |
| done: |
| /* Skip over any unrecognized fields */ |
| *p = end; |
| return 0; |
| |
| bad: |
| err = -EIO; |
| out_bad: |
| pr_err("problem parsing dir contents %d\n", err); |
| return err; |
| } |
| |
| /* |
| * parse fcntl F_GETLK results |
| */ |
| static int parse_reply_info_filelock(void **p, void *end, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features) |
| { |
| if (*p + sizeof(*info->filelock_reply) > end) |
| goto bad; |
| |
| info->filelock_reply = *p; |
| |
| /* Skip over any unrecognized fields */ |
| *p = end; |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| |
| #if BITS_PER_LONG == 64 |
| |
| #define DELEGATED_INO_AVAILABLE xa_mk_value(1) |
| |
| static int ceph_parse_deleg_inos(void **p, void *end, |
| struct ceph_mds_session *s) |
| { |
| u32 sets; |
| |
| ceph_decode_32_safe(p, end, sets, bad); |
| dout("got %u sets of delegated inodes\n", sets); |
| while (sets--) { |
| u64 start, len, ino; |
| |
| ceph_decode_64_safe(p, end, start, bad); |
| ceph_decode_64_safe(p, end, len, bad); |
| |
| /* Don't accept a delegation of system inodes */ |
| if (start < CEPH_INO_SYSTEM_BASE) { |
| pr_warn_ratelimited("ceph: ignoring reserved inode range delegation (start=0x%llx len=0x%llx)\n", |
| start, len); |
| continue; |
| } |
| while (len--) { |
| int err = xa_insert(&s->s_delegated_inos, ino = start++, |
| DELEGATED_INO_AVAILABLE, |
| GFP_KERNEL); |
| if (!err) { |
| dout("added delegated inode 0x%llx\n", |
| start - 1); |
| } else if (err == -EBUSY) { |
| pr_warn("ceph: MDS delegated inode 0x%llx more than once.\n", |
| start - 1); |
| } else { |
| return err; |
| } |
| } |
| } |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| u64 ceph_get_deleg_ino(struct ceph_mds_session *s) |
| { |
| unsigned long ino; |
| void *val; |
| |
| xa_for_each(&s->s_delegated_inos, ino, val) { |
| val = xa_erase(&s->s_delegated_inos, ino); |
| if (val == DELEGATED_INO_AVAILABLE) |
| return ino; |
| } |
| return 0; |
| } |
| |
| int ceph_restore_deleg_ino(struct ceph_mds_session *s, u64 ino) |
| { |
| return xa_insert(&s->s_delegated_inos, ino, DELEGATED_INO_AVAILABLE, |
| GFP_KERNEL); |
| } |
| #else /* BITS_PER_LONG == 64 */ |
| /* |
| * FIXME: xarrays can't handle 64-bit indexes on a 32-bit arch. For now, just |
| * ignore delegated_inos on 32 bit arch. Maybe eventually add xarrays for top |
| * and bottom words? |
| */ |
| static int ceph_parse_deleg_inos(void **p, void *end, |
| struct ceph_mds_session *s) |
| { |
| u32 sets; |
| |
| ceph_decode_32_safe(p, end, sets, bad); |
| if (sets) |
| ceph_decode_skip_n(p, end, sets * 2 * sizeof(__le64), bad); |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| u64 ceph_get_deleg_ino(struct ceph_mds_session *s) |
| { |
| return 0; |
| } |
| |
| int ceph_restore_deleg_ino(struct ceph_mds_session *s, u64 ino) |
| { |
| return 0; |
| } |
| #endif /* BITS_PER_LONG == 64 */ |
| |
| /* |
| * parse create results |
| */ |
| static int parse_reply_info_create(void **p, void *end, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features, struct ceph_mds_session *s) |
| { |
| int ret; |
| |
| if (features == (u64)-1 || |
| (features & CEPH_FEATURE_REPLY_CREATE_INODE)) { |
| if (*p == end) { |
| /* Malformed reply? */ |
| info->has_create_ino = false; |
| } else if (test_bit(CEPHFS_FEATURE_DELEG_INO, &s->s_features)) { |
| info->has_create_ino = true; |
| /* struct_v, struct_compat, and len */ |
| ceph_decode_skip_n(p, end, 2 + sizeof(u32), bad); |
| ceph_decode_64_safe(p, end, info->ino, bad); |
| ret = ceph_parse_deleg_inos(p, end, s); |
| if (ret) |
| return ret; |
| } else { |
| /* legacy */ |
| ceph_decode_64_safe(p, end, info->ino, bad); |
| info->has_create_ino = true; |
| } |
| } else { |
| if (*p != end) |
| goto bad; |
| } |
| |
| /* Skip over any unrecognized fields */ |
| *p = end; |
| return 0; |
| bad: |
| return -EIO; |
| } |
| |
| /* |
| * parse extra results |
| */ |
| static int parse_reply_info_extra(void **p, void *end, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features, struct ceph_mds_session *s) |
| { |
| u32 op = le32_to_cpu(info->head->op); |
| |
| if (op == CEPH_MDS_OP_GETFILELOCK) |
| return parse_reply_info_filelock(p, end, info, features); |
| else if (op == CEPH_MDS_OP_READDIR || op == CEPH_MDS_OP_LSSNAP) |
| return parse_reply_info_readdir(p, end, info, features); |
| else if (op == CEPH_MDS_OP_CREATE) |
| return parse_reply_info_create(p, end, info, features, s); |
| else |
| return -EIO; |
| } |
| |
| /* |
| * parse entire mds reply |
| */ |
| static int parse_reply_info(struct ceph_mds_session *s, struct ceph_msg *msg, |
| struct ceph_mds_reply_info_parsed *info, |
| u64 features) |
| { |
| void *p, *end; |
| u32 len; |
| int err; |
| |
| info->head = msg->front.iov_base; |
| p = msg->front.iov_base + sizeof(struct ceph_mds_reply_head); |
| end = p + msg->front.iov_len - sizeof(struct ceph_mds_reply_head); |
| |
| /* trace */ |
| ceph_decode_32_safe(&p, end, len, bad); |
| if (len > 0) { |
| ceph_decode_need(&p, end, len, bad); |
| err = parse_reply_info_trace(&p, p+len, info, features); |
| if (err < 0) |
| goto out_bad; |
| } |
| |
| /* extra */ |
| ceph_decode_32_safe(&p, end, len, bad); |
| if (len > 0) { |
| ceph_decode_need(&p, end, len, bad); |
| err = parse_reply_info_extra(&p, p+len, info, features, s); |
| if (err < 0) |
| goto out_bad; |
| } |
| |
| /* snap blob */ |
| ceph_decode_32_safe(&p, end, len, bad); |
| info->snapblob_len = len; |
| info->snapblob = p; |
| p += len; |
| |
| if (p != end) |
| goto bad; |
| return 0; |
| |
| bad: |
| err = -EIO; |
| out_bad: |
| pr_err("mds parse_reply err %d\n", err); |
| return err; |
| } |
| |
| static void destroy_reply_info(struct ceph_mds_reply_info_parsed *info) |
| { |
| if (!info->dir_entries) |
| return; |
| free_pages((unsigned long)info->dir_entries, get_order(info->dir_buf_size)); |
| } |
| |
| |
| /* |
| * sessions |
| */ |
| const char *ceph_session_state_name(int s) |
| { |
| switch (s) { |
| case CEPH_MDS_SESSION_NEW: return "new"; |
| case CEPH_MDS_SESSION_OPENING: return "opening"; |
| case CEPH_MDS_SESSION_OPEN: return "open"; |
| case CEPH_MDS_SESSION_HUNG: return "hung"; |
| case CEPH_MDS_SESSION_CLOSING: return "closing"; |
| case CEPH_MDS_SESSION_CLOSED: return "closed"; |
| case CEPH_MDS_SESSION_RESTARTING: return "restarting"; |
| case CEPH_MDS_SESSION_RECONNECTING: return "reconnecting"; |
| case CEPH_MDS_SESSION_REJECTED: return "rejected"; |
| default: return "???"; |
| } |
| } |
| |
| struct ceph_mds_session *ceph_get_mds_session(struct ceph_mds_session *s) |
| { |
| if (refcount_inc_not_zero(&s->s_ref)) |
| return s; |
| return NULL; |
| } |
| |
| void ceph_put_mds_session(struct ceph_mds_session *s) |
| { |
| if (IS_ERR_OR_NULL(s)) |
| return; |
| |
| if (refcount_dec_and_test(&s->s_ref)) { |
| if (s->s_auth.authorizer) |
| ceph_auth_destroy_authorizer(s->s_auth.authorizer); |
| WARN_ON(mutex_is_locked(&s->s_mutex)); |
| xa_destroy(&s->s_delegated_inos); |
| kfree(s); |
| } |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| struct ceph_mds_session *__ceph_lookup_mds_session(struct ceph_mds_client *mdsc, |
| int mds) |
| { |
| if (mds >= mdsc->max_sessions || !mdsc->sessions[mds]) |
| return NULL; |
| return ceph_get_mds_session(mdsc->sessions[mds]); |
| } |
| |
| static bool __have_session(struct ceph_mds_client *mdsc, int mds) |
| { |
| if (mds >= mdsc->max_sessions || !mdsc->sessions[mds]) |
| return false; |
| else |
| return true; |
| } |
| |
| static int __verify_registered_session(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *s) |
| { |
| if (s->s_mds >= mdsc->max_sessions || |
| mdsc->sessions[s->s_mds] != s) |
| return -ENOENT; |
| return 0; |
| } |
| |
| /* |
| * create+register a new session for given mds. |
| * called under mdsc->mutex. |
| */ |
| static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc, |
| int mds) |
| { |
| struct ceph_mds_session *s; |
| |
| if (mds >= mdsc->mdsmap->possible_max_rank) |
| return ERR_PTR(-EINVAL); |
| |
| s = kzalloc(sizeof(*s), GFP_NOFS); |
| if (!s) |
| return ERR_PTR(-ENOMEM); |
| |
| if (mds >= mdsc->max_sessions) { |
| int newmax = 1 << get_count_order(mds + 1); |
| struct ceph_mds_session **sa; |
| |
| dout("%s: realloc to %d\n", __func__, newmax); |
| sa = kcalloc(newmax, sizeof(void *), GFP_NOFS); |
| if (!sa) |
| goto fail_realloc; |
| if (mdsc->sessions) { |
| memcpy(sa, mdsc->sessions, |
| mdsc->max_sessions * sizeof(void *)); |
| kfree(mdsc->sessions); |
| } |
| mdsc->sessions = sa; |
| mdsc->max_sessions = newmax; |
| } |
| |
| dout("%s: mds%d\n", __func__, mds); |
| s->s_mdsc = mdsc; |
| s->s_mds = mds; |
| s->s_state = CEPH_MDS_SESSION_NEW; |
| mutex_init(&s->s_mutex); |
| |
| ceph_con_init(&s->s_con, s, &mds_con_ops, &mdsc->fsc->client->msgr); |
| |
| atomic_set(&s->s_cap_gen, 1); |
| s->s_cap_ttl = jiffies - 1; |
| |
| spin_lock_init(&s->s_cap_lock); |
| INIT_LIST_HEAD(&s->s_caps); |
| refcount_set(&s->s_ref, 1); |
| INIT_LIST_HEAD(&s->s_waiting); |
| INIT_LIST_HEAD(&s->s_unsafe); |
| xa_init(&s->s_delegated_inos); |
| INIT_LIST_HEAD(&s->s_cap_releases); |
| INIT_WORK(&s->s_cap_release_work, ceph_cap_release_work); |
| |
| INIT_LIST_HEAD(&s->s_cap_dirty); |
| INIT_LIST_HEAD(&s->s_cap_flushing); |
| |
| mdsc->sessions[mds] = s; |
| atomic_inc(&mdsc->num_sessions); |
| refcount_inc(&s->s_ref); /* one ref to sessions[], one to caller */ |
| |
| ceph_con_open(&s->s_con, CEPH_ENTITY_TYPE_MDS, mds, |
| ceph_mdsmap_get_addr(mdsc->mdsmap, mds)); |
| |
| return s; |
| |
| fail_realloc: |
| kfree(s); |
| return ERR_PTR(-ENOMEM); |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| static void __unregister_session(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *s) |
| { |
| dout("__unregister_session mds%d %p\n", s->s_mds, s); |
| BUG_ON(mdsc->sessions[s->s_mds] != s); |
| mdsc->sessions[s->s_mds] = NULL; |
| ceph_con_close(&s->s_con); |
| ceph_put_mds_session(s); |
| atomic_dec(&mdsc->num_sessions); |
| } |
| |
| /* |
| * drop session refs in request. |
| * |
| * should be last request ref, or hold mdsc->mutex |
| */ |
| static void put_request_session(struct ceph_mds_request *req) |
| { |
| if (req->r_session) { |
| ceph_put_mds_session(req->r_session); |
| req->r_session = NULL; |
| } |
| } |
| |
| void ceph_mdsc_iterate_sessions(struct ceph_mds_client *mdsc, |
| void (*cb)(struct ceph_mds_session *), |
| bool check_state) |
| { |
| int mds; |
| |
| mutex_lock(&mdsc->mutex); |
| for (mds = 0; mds < mdsc->max_sessions; ++mds) { |
| struct ceph_mds_session *s; |
| |
| s = __ceph_lookup_mds_session(mdsc, mds); |
| if (!s) |
| continue; |
| |
| if (check_state && !check_session_state(s)) { |
| ceph_put_mds_session(s); |
| continue; |
| } |
| |
| mutex_unlock(&mdsc->mutex); |
| cb(s); |
| ceph_put_mds_session(s); |
| mutex_lock(&mdsc->mutex); |
| } |
| mutex_unlock(&mdsc->mutex); |
| } |
| |
| void ceph_mdsc_release_request(struct kref *kref) |
| { |
| struct ceph_mds_request *req = container_of(kref, |
| struct ceph_mds_request, |
| r_kref); |
| ceph_mdsc_release_dir_caps_no_check(req); |
| destroy_reply_info(&req->r_reply_info); |
| if (req->r_request) |
| ceph_msg_put(req->r_request); |
| if (req->r_reply) |
| ceph_msg_put(req->r_reply); |
| if (req->r_inode) { |
| ceph_put_cap_refs(ceph_inode(req->r_inode), CEPH_CAP_PIN); |
| iput(req->r_inode); |
| } |
| if (req->r_parent) { |
| ceph_put_cap_refs(ceph_inode(req->r_parent), CEPH_CAP_PIN); |
| iput(req->r_parent); |
| } |
| iput(req->r_target_inode); |
| if (req->r_dentry) |
| dput(req->r_dentry); |
| if (req->r_old_dentry) |
| dput(req->r_old_dentry); |
| if (req->r_old_dentry_dir) { |
| /* |
| * track (and drop pins for) r_old_dentry_dir |
| * separately, since r_old_dentry's d_parent may have |
| * changed between the dir mutex being dropped and |
| * this request being freed. |
| */ |
| ceph_put_cap_refs(ceph_inode(req->r_old_dentry_dir), |
| CEPH_CAP_PIN); |
| iput(req->r_old_dentry_dir); |
| } |
| kfree(req->r_path1); |
| kfree(req->r_path2); |
| put_cred(req->r_cred); |
| if (req->r_pagelist) |
| ceph_pagelist_release(req->r_pagelist); |
| put_request_session(req); |
| ceph_unreserve_caps(req->r_mdsc, &req->r_caps_reservation); |
| WARN_ON_ONCE(!list_empty(&req->r_wait)); |
| kmem_cache_free(ceph_mds_request_cachep, req); |
| } |
| |
| DEFINE_RB_FUNCS(request, struct ceph_mds_request, r_tid, r_node) |
| |
| /* |
| * lookup session, bump ref if found. |
| * |
| * called under mdsc->mutex. |
| */ |
| static struct ceph_mds_request * |
| lookup_get_request(struct ceph_mds_client *mdsc, u64 tid) |
| { |
| struct ceph_mds_request *req; |
| |
| req = lookup_request(&mdsc->request_tree, tid); |
| if (req) |
| ceph_mdsc_get_request(req); |
| |
| return req; |
| } |
| |
| /* |
| * Register an in-flight request, and assign a tid. Link to directory |
| * are modifying (if any). |
| * |
| * Called under mdsc->mutex. |
| */ |
| static void __register_request(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req, |
| struct inode *dir) |
| { |
| int ret = 0; |
| |
| req->r_tid = ++mdsc->last_tid; |
| if (req->r_num_caps) { |
| ret = ceph_reserve_caps(mdsc, &req->r_caps_reservation, |
| req->r_num_caps); |
| if (ret < 0) { |
| pr_err("__register_request %p " |
| "failed to reserve caps: %d\n", req, ret); |
| /* set req->r_err to fail early from __do_request */ |
| req->r_err = ret; |
| return; |
| } |
| } |
| dout("__register_request %p tid %lld\n", req, req->r_tid); |
| ceph_mdsc_get_request(req); |
| insert_request(&mdsc->request_tree, req); |
| |
| req->r_cred = get_current_cred(); |
| |
| if (mdsc->oldest_tid == 0 && req->r_op != CEPH_MDS_OP_SETFILELOCK) |
| mdsc->oldest_tid = req->r_tid; |
| |
| if (dir) { |
| struct ceph_inode_info *ci = ceph_inode(dir); |
| |
| ihold(dir); |
| req->r_unsafe_dir = dir; |
| spin_lock(&ci->i_unsafe_lock); |
| list_add_tail(&req->r_unsafe_dir_item, &ci->i_unsafe_dirops); |
| spin_unlock(&ci->i_unsafe_lock); |
| } |
| } |
| |
| static void __unregister_request(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req) |
| { |
| dout("__unregister_request %p tid %lld\n", req, req->r_tid); |
| |
| /* Never leave an unregistered request on an unsafe list! */ |
| list_del_init(&req->r_unsafe_item); |
| |
| if (req->r_tid == mdsc->oldest_tid) { |
| struct rb_node *p = rb_next(&req->r_node); |
| mdsc->oldest_tid = 0; |
| while (p) { |
| struct ceph_mds_request *next_req = |
| rb_entry(p, struct ceph_mds_request, r_node); |
| if (next_req->r_op != CEPH_MDS_OP_SETFILELOCK) { |
| mdsc->oldest_tid = next_req->r_tid; |
| break; |
| } |
| p = rb_next(p); |
| } |
| } |
| |
| erase_request(&mdsc->request_tree, req); |
| |
| if (req->r_unsafe_dir) { |
| struct ceph_inode_info *ci = ceph_inode(req->r_unsafe_dir); |
| spin_lock(&ci->i_unsafe_lock); |
| list_del_init(&req->r_unsafe_dir_item); |
| spin_unlock(&ci->i_unsafe_lock); |
| } |
| if (req->r_target_inode && |
| test_bit(CEPH_MDS_R_GOT_UNSAFE, &req->r_req_flags)) { |
| struct ceph_inode_info *ci = ceph_inode(req->r_target_inode); |
| spin_lock(&ci->i_unsafe_lock); |
| list_del_init(&req->r_unsafe_target_item); |
| spin_unlock(&ci->i_unsafe_lock); |
| } |
| |
| if (req->r_unsafe_dir) { |
| iput(req->r_unsafe_dir); |
| req->r_unsafe_dir = NULL; |
| } |
| |
| complete_all(&req->r_safe_completion); |
| |
| ceph_mdsc_put_request(req); |
| } |
| |
| /* |
| * Walk back up the dentry tree until we hit a dentry representing a |
| * non-snapshot inode. We do this using the rcu_read_lock (which must be held |
| * when calling this) to ensure that the objects won't disappear while we're |
| * working with them. Once we hit a candidate dentry, we attempt to take a |
| * reference to it, and return that as the result. |
| */ |
| static struct inode *get_nonsnap_parent(struct dentry *dentry) |
| { |
| struct inode *inode = NULL; |
| |
| while (dentry && !IS_ROOT(dentry)) { |
| inode = d_inode_rcu(dentry); |
| if (!inode || ceph_snap(inode) == CEPH_NOSNAP) |
| break; |
| dentry = dentry->d_parent; |
| } |
| if (inode) |
| inode = igrab(inode); |
| return inode; |
| } |
| |
| /* |
| * Choose mds to send request to next. If there is a hint set in the |
| * request (e.g., due to a prior forward hint from the mds), use that. |
| * Otherwise, consult frag tree and/or caps to identify the |
| * appropriate mds. If all else fails, choose randomly. |
| * |
| * Called under mdsc->mutex. |
| */ |
| static int __choose_mds(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req, |
| bool *random) |
| { |
| struct inode *inode; |
| struct ceph_inode_info *ci; |
| struct ceph_cap *cap; |
| int mode = req->r_direct_mode; |
| int mds = -1; |
| u32 hash = req->r_direct_hash; |
| bool is_hash = test_bit(CEPH_MDS_R_DIRECT_IS_HASH, &req->r_req_flags); |
| |
| if (random) |
| *random = false; |
| |
| /* |
| * is there a specific mds we should try? ignore hint if we have |
| * no session and the mds is not up (active or recovering). |
| */ |
| if (req->r_resend_mds >= 0 && |
| (__have_session(mdsc, req->r_resend_mds) || |
| ceph_mdsmap_get_state(mdsc->mdsmap, req->r_resend_mds) > 0)) { |
| dout("%s using resend_mds mds%d\n", __func__, |
| req->r_resend_mds); |
| return req->r_resend_mds; |
| } |
| |
| if (mode == USE_RANDOM_MDS) |
| goto random; |
| |
| inode = NULL; |
| if (req->r_inode) { |
| if (ceph_snap(req->r_inode) != CEPH_SNAPDIR) { |
| inode = req->r_inode; |
| ihold(inode); |
| } else { |
| /* req->r_dentry is non-null for LSSNAP request */ |
| rcu_read_lock(); |
| inode = get_nonsnap_parent(req->r_dentry); |
| rcu_read_unlock(); |
| dout("%s using snapdir's parent %p\n", __func__, inode); |
| } |
| } else if (req->r_dentry) { |
| /* ignore race with rename; old or new d_parent is okay */ |
| struct dentry *parent; |
| struct inode *dir; |
| |
| rcu_read_lock(); |
| parent = READ_ONCE(req->r_dentry->d_parent); |
| dir = req->r_parent ? : d_inode_rcu(parent); |
| |
| if (!dir || dir->i_sb != mdsc->fsc->sb) { |
| /* not this fs or parent went negative */ |
| inode = d_inode(req->r_dentry); |
| if (inode) |
| ihold(inode); |
| } else if (ceph_snap(dir) != CEPH_NOSNAP) { |
| /* direct snapped/virtual snapdir requests |
| * based on parent dir inode */ |
| inode = get_nonsnap_parent(parent); |
| dout("%s using nonsnap parent %p\n", __func__, inode); |
| } else { |
| /* dentry target */ |
| inode = d_inode(req->r_dentry); |
| if (!inode || mode == USE_AUTH_MDS) { |
| /* dir + name */ |
| inode = igrab(dir); |
| hash = ceph_dentry_hash(dir, req->r_dentry); |
| is_hash = true; |
| } else { |
| ihold(inode); |
| } |
| } |
| rcu_read_unlock(); |
| } |
| |
| dout("%s %p is_hash=%d (0x%x) mode %d\n", __func__, inode, (int)is_hash, |
| hash, mode); |
| if (!inode) |
| goto random; |
| ci = ceph_inode(inode); |
| |
| if (is_hash && S_ISDIR(inode->i_mode)) { |
| struct ceph_inode_frag frag; |
| int found; |
| |
| ceph_choose_frag(ci, hash, &frag, &found); |
| if (found) { |
| if (mode == USE_ANY_MDS && frag.ndist > 0) { |
| u8 r; |
| |
| /* choose a random replica */ |
| get_random_bytes(&r, 1); |
| r %= frag.ndist; |
| mds = frag.dist[r]; |
| dout("%s %p %llx.%llx frag %u mds%d (%d/%d)\n", |
| __func__, inode, ceph_vinop(inode), |
| frag.frag, mds, (int)r, frag.ndist); |
| if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >= |
| CEPH_MDS_STATE_ACTIVE && |
| !ceph_mdsmap_is_laggy(mdsc->mdsmap, mds)) |
| goto out; |
| } |
| |
| /* since this file/dir wasn't known to be |
| * replicated, then we want to look for the |
| * authoritative mds. */ |
| if (frag.mds >= 0) { |
| /* choose auth mds */ |
| mds = frag.mds; |
| dout("%s %p %llx.%llx frag %u mds%d (auth)\n", |
| __func__, inode, ceph_vinop(inode), |
| frag.frag, mds); |
| if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >= |
| CEPH_MDS_STATE_ACTIVE) { |
| if (!ceph_mdsmap_is_laggy(mdsc->mdsmap, |
| mds)) |
| goto out; |
| } |
| } |
| mode = USE_AUTH_MDS; |
| } |
| } |
| |
| spin_lock(&ci->i_ceph_lock); |
| cap = NULL; |
| if (mode == USE_AUTH_MDS) |
| cap = ci->i_auth_cap; |
| if (!cap && !RB_EMPTY_ROOT(&ci->i_caps)) |
| cap = rb_entry(rb_first(&ci->i_caps), struct ceph_cap, ci_node); |
| if (!cap) { |
| spin_unlock(&ci->i_ceph_lock); |
| iput(inode); |
| goto random; |
| } |
| mds = cap->session->s_mds; |
| dout("%s %p %llx.%llx mds%d (%scap %p)\n", __func__, |
| inode, ceph_vinop(inode), mds, |
| cap == ci->i_auth_cap ? "auth " : "", cap); |
| spin_unlock(&ci->i_ceph_lock); |
| out: |
| iput(inode); |
| return mds; |
| |
| random: |
| if (random) |
| *random = true; |
| |
| mds = ceph_mdsmap_get_random_mds(mdsc->mdsmap); |
| dout("%s chose random mds%d\n", __func__, mds); |
| return mds; |
| } |
| |
| |
| /* |
| * session messages |
| */ |
| struct ceph_msg *ceph_create_session_msg(u32 op, u64 seq) |
| { |
| struct ceph_msg *msg; |
| struct ceph_mds_session_head *h; |
| |
| msg = ceph_msg_new(CEPH_MSG_CLIENT_SESSION, sizeof(*h), GFP_NOFS, |
| false); |
| if (!msg) { |
| pr_err("ENOMEM creating session %s msg\n", |
| ceph_session_op_name(op)); |
| return NULL; |
| } |
| h = msg->front.iov_base; |
| h->op = cpu_to_le32(op); |
| h->seq = cpu_to_le64(seq); |
| |
| return msg; |
| } |
| |
| static const unsigned char feature_bits[] = CEPHFS_FEATURES_CLIENT_SUPPORTED; |
| #define FEATURE_BYTES(c) (DIV_ROUND_UP((size_t)feature_bits[c - 1] + 1, 64) * 8) |
| static int encode_supported_features(void **p, void *end) |
| { |
| static const size_t count = ARRAY_SIZE(feature_bits); |
| |
| if (count > 0) { |
| size_t i; |
| size_t size = FEATURE_BYTES(count); |
| |
| if (WARN_ON_ONCE(*p + 4 + size > end)) |
| return -ERANGE; |
| |
| ceph_encode_32(p, size); |
| memset(*p, 0, size); |
| for (i = 0; i < count; i++) |
| ((unsigned char*)(*p))[i / 8] |= BIT(feature_bits[i] % 8); |
| *p += size; |
| } else { |
| if (WARN_ON_ONCE(*p + 4 > end)) |
| return -ERANGE; |
| |
| ceph_encode_32(p, 0); |
| } |
| |
| return 0; |
| } |
| |
| static const unsigned char metric_bits[] = CEPHFS_METRIC_SPEC_CLIENT_SUPPORTED; |
| #define METRIC_BYTES(cnt) (DIV_ROUND_UP((size_t)metric_bits[cnt - 1] + 1, 64) * 8) |
| static int encode_metric_spec(void **p, void *end) |
| { |
| static const size_t count = ARRAY_SIZE(metric_bits); |
| |
| /* header */ |
| if (WARN_ON_ONCE(*p + 2 > end)) |
| return -ERANGE; |
| |
| ceph_encode_8(p, 1); /* version */ |
| ceph_encode_8(p, 1); /* compat */ |
| |
| if (count > 0) { |
| size_t i; |
| size_t size = METRIC_BYTES(count); |
| |
| if (WARN_ON_ONCE(*p + 4 + 4 + size > end)) |
| return -ERANGE; |
| |
| /* metric spec info length */ |
| ceph_encode_32(p, 4 + size); |
| |
| /* metric spec */ |
| ceph_encode_32(p, size); |
| memset(*p, 0, size); |
| for (i = 0; i < count; i++) |
| ((unsigned char *)(*p))[i / 8] |= BIT(metric_bits[i] % 8); |
| *p += size; |
| } else { |
| if (WARN_ON_ONCE(*p + 4 + 4 > end)) |
| return -ERANGE; |
| |
| /* metric spec info length */ |
| ceph_encode_32(p, 4); |
| /* metric spec */ |
| ceph_encode_32(p, 0); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * session message, specialization for CEPH_SESSION_REQUEST_OPEN |
| * to include additional client metadata fields. |
| */ |
| static struct ceph_msg *create_session_open_msg(struct ceph_mds_client *mdsc, u64 seq) |
| { |
| struct ceph_msg *msg; |
| struct ceph_mds_session_head *h; |
| int i; |
| int extra_bytes = 0; |
| int metadata_key_count = 0; |
| struct ceph_options *opt = mdsc->fsc->client->options; |
| struct ceph_mount_options *fsopt = mdsc->fsc->mount_options; |
| size_t size, count; |
| void *p, *end; |
| int ret; |
| |
| const char* metadata[][2] = { |
| {"hostname", mdsc->nodename}, |
| {"kernel_version", init_utsname()->release}, |
| {"entity_id", opt->name ? : ""}, |
| {"root", fsopt->server_path ? : "/"}, |
| {NULL, NULL} |
| }; |
| |
| /* Calculate serialized length of metadata */ |
| extra_bytes = 4; /* map length */ |
| for (i = 0; metadata[i][0]; ++i) { |
| extra_bytes += 8 + strlen(metadata[i][0]) + |
| strlen(metadata[i][1]); |
| metadata_key_count++; |
| } |
| |
| /* supported feature */ |
| size = 0; |
| count = ARRAY_SIZE(feature_bits); |
| if (count > 0) |
| size = FEATURE_BYTES(count); |
| extra_bytes += 4 + size; |
| |
| /* metric spec */ |
| size = 0; |
| count = ARRAY_SIZE(metric_bits); |
| if (count > 0) |
| size = METRIC_BYTES(count); |
| extra_bytes += 2 + 4 + 4 + size; |
| |
| /* Allocate the message */ |
| msg = ceph_msg_new(CEPH_MSG_CLIENT_SESSION, sizeof(*h) + extra_bytes, |
| GFP_NOFS, false); |
| if (!msg) { |
| pr_err("ENOMEM creating session open msg\n"); |
| return ERR_PTR(-ENOMEM); |
| } |
| p = msg->front.iov_base; |
| end = p + msg->front.iov_len; |
| |
| h = p; |
| h->op = cpu_to_le32(CEPH_SESSION_REQUEST_OPEN); |
| h->seq = cpu_to_le64(seq); |
| |
| /* |
| * Serialize client metadata into waiting buffer space, using |
| * the format that userspace expects for map<string, string> |
| * |
| * ClientSession messages with metadata are v4 |
| */ |
| msg->hdr.version = cpu_to_le16(4); |
| msg->hdr.compat_version = cpu_to_le16(1); |
| |
| /* The write pointer, following the session_head structure */ |
| p += sizeof(*h); |
| |
| /* Number of entries in the map */ |
| ceph_encode_32(&p, metadata_key_count); |
| |
| /* Two length-prefixed strings for each entry in the map */ |
| for (i = 0; metadata[i][0]; ++i) { |
| size_t const key_len = strlen(metadata[i][0]); |
| size_t const val_len = strlen(metadata[i][1]); |
| |
| ceph_encode_32(&p, key_len); |
| memcpy(p, metadata[i][0], key_len); |
| p += key_len; |
| ceph_encode_32(&p, val_len); |
| memcpy(p, metadata[i][1], val_len); |
| p += val_len; |
| } |
| |
| ret = encode_supported_features(&p, end); |
| if (ret) { |
| pr_err("encode_supported_features failed!\n"); |
| ceph_msg_put(msg); |
| return ERR_PTR(ret); |
| } |
| |
| ret = encode_metric_spec(&p, end); |
| if (ret) { |
| pr_err("encode_metric_spec failed!\n"); |
| ceph_msg_put(msg); |
| return ERR_PTR(ret); |
| } |
| |
| msg->front.iov_len = p - msg->front.iov_base; |
| msg->hdr.front_len = cpu_to_le32(msg->front.iov_len); |
| |
| return msg; |
| } |
| |
| /* |
| * send session open request. |
| * |
| * called under mdsc->mutex |
| */ |
| static int __open_session(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| struct ceph_msg *msg; |
| int mstate; |
| int mds = session->s_mds; |
| |
| /* wait for mds to go active? */ |
| mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds); |
| dout("open_session to mds%d (%s)\n", mds, |
| ceph_mds_state_name(mstate)); |
| session->s_state = CEPH_MDS_SESSION_OPENING; |
| session->s_renew_requested = jiffies; |
| |
| /* send connect message */ |
| msg = create_session_open_msg(mdsc, session->s_seq); |
| if (IS_ERR(msg)) |
| return PTR_ERR(msg); |
| ceph_con_send(&session->s_con, msg); |
| return 0; |
| } |
| |
| /* |
| * open sessions for any export targets for the given mds |
| * |
| * called under mdsc->mutex |
| */ |
| static struct ceph_mds_session * |
| __open_export_target_session(struct ceph_mds_client *mdsc, int target) |
| { |
| struct ceph_mds_session *session; |
| int ret; |
| |
| session = __ceph_lookup_mds_session(mdsc, target); |
| if (!session) { |
| session = register_session(mdsc, target); |
| if (IS_ERR(session)) |
| return session; |
| } |
| if (session->s_state == CEPH_MDS_SESSION_NEW || |
| session->s_state == CEPH_MDS_SESSION_CLOSING) { |
| ret = __open_session(mdsc, session); |
| if (ret) |
| return ERR_PTR(ret); |
| } |
| |
| return session; |
| } |
| |
| struct ceph_mds_session * |
| ceph_mdsc_open_export_target_session(struct ceph_mds_client *mdsc, int target) |
| { |
| struct ceph_mds_session *session; |
| |
| dout("open_export_target_session to mds%d\n", target); |
| |
| mutex_lock(&mdsc->mutex); |
| session = __open_export_target_session(mdsc, target); |
| mutex_unlock(&mdsc->mutex); |
| |
| return session; |
| } |
| |
| static void __open_export_target_sessions(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| struct ceph_mds_info *mi; |
| struct ceph_mds_session *ts; |
| int i, mds = session->s_mds; |
| |
| if (mds >= mdsc->mdsmap->possible_max_rank) |
| return; |
| |
| mi = &mdsc->mdsmap->m_info[mds]; |
| dout("open_export_target_sessions for mds%d (%d targets)\n", |
| session->s_mds, mi->num_export_targets); |
| |
| for (i = 0; i < mi->num_export_targets; i++) { |
| ts = __open_export_target_session(mdsc, mi->export_targets[i]); |
| ceph_put_mds_session(ts); |
| } |
| } |
| |
| void ceph_mdsc_open_export_target_sessions(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| mutex_lock(&mdsc->mutex); |
| __open_export_target_sessions(mdsc, session); |
| mutex_unlock(&mdsc->mutex); |
| } |
| |
| /* |
| * session caps |
| */ |
| |
| static void detach_cap_releases(struct ceph_mds_session *session, |
| struct list_head *target) |
| { |
| lockdep_assert_held(&session->s_cap_lock); |
| |
| list_splice_init(&session->s_cap_releases, target); |
| session->s_num_cap_releases = 0; |
| dout("dispose_cap_releases mds%d\n", session->s_mds); |
| } |
| |
| static void dispose_cap_releases(struct ceph_mds_client *mdsc, |
| struct list_head *dispose) |
| { |
| while (!list_empty(dispose)) { |
| struct ceph_cap *cap; |
| /* zero out the in-progress message */ |
| cap = list_first_entry(dispose, struct ceph_cap, session_caps); |
| list_del(&cap->session_caps); |
| ceph_put_cap(mdsc, cap); |
| } |
| } |
| |
| static void cleanup_session_requests(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| struct ceph_mds_request *req; |
| struct rb_node *p; |
| |
| dout("cleanup_session_requests mds%d\n", session->s_mds); |
| mutex_lock(&mdsc->mutex); |
| while (!list_empty(&session->s_unsafe)) { |
| req = list_first_entry(&session->s_unsafe, |
| struct ceph_mds_request, r_unsafe_item); |
| pr_warn_ratelimited(" dropping unsafe request %llu\n", |
| req->r_tid); |
| if (req->r_target_inode) |
| mapping_set_error(req->r_target_inode->i_mapping, -EIO); |
| if (req->r_unsafe_dir) |
| mapping_set_error(req->r_unsafe_dir->i_mapping, -EIO); |
| __unregister_request(mdsc, req); |
| } |
| /* zero r_attempts, so kick_requests() will re-send requests */ |
| p = rb_first(&mdsc->request_tree); |
| while (p) { |
| req = rb_entry(p, struct ceph_mds_request, r_node); |
| p = rb_next(p); |
| if (req->r_session && |
| req->r_session->s_mds == session->s_mds) |
| req->r_attempts = 0; |
| } |
| mutex_unlock(&mdsc->mutex); |
| } |
| |
| /* |
| * Helper to safely iterate over all caps associated with a session, with |
| * special care taken to handle a racing __ceph_remove_cap(). |
| * |
| * Caller must hold session s_mutex. |
| */ |
| int ceph_iterate_session_caps(struct ceph_mds_session *session, |
| int (*cb)(struct inode *, struct ceph_cap *, |
| void *), void *arg) |
| { |
| struct list_head *p; |
| struct ceph_cap *cap; |
| struct inode *inode, *last_inode = NULL; |
| struct ceph_cap *old_cap = NULL; |
| int ret; |
| |
| dout("iterate_session_caps %p mds%d\n", session, session->s_mds); |
| spin_lock(&session->s_cap_lock); |
| p = session->s_caps.next; |
| while (p != &session->s_caps) { |
| cap = list_entry(p, struct ceph_cap, session_caps); |
| inode = igrab(&cap->ci->vfs_inode); |
| if (!inode) { |
| p = p->next; |
| continue; |
| } |
| session->s_cap_iterator = cap; |
| spin_unlock(&session->s_cap_lock); |
| |
| if (last_inode) { |
| iput(last_inode); |
| last_inode = NULL; |
| } |
| if (old_cap) { |
| ceph_put_cap(session->s_mdsc, old_cap); |
| old_cap = NULL; |
| } |
| |
| ret = cb(inode, cap, arg); |
| last_inode = inode; |
| |
| spin_lock(&session->s_cap_lock); |
| p = p->next; |
| if (!cap->ci) { |
| dout("iterate_session_caps finishing cap %p removal\n", |
| cap); |
| BUG_ON(cap->session != session); |
| cap->session = NULL; |
| list_del_init(&cap->session_caps); |
| session->s_nr_caps--; |
| atomic64_dec(&session->s_mdsc->metric.total_caps); |
| if (cap->queue_release) |
| __ceph_queue_cap_release(session, cap); |
| else |
| old_cap = cap; /* put_cap it w/o locks held */ |
| } |
| if (ret < 0) |
| goto out; |
| } |
| ret = 0; |
| out: |
| session->s_cap_iterator = NULL; |
| spin_unlock(&session->s_cap_lock); |
| |
| iput(last_inode); |
| if (old_cap) |
| ceph_put_cap(session->s_mdsc, old_cap); |
| |
| return ret; |
| } |
| |
| static int remove_session_caps_cb(struct inode *inode, struct ceph_cap *cap, |
| void *arg) |
| { |
| struct ceph_inode_info *ci = ceph_inode(inode); |
| bool invalidate = false; |
| int iputs; |
| |
| dout("removing cap %p, ci is %p, inode is %p\n", |
| cap, ci, &ci->vfs_inode); |
| spin_lock(&ci->i_ceph_lock); |
| iputs = ceph_purge_inode_cap(inode, cap, &invalidate); |
| spin_unlock(&ci->i_ceph_lock); |
| |
| wake_up_all(&ci->i_cap_wq); |
| if (invalidate) |
| ceph_queue_invalidate(inode); |
| while (iputs--) |
| iput(inode); |
| return 0; |
| } |
| |
| /* |
| * caller must hold session s_mutex |
| */ |
| static void remove_session_caps(struct ceph_mds_session *session) |
| { |
| struct ceph_fs_client *fsc = session->s_mdsc->fsc; |
| struct super_block *sb = fsc->sb; |
| LIST_HEAD(dispose); |
| |
| dout("remove_session_caps on %p\n", session); |
| ceph_iterate_session_caps(session, remove_session_caps_cb, fsc); |
| |
| wake_up_all(&fsc->mdsc->cap_flushing_wq); |
| |
| spin_lock(&session->s_cap_lock); |
| if (session->s_nr_caps > 0) { |
| struct inode *inode; |
| struct ceph_cap *cap, *prev = NULL; |
| struct ceph_vino vino; |
| /* |
| * iterate_session_caps() skips inodes that are being |
| * deleted, we need to wait until deletions are complete. |
| * __wait_on_freeing_inode() is designed for the job, |
| * but it is not exported, so use lookup inode function |
| * to access it. |
| */ |
| while (!list_empty(&session->s_caps)) { |
| cap = list_entry(session->s_caps.next, |
| struct ceph_cap, session_caps); |
| if (cap == prev) |
| break; |
| prev = cap; |
| vino = cap->ci->i_vino; |
| spin_unlock(&session->s_cap_lock); |
| |
| inode = ceph_find_inode(sb, vino); |
| iput(inode); |
| |
| spin_lock(&session->s_cap_lock); |
| } |
| } |
| |
| // drop cap expires and unlock s_cap_lock |
| detach_cap_releases(session, &dispose); |
| |
| BUG_ON(session->s_nr_caps > 0); |
| BUG_ON(!list_empty(&session->s_cap_flushing)); |
| spin_unlock(&session->s_cap_lock); |
| dispose_cap_releases(session->s_mdsc, &dispose); |
| } |
| |
| enum { |
| RECONNECT, |
| RENEWCAPS, |
| FORCE_RO, |
| }; |
| |
| /* |
| * wake up any threads waiting on this session's caps. if the cap is |
| * old (didn't get renewed on the client reconnect), remove it now. |
| * |
| * caller must hold s_mutex. |
| */ |
| static int wake_up_session_cb(struct inode *inode, struct ceph_cap *cap, |
| void *arg) |
| { |
| struct ceph_inode_info *ci = ceph_inode(inode); |
| unsigned long ev = (unsigned long)arg; |
| |
| if (ev == RECONNECT) { |
| spin_lock(&ci->i_ceph_lock); |
| ci->i_wanted_max_size = 0; |
| ci->i_requested_max_size = 0; |
| spin_unlock(&ci->i_ceph_lock); |
| } else if (ev == RENEWCAPS) { |
| if (cap->cap_gen < atomic_read(&cap->session->s_cap_gen)) { |
| /* mds did not re-issue stale cap */ |
| spin_lock(&ci->i_ceph_lock); |
| cap->issued = cap->implemented = CEPH_CAP_PIN; |
| spin_unlock(&ci->i_ceph_lock); |
| } |
| } else if (ev == FORCE_RO) { |
| } |
| wake_up_all(&ci->i_cap_wq); |
| return 0; |
| } |
| |
| static void wake_up_session_caps(struct ceph_mds_session *session, int ev) |
| { |
| dout("wake_up_session_caps %p mds%d\n", session, session->s_mds); |
| ceph_iterate_session_caps(session, wake_up_session_cb, |
| (void *)(unsigned long)ev); |
| } |
| |
| /* |
| * Send periodic message to MDS renewing all currently held caps. The |
| * ack will reset the expiration for all caps from this session. |
| * |
| * caller holds s_mutex |
| */ |
| static int send_renew_caps(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| struct ceph_msg *msg; |
| int state; |
| |
| if (time_after_eq(jiffies, session->s_cap_ttl) && |
| time_after_eq(session->s_cap_ttl, session->s_renew_requested)) |
| pr_info("mds%d caps stale\n", session->s_mds); |
| session->s_renew_requested = jiffies; |
| |
| /* do not try to renew caps until a recovering mds has reconnected |
| * with its clients. */ |
| state = ceph_mdsmap_get_state(mdsc->mdsmap, session->s_mds); |
| if (state < CEPH_MDS_STATE_RECONNECT) { |
| dout("send_renew_caps ignoring mds%d (%s)\n", |
| session->s_mds, ceph_mds_state_name(state)); |
| return 0; |
| } |
| |
| dout("send_renew_caps to mds%d (%s)\n", session->s_mds, |
| ceph_mds_state_name(state)); |
| msg = ceph_create_session_msg(CEPH_SESSION_REQUEST_RENEWCAPS, |
| ++session->s_renew_seq); |
| if (!msg) |
| return -ENOMEM; |
| ceph_con_send(&session->s_con, msg); |
| return 0; |
| } |
| |
| static int send_flushmsg_ack(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session, u64 seq) |
| { |
| struct ceph_msg *msg; |
| |
| dout("send_flushmsg_ack to mds%d (%s)s seq %lld\n", |
| session->s_mds, ceph_session_state_name(session->s_state), seq); |
| msg = ceph_create_session_msg(CEPH_SESSION_FLUSHMSG_ACK, seq); |
| if (!msg) |
| return -ENOMEM; |
| ceph_con_send(&session->s_con, msg); |
| return 0; |
| } |
| |
| |
| /* |
| * Note new cap ttl, and any transition from stale -> not stale (fresh?). |
| * |
| * Called under session->s_mutex |
| */ |
| static void renewed_caps(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session, int is_renew) |
| { |
| int was_stale; |
| int wake = 0; |
| |
| spin_lock(&session->s_cap_lock); |
| was_stale = is_renew && time_after_eq(jiffies, session->s_cap_ttl); |
| |
| session->s_cap_ttl = session->s_renew_requested + |
| mdsc->mdsmap->m_session_timeout*HZ; |
| |
| if (was_stale) { |
| if (time_before(jiffies, session->s_cap_ttl)) { |
| pr_info("mds%d caps renewed\n", session->s_mds); |
| wake = 1; |
| } else { |
| pr_info("mds%d caps still stale\n", session->s_mds); |
| } |
| } |
| dout("renewed_caps mds%d ttl now %lu, was %s, now %s\n", |
| session->s_mds, session->s_cap_ttl, was_stale ? "stale" : "fresh", |
| time_before(jiffies, session->s_cap_ttl) ? "stale" : "fresh"); |
| spin_unlock(&session->s_cap_lock); |
| |
| if (wake) |
| wake_up_session_caps(session, RENEWCAPS); |
| } |
| |
| /* |
| * send a session close request |
| */ |
| static int request_close_session(struct ceph_mds_session *session) |
| { |
| struct ceph_msg *msg; |
| |
| dout("request_close_session mds%d state %s seq %lld\n", |
| session->s_mds, ceph_session_state_name(session->s_state), |
| session->s_seq); |
| msg = ceph_create_session_msg(CEPH_SESSION_REQUEST_CLOSE, |
| session->s_seq); |
| if (!msg) |
| return -ENOMEM; |
| ceph_con_send(&session->s_con, msg); |
| return 1; |
| } |
| |
| /* |
| * Called with s_mutex held. |
| */ |
| static int __close_session(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| if (session->s_state >= CEPH_MDS_SESSION_CLOSING) |
| return 0; |
| session->s_state = CEPH_MDS_SESSION_CLOSING; |
| return request_close_session(session); |
| } |
| |
| static bool drop_negative_children(struct dentry *dentry) |
| { |
| struct dentry *child; |
| bool all_negative = true; |
| |
| if (!d_is_dir(dentry)) |
| goto out; |
| |
| spin_lock(&dentry->d_lock); |
| list_for_each_entry(child, &dentry->d_subdirs, d_child) { |
| if (d_really_is_positive(child)) { |
| all_negative = false; |
| break; |
| } |
| } |
| spin_unlock(&dentry->d_lock); |
| |
| if (all_negative) |
| shrink_dcache_parent(dentry); |
| out: |
| return all_negative; |
| } |
| |
| /* |
| * Trim old(er) caps. |
| * |
| * Because we can't cache an inode without one or more caps, we do |
| * this indirectly: if a cap is unused, we prune its aliases, at which |
| * point the inode will hopefully get dropped to. |
| * |
| * Yes, this is a bit sloppy. Our only real goal here is to respond to |
| * memory pressure from the MDS, though, so it needn't be perfect. |
| */ |
| static int trim_caps_cb(struct inode *inode, struct ceph_cap *cap, void *arg) |
| { |
| int *remaining = arg; |
| struct ceph_inode_info *ci = ceph_inode(inode); |
| int used, wanted, oissued, mine; |
| |
| if (*remaining <= 0) |
| return -1; |
| |
| spin_lock(&ci->i_ceph_lock); |
| mine = cap->issued | cap->implemented; |
| used = __ceph_caps_used(ci); |
| wanted = __ceph_caps_file_wanted(ci); |
| oissued = __ceph_caps_issued_other(ci, cap); |
| |
| dout("trim_caps_cb %p cap %p mine %s oissued %s used %s wanted %s\n", |
| inode, cap, ceph_cap_string(mine), ceph_cap_string(oissued), |
| ceph_cap_string(used), ceph_cap_string(wanted)); |
| if (cap == ci->i_auth_cap) { |
| if (ci->i_dirty_caps || ci->i_flushing_caps || |
| !list_empty(&ci->i_cap_snaps)) |
| goto out; |
| if ((used | wanted) & CEPH_CAP_ANY_WR) |
| goto out; |
| /* Note: it's possible that i_filelock_ref becomes non-zero |
| * after dropping auth caps. It doesn't hurt because reply |
| * of lock mds request will re-add auth caps. */ |
| if (atomic_read(&ci->i_filelock_ref) > 0) |
| goto out; |
| } |
| /* The inode has cached pages, but it's no longer used. |
| * we can safely drop it */ |
| if (S_ISREG(inode->i_mode) && |
| wanted == 0 && used == CEPH_CAP_FILE_CACHE && |
| !(oissued & CEPH_CAP_FILE_CACHE)) { |
| used = 0; |
| oissued = 0; |
| } |
| if ((used | wanted) & ~oissued & mine) |
| goto out; /* we need these caps */ |
| |
| if (oissued) { |
| /* we aren't the only cap.. just remove us */ |
| ceph_remove_cap(cap, true); |
| (*remaining)--; |
| } else { |
| struct dentry *dentry; |
| /* try dropping referring dentries */ |
| spin_unlock(&ci->i_ceph_lock); |
| dentry = d_find_any_alias(inode); |
| if (dentry && drop_negative_children(dentry)) { |
| int count; |
| dput(dentry); |
| d_prune_aliases(inode); |
| count = atomic_read(&inode->i_count); |
| if (count == 1) |
| (*remaining)--; |
| dout("trim_caps_cb %p cap %p pruned, count now %d\n", |
| inode, cap, count); |
| } else { |
| dput(dentry); |
| } |
| return 0; |
| } |
| |
| out: |
| spin_unlock(&ci->i_ceph_lock); |
| return 0; |
| } |
| |
| /* |
| * Trim session cap count down to some max number. |
| */ |
| int ceph_trim_caps(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session, |
| int max_caps) |
| { |
| int trim_caps = session->s_nr_caps - max_caps; |
| |
| dout("trim_caps mds%d start: %d / %d, trim %d\n", |
| session->s_mds, session->s_nr_caps, max_caps, trim_caps); |
| if (trim_caps > 0) { |
| int remaining = trim_caps; |
| |
| ceph_iterate_session_caps(session, trim_caps_cb, &remaining); |
| dout("trim_caps mds%d done: %d / %d, trimmed %d\n", |
| session->s_mds, session->s_nr_caps, max_caps, |
| trim_caps - remaining); |
| } |
| |
| ceph_flush_cap_releases(mdsc, session); |
| return 0; |
| } |
| |
| static int check_caps_flush(struct ceph_mds_client *mdsc, |
| u64 want_flush_tid) |
| { |
| int ret = 1; |
| |
| spin_lock(&mdsc->cap_dirty_lock); |
| if (!list_empty(&mdsc->cap_flush_list)) { |
| struct ceph_cap_flush *cf = |
| list_first_entry(&mdsc->cap_flush_list, |
| struct ceph_cap_flush, g_list); |
| if (cf->tid <= want_flush_tid) { |
| dout("check_caps_flush still flushing tid " |
| "%llu <= %llu\n", cf->tid, want_flush_tid); |
| ret = 0; |
| } |
| } |
| spin_unlock(&mdsc->cap_dirty_lock); |
| return ret; |
| } |
| |
| /* |
| * flush all dirty inode data to disk. |
| * |
| * returns true if we've flushed through want_flush_tid |
| */ |
| static void wait_caps_flush(struct ceph_mds_client *mdsc, |
| u64 want_flush_tid) |
| { |
| dout("check_caps_flush want %llu\n", want_flush_tid); |
| |
| wait_event(mdsc->cap_flushing_wq, |
| check_caps_flush(mdsc, want_flush_tid)); |
| |
| dout("check_caps_flush ok, flushed thru %llu\n", want_flush_tid); |
| } |
| |
| /* |
| * called under s_mutex |
| */ |
| static void ceph_send_cap_releases(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| struct ceph_msg *msg = NULL; |
| struct ceph_mds_cap_release *head; |
| struct ceph_mds_cap_item *item; |
| struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc; |
| struct ceph_cap *cap; |
| LIST_HEAD(tmp_list); |
| int num_cap_releases; |
| __le32 barrier, *cap_barrier; |
| |
| down_read(&osdc->lock); |
| barrier = cpu_to_le32(osdc->epoch_barrier); |
| up_read(&osdc->lock); |
| |
| spin_lock(&session->s_cap_lock); |
| again: |
| list_splice_init(&session->s_cap_releases, &tmp_list); |
| num_cap_releases = session->s_num_cap_releases; |
| session->s_num_cap_releases = 0; |
| spin_unlock(&session->s_cap_lock); |
| |
| while (!list_empty(&tmp_list)) { |
| if (!msg) { |
| msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPRELEASE, |
| PAGE_SIZE, GFP_NOFS, false); |
| if (!msg) |
| goto out_err; |
| head = msg->front.iov_base; |
| head->num = cpu_to_le32(0); |
| msg->front.iov_len = sizeof(*head); |
| |
| msg->hdr.version = cpu_to_le16(2); |
| msg->hdr.compat_version = cpu_to_le16(1); |
| } |
| |
| cap = list_first_entry(&tmp_list, struct ceph_cap, |
| session_caps); |
| list_del(&cap->session_caps); |
| num_cap_releases--; |
| |
| head = msg->front.iov_base; |
| put_unaligned_le32(get_unaligned_le32(&head->num) + 1, |
| &head->num); |
| item = msg->front.iov_base + msg->front.iov_len; |
| item->ino = cpu_to_le64(cap->cap_ino); |
| item->cap_id = cpu_to_le64(cap->cap_id); |
| item->migrate_seq = cpu_to_le32(cap->mseq); |
| item->seq = cpu_to_le32(cap->issue_seq); |
| msg->front.iov_len += sizeof(*item); |
| |
| ceph_put_cap(mdsc, cap); |
| |
| if (le32_to_cpu(head->num) == CEPH_CAPS_PER_RELEASE) { |
| // Append cap_barrier field |
| cap_barrier = msg->front.iov_base + msg->front.iov_len; |
| *cap_barrier = barrier; |
| msg->front.iov_len += sizeof(*cap_barrier); |
| |
| msg->hdr.front_len = cpu_to_le32(msg->front.iov_len); |
| dout("send_cap_releases mds%d %p\n", session->s_mds, msg); |
| ceph_con_send(&session->s_con, msg); |
| msg = NULL; |
| } |
| } |
| |
| BUG_ON(num_cap_releases != 0); |
| |
| spin_lock(&session->s_cap_lock); |
| if (!list_empty(&session->s_cap_releases)) |
| goto again; |
| spin_unlock(&session->s_cap_lock); |
| |
| if (msg) { |
| // Append cap_barrier field |
| cap_barrier = msg->front.iov_base + msg->front.iov_len; |
| *cap_barrier = barrier; |
| msg->front.iov_len += sizeof(*cap_barrier); |
| |
| msg->hdr.front_len = cpu_to_le32(msg->front.iov_len); |
| dout("send_cap_releases mds%d %p\n", session->s_mds, msg); |
| ceph_con_send(&session->s_con, msg); |
| } |
| return; |
| out_err: |
| pr_err("send_cap_releases mds%d, failed to allocate message\n", |
| session->s_mds); |
| spin_lock(&session->s_cap_lock); |
| list_splice(&tmp_list, &session->s_cap_releases); |
| session->s_num_cap_releases += num_cap_releases; |
| spin_unlock(&session->s_cap_lock); |
| } |
| |
| static void ceph_cap_release_work(struct work_struct *work) |
| { |
| struct ceph_mds_session *session = |
| container_of(work, struct ceph_mds_session, s_cap_release_work); |
| |
| mutex_lock(&session->s_mutex); |
| if (session->s_state == CEPH_MDS_SESSION_OPEN || |
| session->s_state == CEPH_MDS_SESSION_HUNG) |
| ceph_send_cap_releases(session->s_mdsc, session); |
| mutex_unlock(&session->s_mutex); |
| ceph_put_mds_session(session); |
| } |
| |
| void ceph_flush_cap_releases(struct ceph_mds_client *mdsc, |
| struct ceph_mds_session *session) |
| { |
| if (mdsc->stopping) |
| return; |
| |
| ceph_get_mds_session(session); |
| if (queue_work(mdsc->fsc->cap_wq, |
| &session->s_cap_release_work)) { |
| dout("cap release work queued\n"); |
| } else { |
| ceph_put_mds_session(session); |
| dout("failed to queue cap release work\n"); |
| } |
| } |
| |
| /* |
| * caller holds session->s_cap_lock |
| */ |
| void __ceph_queue_cap_release(struct ceph_mds_session *session, |
| struct ceph_cap *cap) |
| { |
| list_add_tail(&cap->session_caps, &session->s_cap_releases); |
| session->s_num_cap_releases++; |
| |
| if (!(session->s_num_cap_releases % CEPH_CAPS_PER_RELEASE)) |
| ceph_flush_cap_releases(session->s_mdsc, session); |
| } |
| |
| static void ceph_cap_reclaim_work(struct work_struct *work) |
| { |
| struct ceph_mds_client *mdsc = |
| container_of(work, struct ceph_mds_client, cap_reclaim_work); |
| int ret = ceph_trim_dentries(mdsc); |
| if (ret == -EAGAIN) |
| ceph_queue_cap_reclaim_work(mdsc); |
| } |
| |
| void ceph_queue_cap_reclaim_work(struct ceph_mds_client *mdsc) |
| { |
| if (mdsc->stopping) |
| return; |
| |
| if (queue_work(mdsc->fsc->cap_wq, &mdsc->cap_reclaim_work)) { |
| dout("caps reclaim work queued\n"); |
| } else { |
| dout("failed to queue caps release work\n"); |
| } |
| } |
| |
| void ceph_reclaim_caps_nr(struct ceph_mds_client *mdsc, int nr) |
| { |
| int val; |
| if (!nr) |
| return; |
| val = atomic_add_return(nr, &mdsc->cap_reclaim_pending); |
| if ((val % CEPH_CAPS_PER_RELEASE) < nr) { |
| atomic_set(&mdsc->cap_reclaim_pending, 0); |
| ceph_queue_cap_reclaim_work(mdsc); |
| } |
| } |
| |
| /* |
| * requests |
| */ |
| |
| int ceph_alloc_readdir_reply_buffer(struct ceph_mds_request *req, |
| struct inode *dir) |
| { |
| struct ceph_inode_info *ci = ceph_inode(dir); |
| struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; |
| struct ceph_mount_options *opt = req->r_mdsc->fsc->mount_options; |
| size_t size = sizeof(struct ceph_mds_reply_dir_entry); |
| unsigned int num_entries; |
| int order; |
| |
| spin_lock(&ci->i_ceph_lock); |
| num_entries = ci->i_files + ci->i_subdirs; |
| spin_unlock(&ci->i_ceph_lock); |
| num_entries = max(num_entries, 1U); |
| num_entries = min(num_entries, opt->max_readdir); |
| |
| order = get_order(size * num_entries); |
| while (order >= 0) { |
| rinfo->dir_entries = (void*)__get_free_pages(GFP_KERNEL | |
| __GFP_NOWARN, |
| order); |
| if (rinfo->dir_entries) |
| break; |
| order--; |
| } |
| if (!rinfo->dir_entries) |
| return -ENOMEM; |
| |
| num_entries = (PAGE_SIZE << order) / size; |
| num_entries = min(num_entries, opt->max_readdir); |
| |
| rinfo->dir_buf_size = PAGE_SIZE << order; |
| req->r_num_caps = num_entries + 1; |
| req->r_args.readdir.max_entries = cpu_to_le32(num_entries); |
| req->r_args.readdir.max_bytes = cpu_to_le32(opt->max_readdir_bytes); |
| return 0; |
| } |
| |
| /* |
| * Create an mds request. |
| */ |
| struct ceph_mds_request * |
| ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op, int mode) |
| { |
| struct ceph_mds_request *req; |
| |
| req = kmem_cache_zalloc(ceph_mds_request_cachep, GFP_NOFS); |
| if (!req) |
| return ERR_PTR(-ENOMEM); |
| |
| mutex_init(&req->r_fill_mutex); |
| req->r_mdsc = mdsc; |
| req->r_started = jiffies; |
| req->r_start_latency = ktime_get(); |
| req->r_resend_mds = -1; |
| INIT_LIST_HEAD(&req->r_unsafe_dir_item); |
| INIT_LIST_HEAD(&req->r_unsafe_target_item); |
| req->r_fmode = -1; |
| kref_init(&req->r_kref); |
| RB_CLEAR_NODE(&req->r_node); |
| INIT_LIST_HEAD(&req->r_wait); |
| init_completion(&req->r_completion); |
| init_completion(&req->r_safe_completion); |
| INIT_LIST_HEAD(&req->r_unsafe_item); |
| |
| ktime_get_coarse_real_ts64(&req->r_stamp); |
| |
| req->r_op = op; |
| req->r_direct_mode = mode; |
| return req; |
| } |
| |
| /* |
| * return oldest (lowest) request, tid in request tree, 0 if none. |
| * |
| * called under mdsc->mutex. |
| */ |
| static struct ceph_mds_request *__get_oldest_req(struct ceph_mds_client *mdsc) |
| { |
| if (RB_EMPTY_ROOT(&mdsc->request_tree)) |
| return NULL; |
| return rb_entry(rb_first(&mdsc->request_tree), |
| struct ceph_mds_request, r_node); |
| } |
| |
| static inline u64 __get_oldest_tid(struct ceph_mds_client *mdsc) |
| { |
| return mdsc->oldest_tid; |
| } |
| |
| /* |
| * Build a dentry's path. Allocate on heap; caller must kfree. Based |
| * on build_path_from_dentry in fs/cifs/dir.c. |
| * |
| * If @stop_on_nosnap, generate path relative to the first non-snapped |
| * inode. |
| * |
| * Encode hidden .snap dirs as a double /, i.e. |
| * foo/.snap/bar -> foo//bar |
| */ |
| char *ceph_mdsc_build_path(struct dentry *dentry, int *plen, u64 *pbase, |
| int stop_on_nosnap) |
| { |
| struct dentry *temp; |
| char *path; |
| int pos; |
| unsigned seq; |
| u64 base; |
| |
| if (!dentry) |
| return ERR_PTR(-EINVAL); |
| |
| path = __getname(); |
| if (!path) |
| return ERR_PTR(-ENOMEM); |
| retry: |
| pos = PATH_MAX - 1; |
| path[pos] = '\0'; |
| |
| seq = read_seqbegin(&rename_lock); |
| rcu_read_lock(); |
| temp = dentry; |
| for (;;) { |
| struct inode *inode; |
| |
| spin_lock(&temp->d_lock); |
| inode = d_inode(temp); |
| if (inode && ceph_snap(inode) == CEPH_SNAPDIR) { |
| dout("build_path path+%d: %p SNAPDIR\n", |
| pos, temp); |
| } else if (stop_on_nosnap && inode && dentry != temp && |
| ceph_snap(inode) == CEPH_NOSNAP) { |
| spin_unlock(&temp->d_lock); |
| pos++; /* get rid of any prepended '/' */ |
| break; |
| } else { |
| pos -= temp->d_name.len; |
| if (pos < 0) { |
| spin_unlock(&temp->d_lock); |
| break; |
| } |
| memcpy(path + pos, temp->d_name.name, temp->d_name.len); |
| } |
| spin_unlock(&temp->d_lock); |
| temp = READ_ONCE(temp->d_parent); |
| |
| /* Are we at the root? */ |
| if (IS_ROOT(temp)) |
| break; |
| |
| /* Are we out of buffer? */ |
| if (--pos < 0) |
| break; |
| |
| path[pos] = '/'; |
| } |
| base = ceph_ino(d_inode(temp)); |
| rcu_read_unlock(); |
| |
| if (read_seqretry(&rename_lock, seq)) |
| goto retry; |
| |
| if (pos < 0) { |
| /* |
| * A rename didn't occur, but somehow we didn't end up where |
| * we thought we would. Throw a warning and try again. |
| */ |
| pr_warn("build_path did not end path lookup where " |
| "expected, pos is %d\n", pos); |
| goto retry; |
| } |
| |
| *pbase = base; |
| *plen = PATH_MAX - 1 - pos; |
| dout("build_path on %p %d built %llx '%.*s'\n", |
| dentry, d_count(dentry), base, *plen, path + pos); |
| return path + pos; |
| } |
| |
| static int build_dentry_path(struct dentry *dentry, struct inode *dir, |
| const char **ppath, int *ppathlen, u64 *pino, |
| bool *pfreepath, bool parent_locked) |
| { |
| char *path; |
| |
| rcu_read_lock(); |
| if (!dir) |
| dir = d_inode_rcu(dentry->d_parent); |
| if (dir && parent_locked && ceph_snap(dir) == CEPH_NOSNAP) { |
| *pino = ceph_ino(dir); |
| rcu_read_unlock(); |
| *ppath = dentry->d_name.name; |
| *ppathlen = dentry->d_name.len; |
| return 0; |
| } |
| rcu_read_unlock(); |
| path = ceph_mdsc_build_path(dentry, ppathlen, pino, 1); |
| if (IS_ERR(path)) |
| return PTR_ERR(path); |
| *ppath = path; |
| *pfreepath = true; |
| return 0; |
| } |
| |
| static int build_inode_path(struct inode *inode, |
| const char **ppath, int *ppathlen, u64 *pino, |
| bool *pfreepath) |
| { |
| struct dentry *dentry; |
| char *path; |
| |
| if (ceph_snap(inode) == CEPH_NOSNAP) { |
| *pino = ceph_ino(inode); |
| *ppathlen = 0; |
| return 0; |
| } |
| dentry = d_find_alias(inode); |
| path = ceph_mdsc_build_path(dentry, ppathlen, pino, 1); |
| dput(dentry); |
| if (IS_ERR(path)) |
| return PTR_ERR(path); |
| *ppath = path; |
| *pfreepath = true; |
| return 0; |
| } |
| |
| /* |
| * request arguments may be specified via an inode *, a dentry *, or |
| * an explicit ino+path. |
| */ |
| static int set_request_path_attr(struct inode *rinode, struct dentry *rdentry, |
| struct inode *rdiri, const char *rpath, |
| u64 rino, const char **ppath, int *pathlen, |
| u64 *ino, bool *freepath, bool parent_locked) |
| { |
| int r = 0; |
| |
| if (rinode) { |
| r = build_inode_path(rinode, ppath, pathlen, ino, freepath); |
| dout(" inode %p %llx.%llx\n", rinode, ceph_ino(rinode), |
| ceph_snap(rinode)); |
| } else if (rdentry) { |
| r = build_dentry_path(rdentry, rdiri, ppath, pathlen, ino, |
| freepath, parent_locked); |
| dout(" dentry %p %llx/%.*s\n", rdentry, *ino, *pathlen, |
| *ppath); |
| } else if (rpath || rino) { |
| *ino = rino; |
| *ppath = rpath; |
| *pathlen = rpath ? strlen(rpath) : 0; |
| dout(" path %.*s\n", *pathlen, rpath); |
| } |
| |
| return r; |
| } |
| |
| static void encode_timestamp_and_gids(void **p, |
| const struct ceph_mds_request *req) |
| { |
| struct ceph_timespec ts; |
| int i; |
| |
| ceph_encode_timespec64(&ts, &req->r_stamp); |
| ceph_encode_copy(p, &ts, sizeof(ts)); |
| |
| /* gid_list */ |
| ceph_encode_32(p, req->r_cred->group_info->ngroups); |
| for (i = 0; i < req->r_cred->group_info->ngroups; i++) |
| ceph_encode_64(p, from_kgid(&init_user_ns, |
| req->r_cred->group_info->gid[i])); |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| static struct ceph_msg *create_request_message(struct ceph_mds_session *session, |
| struct ceph_mds_request *req, |
| bool drop_cap_releases) |
| { |
| int mds = session->s_mds; |
| struct ceph_mds_client *mdsc = session->s_mdsc; |
| struct ceph_msg *msg; |
| struct ceph_mds_request_head_old *head; |
| const char *path1 = NULL; |
| const char *path2 = NULL; |
| u64 ino1 = 0, ino2 = 0; |
| int pathlen1 = 0, pathlen2 = 0; |
| bool freepath1 = false, freepath2 = false; |
| int len; |
| u16 releases; |
| void *p, *end; |
| int ret; |
| bool legacy = !(session->s_con.peer_features & CEPH_FEATURE_FS_BTIME); |
| |
| ret = set_request_path_attr(req->r_inode, req->r_dentry, |
| req->r_parent, req->r_path1, req->r_ino1.ino, |
| &path1, &pathlen1, &ino1, &freepath1, |
| test_bit(CEPH_MDS_R_PARENT_LOCKED, |
| &req->r_req_flags)); |
| if (ret < 0) { |
| msg = ERR_PTR(ret); |
| goto out; |
| } |
| |
| /* If r_old_dentry is set, then assume that its parent is locked */ |
| ret = set_request_path_attr(NULL, req->r_old_dentry, |
| req->r_old_dentry_dir, |
| req->r_path2, req->r_ino2.ino, |
| &path2, &pathlen2, &ino2, &freepath2, true); |
| if (ret < 0) { |
| msg = ERR_PTR(ret); |
| goto out_free1; |
| } |
| |
| len = legacy ? sizeof(*head) : sizeof(struct ceph_mds_request_head); |
| len += pathlen1 + pathlen2 + 2*(1 + sizeof(u32) + sizeof(u64)) + |
| sizeof(struct ceph_timespec); |
| len += sizeof(u32) + (sizeof(u64) * req->r_cred->group_info->ngroups); |
| |
| /* calculate (max) length for cap releases */ |
| len += sizeof(struct ceph_mds_request_release) * |
| (!!req->r_inode_drop + !!req->r_dentry_drop + |
| !!req->r_old_inode_drop + !!req->r_old_dentry_drop); |
| |
| if (req->r_dentry_drop) |
| len += pathlen1; |
| if (req->r_old_dentry_drop) |
| len += pathlen2; |
| |
| msg = ceph_msg_new2(CEPH_MSG_CLIENT_REQUEST, len, 1, GFP_NOFS, false); |
| if (!msg) { |
| msg = ERR_PTR(-ENOMEM); |
| goto out_free2; |
| } |
| |
| msg->hdr.tid = cpu_to_le64(req->r_tid); |
| |
| /* |
| * The old ceph_mds_request_head didn't contain a version field, and |
| * one was added when we moved the message version from 3->4. |
| */ |
| if (legacy) { |
| msg->hdr.version = cpu_to_le16(3); |
| head = msg->front.iov_base; |
| p = msg->front.iov_base + sizeof(*head); |
| } else { |
| struct ceph_mds_request_head *new_head = msg->front.iov_base; |
| |
| msg->hdr.version = cpu_to_le16(4); |
| new_head->version = cpu_to_le16(CEPH_MDS_REQUEST_HEAD_VERSION); |
| head = (struct ceph_mds_request_head_old *)&new_head->oldest_client_tid; |
| p = msg->front.iov_base + sizeof(*new_head); |
| } |
| |
| end = msg->front.iov_base + msg->front.iov_len; |
| |
| head->mdsmap_epoch = cpu_to_le32(mdsc->mdsmap->m_epoch); |
| head->op = cpu_to_le32(req->r_op); |
| head->caller_uid = cpu_to_le32(from_kuid(&init_user_ns, |
| req->r_cred->fsuid)); |
| head->caller_gid = cpu_to_le32(from_kgid(&init_user_ns, |
| req->r_cred->fsgid)); |
| head->ino = cpu_to_le64(req->r_deleg_ino); |
| head->args = req->r_args; |
| |
| ceph_encode_filepath(&p, end, ino1, path1); |
| ceph_encode_filepath(&p, end, ino2, path2); |
| |
| /* make note of release offset, in case we need to replay */ |
| req->r_request_release_offset = p - msg->front.iov_base; |
| |
| /* cap releases */ |
| releases = 0; |
| if (req->r_inode_drop) |
| releases += ceph_encode_inode_release(&p, |
| req->r_inode ? req->r_inode : d_inode(req->r_dentry), |
| mds, req->r_inode_drop, req->r_inode_unless, |
| req->r_op == CEPH_MDS_OP_READDIR); |
| if (req->r_dentry_drop) |
| releases += ceph_encode_dentry_release(&p, req->r_dentry, |
| req->r_parent, mds, req->r_dentry_drop, |
| req->r_dentry_unless); |
| if (req->r_old_dentry_drop) |
| releases += ceph_encode_dentry_release(&p, req->r_old_dentry, |
| req->r_old_dentry_dir, mds, |
| req->r_old_dentry_drop, |
| req->r_old_dentry_unless); |
| if (req->r_old_inode_drop) |
| releases += ceph_encode_inode_release(&p, |
| d_inode(req->r_old_dentry), |
| mds, req->r_old_inode_drop, req->r_old_inode_unless, 0); |
| |
| if (drop_cap_releases) { |
| releases = 0; |
| p = msg->front.iov_base + req->r_request_release_offset; |
| } |
| |
| head->num_releases = cpu_to_le16(releases); |
| |
| encode_timestamp_and_gids(&p, req); |
| |
| if (WARN_ON_ONCE(p > end)) { |
| ceph_msg_put(msg); |
| msg = ERR_PTR(-ERANGE); |
| goto out_free2; |
| } |
| |
| msg->front.iov_len = p - msg->front.iov_base; |
| msg->hdr.front_len = cpu_to_le32(msg->front.iov_len); |
| |
| if (req->r_pagelist) { |
| struct ceph_pagelist *pagelist = req->r_pagelist; |
| ceph_msg_data_add_pagelist(msg, pagelist); |
| msg->hdr.data_len = cpu_to_le32(pagelist->length); |
| } else { |
| msg->hdr.data_len = 0; |
| } |
| |
| msg->hdr.data_off = cpu_to_le16(0); |
| |
| out_free2: |
| if (freepath2) |
| ceph_mdsc_free_path((char *)path2, pathlen2); |
| out_free1: |
| if (freepath1) |
| ceph_mdsc_free_path((char *)path1, pathlen1); |
| out: |
| return msg; |
| } |
| |
| /* |
| * called under mdsc->mutex if error, under no mutex if |
| * success. |
| */ |
| static void complete_request(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req) |
| { |
| req->r_end_latency = ktime_get(); |
| |
| if (req->r_callback) |
| req->r_callback(mdsc, req); |
| complete_all(&req->r_completion); |
| } |
| |
| static struct ceph_mds_request_head_old * |
| find_old_request_head(void *p, u64 features) |
| { |
| bool legacy = !(features & CEPH_FEATURE_FS_BTIME); |
| struct ceph_mds_request_head *new_head; |
| |
| if (legacy) |
| return (struct ceph_mds_request_head_old *)p; |
| new_head = (struct ceph_mds_request_head *)p; |
| return (struct ceph_mds_request_head_old *)&new_head->oldest_client_tid; |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| static int __prepare_send_request(struct ceph_mds_session *session, |
| struct ceph_mds_request *req, |
| bool drop_cap_releases) |
| { |
| int mds = session->s_mds; |
| struct ceph_mds_client *mdsc = session->s_mdsc; |
| struct ceph_mds_request_head_old *rhead; |
| struct ceph_msg *msg; |
| int flags = 0; |
| |
| req->r_attempts++; |
| if (req->r_inode) { |
| struct ceph_cap *cap = |
| ceph_get_cap_for_mds(ceph_inode(req->r_inode), mds); |
| |
| if (cap) |
| req->r_sent_on_mseq = cap->mseq; |
| else |
| req->r_sent_on_mseq = -1; |
| } |
| dout("prepare_send_request %p tid %lld %s (attempt %d)\n", req, |
| req->r_tid, ceph_mds_op_name(req->r_op), req->r_attempts); |
| |
| if (test_bit(CEPH_MDS_R_GOT_UNSAFE, &req->r_req_flags)) { |
| void *p; |
| |
| /* |
| * Replay. Do not regenerate message (and rebuild |
| * paths, etc.); just use the original message. |
| * Rebuilding paths will break for renames because |
| * d_move mangles the src name. |
| */ |
| msg = req->r_request; |
| rhead = find_old_request_head(msg->front.iov_base, |
| session->s_con.peer_features); |
| |
| flags = le32_to_cpu(rhead->flags); |
| flags |= CEPH_MDS_FLAG_REPLAY; |
| rhead->flags = cpu_to_le32(flags); |
| |
| if (req->r_target_inode) |
| rhead->ino = cpu_to_le64(ceph_ino(req->r_target_inode)); |
| |
| rhead->num_retry = req->r_attempts - 1; |
| |
| /* remove cap/dentry releases from message */ |
| rhead->num_releases = 0; |
| |
| p = msg->front.iov_base + req->r_request_release_offset; |
| encode_timestamp_and_gids(&p, req); |
| |
| msg->front.iov_len = p - msg->front.iov_base; |
| msg->hdr.front_len = cpu_to_le32(msg->front.iov_len); |
| return 0; |
| } |
| |
| if (req->r_request) { |
| ceph_msg_put(req->r_request); |
| req->r_request = NULL; |
| } |
| msg = create_request_message(session, req, drop_cap_releases); |
| if (IS_ERR(msg)) { |
| req->r_err = PTR_ERR(msg); |
| return PTR_ERR(msg); |
| } |
| req->r_request = msg; |
| |
| rhead = find_old_request_head(msg->front.iov_base, |
| session->s_con.peer_features); |
| rhead->oldest_client_tid = cpu_to_le64(__get_oldest_tid(mdsc)); |
| if (test_bit(CEPH_MDS_R_GOT_UNSAFE, &req->r_req_flags)) |
| flags |= CEPH_MDS_FLAG_REPLAY; |
| if (test_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags)) |
| flags |= CEPH_MDS_FLAG_ASYNC; |
| if (req->r_parent) |
| flags |= CEPH_MDS_FLAG_WANT_DENTRY; |
| rhead->flags = cpu_to_le32(flags); |
| rhead->num_fwd = req->r_num_fwd; |
| rhead->num_retry = req->r_attempts - 1; |
| |
| dout(" r_parent = %p\n", req->r_parent); |
| return 0; |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| static int __send_request(struct ceph_mds_session *session, |
| struct ceph_mds_request *req, |
| bool drop_cap_releases) |
| { |
| int err; |
| |
| err = __prepare_send_request(session, req, drop_cap_releases); |
| if (!err) { |
| ceph_msg_get(req->r_request); |
| ceph_con_send(&session->s_con, req->r_request); |
| } |
| |
| return err; |
| } |
| |
| /* |
| * send request, or put it on the appropriate wait list. |
| */ |
| static void __do_request(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req) |
| { |
| struct ceph_mds_session *session = NULL; |
| int mds = -1; |
| int err = 0; |
| bool random; |
| |
| if (req->r_err || test_bit(CEPH_MDS_R_GOT_RESULT, &req->r_req_flags)) { |
| if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) |
| __unregister_request(mdsc, req); |
| return; |
| } |
| |
| if (req->r_timeout && |
| time_after_eq(jiffies, req->r_started + req->r_timeout)) { |
| dout("do_request timed out\n"); |
| err = -ETIMEDOUT; |
| goto finish; |
| } |
| if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) { |
| dout("do_request forced umount\n"); |
| err = -EIO; |
| goto finish; |
| } |
| if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_MOUNTING) { |
| if (mdsc->mdsmap_err) { |
| err = mdsc->mdsmap_err; |
| dout("do_request mdsmap err %d\n", err); |
| goto finish; |
| } |
| if (mdsc->mdsmap->m_epoch == 0) { |
| dout("do_request no mdsmap, waiting for map\n"); |
| list_add(&req->r_wait, &mdsc->waiting_for_map); |
| return; |
| } |
| if (!(mdsc->fsc->mount_options->flags & |
| CEPH_MOUNT_OPT_MOUNTWAIT) && |
| !ceph_mdsmap_is_cluster_available(mdsc->mdsmap)) { |
| err = -EHOSTUNREACH; |
| goto finish; |
| } |
| } |
| |
| put_request_session(req); |
| |
| mds = __choose_mds(mdsc, req, &random); |
| if (mds < 0 || |
| ceph_mdsmap_get_state(mdsc->mdsmap, mds) < CEPH_MDS_STATE_ACTIVE) { |
| if (test_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags)) { |
| err = -EJUKEBOX; |
| goto finish; |
| } |
| dout("do_request no mds or not active, waiting for map\n"); |
| list_add(&req->r_wait, &mdsc->waiting_for_map); |
| return; |
| } |
| |
| /* get, open session */ |
| session = __ceph_lookup_mds_session(mdsc, mds); |
| if (!session) { |
| session = register_session(mdsc, mds); |
| if (IS_ERR(session)) { |
| err = PTR_ERR(session); |
| goto finish; |
| } |
| } |
| req->r_session = ceph_get_mds_session(session); |
| |
| dout("do_request mds%d session %p state %s\n", mds, session, |
| ceph_session_state_name(session->s_state)); |
| if (session->s_state != CEPH_MDS_SESSION_OPEN && |
| session->s_state != CEPH_MDS_SESSION_HUNG) { |
| /* |
| * We cannot queue async requests since the caps and delegated |
| * inodes are bound to the session. Just return -EJUKEBOX and |
| * let the caller retry a sync request in that case. |
| */ |
| if (test_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags)) { |
| err = -EJUKEBOX; |
| goto out_session; |
| } |
| |
| /* |
| * If the session has been REJECTED, then return a hard error, |
| * unless it's a CLEANRECOVER mount, in which case we'll queue |
| * it to the mdsc queue. |
| */ |
| if (session->s_state == CEPH_MDS_SESSION_REJECTED) { |
| if (ceph_test_mount_opt(mdsc->fsc, CLEANRECOVER)) |
| list_add(&req->r_wait, &mdsc->waiting_for_map); |
| else |
| err = -EACCES; |
| goto out_session; |
| } |
| |
| if (session->s_state == CEPH_MDS_SESSION_NEW || |
| session->s_state == CEPH_MDS_SESSION_CLOSING) { |
| err = __open_session(mdsc, session); |
| if (err) |
| goto out_session; |
| /* retry the same mds later */ |
| if (random) |
| req->r_resend_mds = mds; |
| } |
| list_add(&req->r_wait, &session->s_waiting); |
| goto out_session; |
| } |
| |
| /* send request */ |
| req->r_resend_mds = -1; /* forget any previous mds hint */ |
| |
| if (req->r_request_started == 0) /* note request start time */ |
| req->r_request_started = jiffies; |
| |
| err = __send_request(session, req, false); |
| |
| out_session: |
| ceph_put_mds_session(session); |
| finish: |
| if (err) { |
| dout("__do_request early error %d\n", err); |
| req->r_err = err; |
| complete_request(mdsc, req); |
| __unregister_request(mdsc, req); |
| } |
| return; |
| } |
| |
| /* |
| * called under mdsc->mutex |
| */ |
| static void __wake_requests(struct ceph_mds_client *mdsc, |
| struct list_head *head) |
| { |
| struct ceph_mds_request *req; |
| LIST_HEAD(tmp_list); |
| |
| list_splice_init(head, &tmp_list); |
| |
| while (!list_empty(&tmp_list)) { |
| req = list_entry(tmp_list.next, |
| struct ceph_mds_request, r_wait); |
| list_del_init(&req->r_wait); |
| dout(" wake request %p tid %llu\n", req, req->r_tid); |
| __do_request(mdsc, req); |
| } |
| } |
| |
| /* |
| * Wake up threads with requests pending for @mds, so that they can |
| * resubmit their requests to a possibly different mds. |
| */ |
| static void kick_requests(struct ceph_mds_client *mdsc, int mds) |
| { |
| struct ceph_mds_request *req; |
| struct rb_node *p = rb_first(&mdsc->request_tree); |
| |
| dout("kick_requests mds%d\n", mds); |
| while (p) { |
| req = rb_entry(p, struct ceph_mds_request, r_node); |
| p = rb_next(p); |
| if (test_bit(CEPH_MDS_R_GOT_UNSAFE, &req->r_req_flags)) |
| continue; |
| if (req->r_attempts > 0) |
| continue; /* only new requests */ |
| if (req->r_session && |
| req->r_session->s_mds == mds) { |
| dout(" kicking tid %llu\n", req->r_tid); |
| list_del_init(&req->r_wait); |
| __do_request(mdsc, req); |
| } |
| } |
| } |
| |
| int ceph_mdsc_submit_request(struct ceph_mds_client *mdsc, struct inode *dir, |
| struct ceph_mds_request *req) |
| { |
| int err = 0; |
| |
| /* take CAP_PIN refs for r_inode, r_parent, r_old_dentry */ |
| if (req->r_inode) |
| ceph_get_cap_refs(ceph_inode(req->r_inode), CEPH_CAP_PIN); |
| if (req->r_parent) { |
| struct ceph_inode_info *ci = ceph_inode(req->r_parent); |
| int fmode = (req->r_op & CEPH_MDS_OP_WRITE) ? |
| CEPH_FILE_MODE_WR : CEPH_FILE_MODE_RD; |
| spin_lock(&ci->i_ceph_lock); |
| ceph_take_cap_refs(ci, CEPH_CAP_PIN, false); |
| __ceph_touch_fmode(ci, mdsc, fmode); |
| spin_unlock(&ci->i_ceph_lock); |
| } |
| if (req->r_old_dentry_dir) |
| ceph_get_cap_refs(ceph_inode(req->r_old_dentry_dir), |
| CEPH_CAP_PIN); |
| |
| if (req->r_inode) { |
| err = ceph_wait_on_async_create(req->r_inode); |
| if (err) { |
| dout("%s: wait for async create returned: %d\n", |
| __func__, err); |
| return err; |
| } |
| } |
| |
| if (!err && req->r_old_inode) { |
| err = ceph_wait_on_async_create(req->r_old_inode); |
| if (err) { |
| dout("%s: wait for async create returned: %d\n", |
| __func__, err); |
| return err; |
| } |
| } |
| |
| dout("submit_request on %p for inode %p\n", req, dir); |
| mutex_lock(&mdsc->mutex); |
| __register_request(mdsc, req, dir); |
| __do_request(mdsc, req); |
| err = req->r_err; |
| mutex_unlock(&mdsc->mutex); |
| return err; |
| } |
| |
| static int ceph_mdsc_wait_request(struct ceph_mds_client *mdsc, |
| struct ceph_mds_request *req) |
| { |
| int err; |
| |
| /* wait */ |
| dout("do_request waiting\n"); |
| if (!req->r_timeout && req->r_wait_for_completion) { |
| err = req->r_wait_for_completion(mdsc, req); |
| } else { |
| long timeleft = wait_for_completion_killable_timeout( |
| &req->r_completion, |
| ceph_timeout_jiffies(req->r_timeout)); |
| if (timeleft > 0) |
| err = 0; |
| else if (!timeleft) |
| err = -ETIMEDOUT; /* timed out */ |
| else |
| err = timeleft; /* killed */ |
| } |
| dout("do_request waited, got %d\n", err); |
| mutex_lock(&mdsc->mutex); |
| |
| /* only abort if we didn't race with a real reply */ |
| if (test_bit(CEPH_MDS_R_GOT_RESULT, &req->r_req_flags)) { |
| err = le32_to_cpu(req->r_reply_info.head->result); |
| } else if (err < 0) { |
| dout("aborted request %lld with %d\n", req->r_tid, err); |
| |
| /* |
| * ensure we aren't running concurrently with |
| * ceph_fill_trace or ceph_readdir_prepopulate, which |
| * rely on locks (dir mutex) held by our caller. |
| */ |
| mutex_lock(&req->r_fill_mutex); |
| req->r_err = err; |
| set_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags); |
| mutex_unlock(&req->r_fill_mutex); |
| |
| if (req->r_parent && |
| (req->r_op & CEPH_MDS_OP_WRITE)) |
| ceph_invalidate_dir_request(req); |
| } else { |
| err = req->r_err; |
| } |
| |
| mutex_unlock(&mdsc->mutex); |
| return err; |
| } |
| |
| /* |
| * Synchrously perform an mds request. Take care of all of the |
| * session setup, forwarding, retry details. |
| */ |
| int ceph_mdsc_do_request( |