Lines Matching refs:mdsc
60 static void __wake_requests(struct ceph_mds_client *mdsc,
653 dout("mdsc get_session %p %d -> %d\n", s,
657 dout("mdsc get_session %p 0 -- FAIL\n", s);
667 dout("mdsc put_session %p %d -> %d\n", s,
679 * called under mdsc->mutex
681 struct ceph_mds_session *__ceph_lookup_mds_session(struct ceph_mds_client *mdsc,
684 if (mds >= mdsc->max_sessions || !mdsc->sessions[mds])
686 return ceph_get_mds_session(mdsc->sessions[mds]);
689 static bool __have_session(struct ceph_mds_client *mdsc, int mds)
691 if (mds >= mdsc->max_sessions || !mdsc->sessions[mds])
697 static int __verify_registered_session(struct ceph_mds_client *mdsc,
700 if (s->s_mds >= mdsc->max_sessions ||
701 mdsc->sessions[s->s_mds] != s)
708 * called under mdsc->mutex.
710 static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,
715 if (mds >= mdsc->mdsmap->possible_max_rank)
722 if (mds >= mdsc->max_sessions) {
730 if (mdsc->sessions) {
731 memcpy(sa, mdsc->sessions,
732 mdsc->max_sessions * sizeof(void *));
733 kfree(mdsc->sessions);
735 mdsc->sessions = sa;
736 mdsc->max_sessions = newmax;
740 s->s_mdsc = mdsc;
747 ceph_con_init(&s->s_con, s, &mds_con_ops, &mdsc->fsc->client->msgr);
771 mdsc->sessions[mds] = s;
772 atomic_inc(&mdsc->num_sessions);
776 ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
786 * called under mdsc->mutex
788 static void __unregister_session(struct ceph_mds_client *mdsc,
792 BUG_ON(mdsc->sessions[s->s_mds] != s);
793 mdsc->sessions[s->s_mds] = NULL;
796 atomic_dec(&mdsc->num_sessions);
802 * should be last request ref, or hold mdsc->mutex
812 void ceph_mdsc_iterate_sessions(struct ceph_mds_client *mdsc,
818 mutex_lock(&mdsc->mutex);
819 for (mds = 0; mds < mdsc->max_sessions; ++mds) {
822 s = __ceph_lookup_mds_session(mdsc, mds);
831 mutex_unlock(&mdsc->mutex);
834 mutex_lock(&mdsc->mutex);
836 mutex_unlock(&mdsc->mutex);
890 * called under mdsc->mutex.
893 lookup_get_request(struct ceph_mds_client *mdsc, u64 tid)
897 req = lookup_request(&mdsc->request_tree, tid);
908 * Called under mdsc->mutex.
910 static void __register_request(struct ceph_mds_client *mdsc,
916 req->r_tid = ++mdsc->last_tid;
918 ret = ceph_reserve_caps(mdsc, &req->r_caps_reservation,
930 insert_request(&mdsc->request_tree, req);
935 if (mdsc->oldest_tid == 0 && req->r_op != CEPH_MDS_OP_SETFILELOCK)
936 mdsc->oldest_tid = req->r_tid;
949 static void __unregister_request(struct ceph_mds_client *mdsc,
957 if (req->r_tid == mdsc->oldest_tid) {
959 mdsc->oldest_tid = 0;
964 mdsc->oldest_tid = next_req->r_tid;
971 erase_request(&mdsc->request_tree, req);
1026 * Called under mdsc->mutex.
1028 static int __choose_mds(struct ceph_mds_client *mdsc,
1048 (__have_session(mdsc, req->r_resend_mds) ||
1049 ceph_mdsmap_get_state(mdsc->mdsmap, req->r_resend_mds) > 0)) {
1079 if (!dir || dir->i_sb != mdsc->fsc->sb) {
1126 if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >=
1128 !ceph_mdsmap_is_laggy(mdsc->mdsmap, mds))
1141 if (ceph_mdsmap_get_state(mdsc->mdsmap, mds) >=
1143 if (!ceph_mdsmap_is_laggy(mdsc->mdsmap,
1169 /* avoid calling iput_final() while holding mdsc->mutex or
1178 mds = ceph_mdsmap_get_random_mds(mdsc->mdsmap);
1283 static struct ceph_msg *create_session_open_msg(struct ceph_mds_client *mdsc, u64 seq)
1290 struct ceph_options *opt = mdsc->fsc->client->options;
1291 struct ceph_mount_options *fsopt = mdsc->fsc->mount_options;
1297 {"hostname", mdsc->nodename},
1391 * called under mdsc->mutex
1393 static int __open_session(struct ceph_mds_client *mdsc,
1401 mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds);
1408 msg = create_session_open_msg(mdsc, session->s_seq);
1418 * called under mdsc->mutex
1421 __open_export_target_session(struct ceph_mds_client *mdsc, int target)
1426 session = __ceph_lookup_mds_session(mdsc, target);
1428 session = register_session(mdsc, target);
1434 ret = __open_session(mdsc, session);
1443 ceph_mdsc_open_export_target_session(struct ceph_mds_client *mdsc, int target)
1449 mutex_lock(&mdsc->mutex);
1450 session = __open_export_target_session(mdsc, target);
1451 mutex_unlock(&mdsc->mutex);
1456 static void __open_export_target_sessions(struct ceph_mds_client *mdsc,
1463 if (mds >= mdsc->mdsmap->possible_max_rank)
1466 mi = &mdsc->mdsmap->m_info[mds];
1471 ts = __open_export_target_session(mdsc, mi->export_targets[i]);
1476 void ceph_mdsc_open_export_target_sessions(struct ceph_mds_client *mdsc,
1479 mutex_lock(&mdsc->mutex);
1480 __open_export_target_sessions(mdsc, session);
1481 mutex_unlock(&mdsc->mutex);
1498 static void dispose_cap_releases(struct ceph_mds_client *mdsc,
1506 ceph_put_cap(mdsc, cap);
1510 static void cleanup_session_requests(struct ceph_mds_client *mdsc,
1517 mutex_lock(&mdsc->mutex);
1527 __unregister_request(mdsc, req);
1530 p = rb_first(&mdsc->request_tree);
1538 mutex_unlock(&mdsc->mutex);
1614 static int remove_capsnaps(struct ceph_mds_client *mdsc, struct inode *inode)
1633 wake_up_all(&mdsc->cap_flushing_wq);
1641 struct ceph_mds_client *mdsc = fsc->mdsc;
1668 spin_lock(&mdsc->cap_dirty_lock);
1689 mdsc->num_cap_flushing--;
1692 spin_unlock(&mdsc->cap_dirty_lock);
1719 capsnap_release = remove_capsnaps(mdsc, inode);
1753 wake_up_all(&fsc->mdsc->cap_flushing_wq);
1842 static int send_renew_caps(struct ceph_mds_client *mdsc,
1855 state = ceph_mdsmap_get_state(mdsc->mdsmap, session->s_mds);
1872 static int send_flushmsg_ack(struct ceph_mds_client *mdsc,
1892 static void renewed_caps(struct ceph_mds_client *mdsc,
1902 mdsc->mdsmap->m_session_timeout*HZ;
1942 static int __close_session(struct ceph_mds_client *mdsc,
2057 int ceph_trim_caps(struct ceph_mds_client *mdsc,
2074 ceph_flush_cap_releases(mdsc, session);
2078 static int check_caps_flush(struct ceph_mds_client *mdsc,
2083 spin_lock(&mdsc->cap_dirty_lock);
2084 if (!list_empty(&mdsc->cap_flush_list)) {
2086 list_first_entry(&mdsc->cap_flush_list,
2094 spin_unlock(&mdsc->cap_dirty_lock);
2103 static void wait_caps_flush(struct ceph_mds_client *mdsc,
2108 wait_event(mdsc->cap_flushing_wq,
2109 check_caps_flush(mdsc, want_flush_tid));
2117 static void ceph_send_cap_releases(struct ceph_mds_client *mdsc,
2123 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
2169 ceph_put_cap(mdsc, cap);
2224 void ceph_flush_cap_releases(struct ceph_mds_client *mdsc,
2227 if (mdsc->stopping)
2231 if (queue_work(mdsc->fsc->cap_wq,
2255 struct ceph_mds_client *mdsc =
2257 int ret = ceph_trim_dentries(mdsc);
2259 ceph_queue_cap_reclaim_work(mdsc);
2262 void ceph_queue_cap_reclaim_work(struct ceph_mds_client *mdsc)
2264 if (mdsc->stopping)
2267 if (queue_work(mdsc->fsc->cap_wq, &mdsc->cap_reclaim_work)) {
2274 void ceph_reclaim_caps_nr(struct ceph_mds_client *mdsc, int nr)
2279 val = atomic_add_return(nr, &mdsc->cap_reclaim_pending);
2281 atomic_set(&mdsc->cap_reclaim_pending, 0);
2282 ceph_queue_cap_reclaim_work(mdsc);
2332 ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op, int mode)
2341 req->r_mdsc = mdsc;
2365 * called under mdsc->mutex.
2367 static struct ceph_mds_request *__get_oldest_req(struct ceph_mds_client *mdsc)
2369 if (RB_EMPTY_ROOT(&mdsc->request_tree))
2371 return rb_entry(rb_first(&mdsc->request_tree),
2375 static inline u64 __get_oldest_tid(struct ceph_mds_client *mdsc)
2377 return mdsc->oldest_tid;
2547 * called under mdsc->mutex
2549 static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
2611 head->mdsmap_epoch = cpu_to_le32(mdsc->mdsmap->m_epoch);
2689 * called under mdsc->mutex if error, under no mutex if
2692 static void complete_request(struct ceph_mds_client *mdsc,
2698 req->r_callback(mdsc, req);
2703 * called under mdsc->mutex
2705 static int __prepare_send_request(struct ceph_mds_client *mdsc,
2766 msg = create_request_message(mdsc, req, mds, drop_cap_releases);
2774 rhead->oldest_client_tid = cpu_to_le64(__get_oldest_tid(mdsc));
2790 * called under mdsc->mutex
2792 static int __send_request(struct ceph_mds_client *mdsc,
2799 err = __prepare_send_request(mdsc, req, session->s_mds,
2812 static void __do_request(struct ceph_mds_client *mdsc,
2822 __unregister_request(mdsc, req);
2832 if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
2837 if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_MOUNTING) {
2838 if (mdsc->mdsmap_err) {
2839 err = mdsc->mdsmap_err;
2843 if (mdsc->mdsmap->m_epoch == 0) {
2845 list_add(&req->r_wait, &mdsc->waiting_for_map);
2848 if (!(mdsc->fsc->mount_options->flags &
2850 !ceph_mdsmap_is_cluster_available(mdsc->mdsmap)) {
2858 mds = __choose_mds(mdsc, req, &random);
2860 ceph_mdsmap_get_state(mdsc->mdsmap, mds) < CEPH_MDS_STATE_ACTIVE) {
2866 list_add(&req->r_wait, &mdsc->waiting_for_map);
2871 session = __ceph_lookup_mds_session(mdsc, mds);
2873 session = register_session(mdsc, mds);
2900 err = __open_session(mdsc, session);
2917 err = __send_request(mdsc, session, req, false);
2925 complete_request(mdsc, req);
2926 __unregister_request(mdsc, req);
2932 * called under mdsc->mutex
2934 static void __wake_requests(struct ceph_mds_client *mdsc,
2947 __do_request(mdsc, req);
2955 static void kick_requests(struct ceph_mds_client *mdsc, int mds)
2958 struct rb_node *p = rb_first(&mdsc->request_tree);
2972 __do_request(mdsc, req);
2977 int ceph_mdsc_submit_request(struct ceph_mds_client *mdsc, struct inode *dir,
2991 __ceph_touch_fmode(ci, mdsc, fmode);
3018 mutex_lock(&mdsc->mutex);
3019 __register_request(mdsc, req, dir);
3020 __do_request(mdsc, req);
3022 mutex_unlock(&mdsc->mutex);
3026 static int ceph_mdsc_wait_request(struct ceph_mds_client *mdsc,
3034 err = req->r_wait_for_completion(mdsc, req);
3047 mutex_lock(&mdsc->mutex);
3072 mutex_unlock(&mdsc->mutex);
3080 int ceph_mdsc_do_request(struct ceph_mds_client *mdsc,
3089 err = ceph_mdsc_submit_request(mdsc, dir, req);
3091 err = ceph_mdsc_wait_request(mdsc, req);
3125 struct ceph_mds_client *mdsc = session->s_mdsc;
3142 mutex_lock(&mdsc->mutex);
3143 req = lookup_get_request(mdsc, tid);
3146 mutex_unlock(&mdsc->mutex);
3156 mutex_unlock(&mdsc->mutex);
3165 mutex_unlock(&mdsc->mutex);
3171 mutex_unlock(&mdsc->mutex);
3190 __do_request(mdsc, req);
3191 mutex_unlock(&mdsc->mutex);
3194 int mds = __choose_mds(mdsc, req, NULL);
3197 __do_request(mdsc, req);
3198 mutex_unlock(&mdsc->mutex);
3208 __unregister_request(mdsc, req);
3211 if (mdsc->stopping && !__get_oldest_req(mdsc))
3212 complete_all(&mdsc->safe_umount_waiters);
3224 mutex_unlock(&mdsc->mutex);
3238 mutex_unlock(&mdsc->mutex);
3250 down_write(&mdsc->snap_rwsem);
3251 ceph_update_snap_trace(mdsc, rinfo->snapblob,
3255 downgrade_write(&mdsc->snap_rwsem);
3257 down_read(&mdsc->snap_rwsem);
3263 err = ceph_fill_trace(mdsc->fsc->sb, req);
3272 up_read(&mdsc->snap_rwsem);
3274 ceph_put_snap_realm(mdsc, realm);
3287 ceph_unreserve_caps(mdsc, &req->r_caps_reservation);
3290 mutex_lock(&mdsc->mutex);
3301 mutex_unlock(&mdsc->mutex);
3306 complete_request(mdsc, req);
3308 ceph_update_metadata_latency(&mdsc->metric, req->r_start_latency,
3320 static void handle_forward(struct ceph_mds_client *mdsc,
3336 mutex_lock(&mdsc->mutex);
3337 req = lookup_get_request(mdsc, tid);
3345 __unregister_request(mdsc, req);
3358 __do_request(mdsc, req);
3362 mutex_unlock(&mdsc->mutex);
3403 struct ceph_mds_client *mdsc = session->s_mdsc;
3435 mutex_lock(&mdsc->mutex);
3438 __unregister_session(mdsc, session);
3441 session->s_ttl = jiffies + HZ*mdsc->mdsmap->m_session_autoclose;
3442 mutex_unlock(&mdsc->mutex);
3461 renewed_caps(mdsc, session, 0);
3463 metric_schedule_delayed(&mdsc->metric);
3465 if (mdsc->stopping)
3466 __close_session(mdsc, session);
3471 renewed_caps(mdsc, session, 1);
3478 cleanup_session_requests(mdsc, session);
3481 wake_up_all(&mdsc->session_close_wq);
3491 send_renew_caps(mdsc, session);
3495 ceph_trim_caps(mdsc, session, le32_to_cpu(h->max_caps));
3502 ceph_flush_cap_releases(mdsc, session);
3505 send_flushmsg_ack(mdsc, session, seq);
3520 cleanup_session_requests(mdsc, session);
3523 mdsc->fsc->blocklisted = true;
3534 mutex_lock(&mdsc->mutex);
3535 __wake_requests(mdsc, &session->s_waiting);
3537 kick_requests(mdsc, mds);
3538 mutex_unlock(&mdsc->mutex);
3577 static void replay_unsafe_requests(struct ceph_mds_client *mdsc,
3585 mutex_lock(&mdsc->mutex);
3587 __send_request(mdsc, session, req, true);
3593 p = rb_first(&mdsc->request_tree);
3608 __send_request(mdsc, session, req, true);
3610 mutex_unlock(&mdsc->mutex);
3904 static int encode_snap_realms(struct ceph_mds_client *mdsc,
3912 err = ceph_pagelist_encode_32(pagelist, mdsc->num_snap_realms);
3922 for (p = rb_first(&mdsc->snap_realms); p; p = rb_next(p)) {
3974 static void send_mds_reconnect(struct ceph_mds_client *mdsc,
4020 dispose_cap_releases(mdsc, &dispose);
4023 if (mdsc->fsc->sb->s_root)
4024 shrink_dcache_parent(mdsc->fsc->sb->s_root);
4029 ceph_mdsmap_get_addr(mdsc->mdsmap, mds));
4032 replay_unsafe_requests(mdsc, session);
4034 ceph_early_kick_flushing_caps(mdsc, session);
4036 down_read(&mdsc->snap_rwsem);
4062 if (mdsc->num_snap_realms) {
4065 mdsc->num_snap_realms *
4071 total_len += mdsc->num_snap_realms *
4088 err = encode_snap_realms(mdsc, &recon_state);
4104 WARN_ON(recon_state.nr_realms != mdsc->num_snap_realms);
4123 mutex_lock(&mdsc->mutex);
4124 __wake_requests(mdsc, &session->s_waiting);
4125 mutex_unlock(&mdsc->mutex);
4127 up_read(&mdsc->snap_rwsem);
4133 up_read(&mdsc->snap_rwsem);
4147 * called under mdsc->mutex.
4149 static void check_new_map(struct ceph_mds_client *mdsc,
4160 for (i = 0; i < oldmap->possible_max_rank && i < mdsc->max_sessions; i++) {
4161 if (!mdsc->sessions[i])
4163 s = mdsc->sessions[i];
4177 __unregister_session(mdsc, s);
4178 __wake_requests(mdsc, &s->s_waiting);
4179 mutex_unlock(&mdsc->mutex);
4182 cleanup_session_requests(mdsc, s);
4188 mutex_lock(&mdsc->mutex);
4189 kick_requests(mdsc, i);
4197 mutex_unlock(&mdsc->mutex);
4199 mutex_lock(&mdsc->mutex);
4212 mutex_unlock(&mdsc->mutex);
4213 send_mds_reconnect(mdsc, s);
4214 mutex_lock(&mdsc->mutex);
4225 kick_requests(mdsc, i);
4226 mutex_unlock(&mdsc->mutex);
4228 mutex_lock(&mdsc->mutex);
4229 ceph_kick_flushing_caps(mdsc, s);
4235 for (i = 0; i < newmap->possible_max_rank && i < mdsc->max_sessions; i++) {
4236 s = mdsc->sessions[i];
4246 __open_export_target_sessions(mdsc, s);
4268 static void handle_lease(struct ceph_mds_client *mdsc,
4272 struct super_block *sb = mdsc->fsc->sb;
4421 static void maybe_recover_session(struct ceph_mds_client *mdsc)
4423 struct ceph_fs_client *fsc = mdsc->fsc;
4492 static void schedule_delayed(struct ceph_mds_client *mdsc, unsigned long delay)
4499 schedule_delayed_work(&mdsc->delayed_work,
4505 struct ceph_mds_client *mdsc =
4512 dout("mdsc delayed_work\n");
4514 if (mdsc->stopping >= CEPH_MDSC_STOPPING_FLUSHED)
4517 mutex_lock(&mdsc->mutex);
4518 renew_interval = mdsc->mdsmap->m_session_timeout >> 2;
4520 mdsc->last_renew_caps);
4522 mdsc->last_renew_caps = jiffies;
4524 for (i = 0; i < mdsc->max_sessions; i++) {
4525 struct ceph_mds_session *s = __ceph_lookup_mds_session(mdsc, i);
4533 mutex_unlock(&mdsc->mutex);
4537 send_renew_caps(mdsc, s);
4542 ceph_send_cap_releases(mdsc, s);
4546 mutex_lock(&mdsc->mutex);
4548 mutex_unlock(&mdsc->mutex);
4550 delay = ceph_check_delayed_caps(mdsc);
4552 ceph_queue_cap_reclaim_work(mdsc);
4554 ceph_trim_snapid_map(mdsc);
4556 maybe_recover_session(mdsc);
4558 schedule_delayed(mdsc, delay);
4564 struct ceph_mds_client *mdsc;
4567 mdsc = kzalloc(sizeof(struct ceph_mds_client), GFP_NOFS);
4568 if (!mdsc)
4570 mdsc->fsc = fsc;
4571 mutex_init(&mdsc->mutex);
4572 mdsc->mdsmap = kzalloc(sizeof(*mdsc->mdsmap), GFP_NOFS);
4573 if (!mdsc->mdsmap) {
4578 init_completion(&mdsc->safe_umount_waiters);
4579 init_waitqueue_head(&mdsc->session_close_wq);
4580 INIT_LIST_HEAD(&mdsc->waiting_for_map);
4581 mdsc->sessions = NULL;
4582 atomic_set(&mdsc->num_sessions, 0);
4583 mdsc->max_sessions = 0;
4584 mdsc->stopping = 0;
4585 atomic64_set(&mdsc->quotarealms_count, 0);
4586 mdsc->quotarealms_inodes = RB_ROOT;
4587 mutex_init(&mdsc->quotarealms_inodes_mutex);
4588 mdsc->last_snap_seq = 0;
4589 init_rwsem(&mdsc->snap_rwsem);
4590 mdsc->snap_realms = RB_ROOT;
4591 INIT_LIST_HEAD(&mdsc->snap_empty);
4592 mdsc->num_snap_realms = 0;
4593 spin_lock_init(&mdsc->snap_empty_lock);
4594 mdsc->last_tid = 0;
4595 mdsc->oldest_tid = 0;
4596 mdsc->request_tree = RB_ROOT;
4597 INIT_DELAYED_WORK(&mdsc->delayed_work, delayed_work);
4598 mdsc->last_renew_caps = jiffies;
4599 INIT_LIST_HEAD(&mdsc->cap_delay_list);
4600 INIT_LIST_HEAD(&mdsc->cap_wait_list);
4601 spin_lock_init(&mdsc->cap_delay_lock);
4602 INIT_LIST_HEAD(&mdsc->snap_flush_list);
4603 spin_lock_init(&mdsc->snap_flush_lock);
4604 mdsc->last_cap_flush_tid = 1;
4605 INIT_LIST_HEAD(&mdsc->cap_flush_list);
4606 INIT_LIST_HEAD(&mdsc->cap_dirty_migrating);
4607 mdsc->num_cap_flushing = 0;
4608 spin_lock_init(&mdsc->cap_dirty_lock);
4609 init_waitqueue_head(&mdsc->cap_flushing_wq);
4610 INIT_WORK(&mdsc->cap_reclaim_work, ceph_cap_reclaim_work);
4611 atomic_set(&mdsc->cap_reclaim_pending, 0);
4612 err = ceph_metric_init(&mdsc->metric);
4616 spin_lock_init(&mdsc->dentry_list_lock);
4617 INIT_LIST_HEAD(&mdsc->dentry_leases);
4618 INIT_LIST_HEAD(&mdsc->dentry_dir_leases);
4620 ceph_caps_init(mdsc);
4621 ceph_adjust_caps_max_min(mdsc, fsc->mount_options);
4623 spin_lock_init(&mdsc->snapid_map_lock);
4624 mdsc->snapid_map_tree = RB_ROOT;
4625 INIT_LIST_HEAD(&mdsc->snapid_map_lru);
4627 init_rwsem(&mdsc->pool_perm_rwsem);
4628 mdsc->pool_perm_tree = RB_ROOT;
4630 strscpy(mdsc->nodename, utsname()->nodename,
4631 sizeof(mdsc->nodename));
4633 fsc->mdsc = mdsc;
4637 kfree(mdsc->mdsmap);
4639 kfree(mdsc);
4647 static void wait_requests(struct ceph_mds_client *mdsc)
4649 struct ceph_options *opts = mdsc->fsc->client->options;
4652 mutex_lock(&mdsc->mutex);
4653 if (__get_oldest_req(mdsc)) {
4654 mutex_unlock(&mdsc->mutex);
4657 wait_for_completion_timeout(&mdsc->safe_umount_waiters,
4661 mutex_lock(&mdsc->mutex);
4662 while ((req = __get_oldest_req(mdsc))) {
4666 __unregister_request(mdsc, req);
4669 mutex_unlock(&mdsc->mutex);
4701 void ceph_mdsc_pre_umount(struct ceph_mds_client *mdsc)
4704 mdsc->stopping = CEPH_MDSC_STOPPING_BEGIN;
4706 ceph_mdsc_iterate_sessions(mdsc, send_flush_mdlog, true);
4707 ceph_mdsc_iterate_sessions(mdsc, lock_unlock_session, false);
4708 ceph_flush_dirty_caps(mdsc);
4709 wait_requests(mdsc);
4717 ceph_cleanup_quotarealms_inodes(mdsc);
4723 static void wait_unsafe_requests(struct ceph_mds_client *mdsc, u64 want_tid)
4728 mutex_lock(&mdsc->mutex);
4731 req = __get_oldest_req(mdsc);
4745 mutex_unlock(&mdsc->mutex);
4749 mutex_lock(&mdsc->mutex);
4762 mutex_unlock(&mdsc->mutex);
4766 void ceph_mdsc_sync(struct ceph_mds_client *mdsc)
4770 if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN)
4774 mutex_lock(&mdsc->mutex);
4775 want_tid = mdsc->last_tid;
4776 mutex_unlock(&mdsc->mutex);
4778 ceph_flush_dirty_caps(mdsc);
4779 spin_lock(&mdsc->cap_dirty_lock);
4780 want_flush = mdsc->last_cap_flush_tid;
4781 if (!list_empty(&mdsc->cap_flush_list)) {
4783 list_last_entry(&mdsc->cap_flush_list,
4787 spin_unlock(&mdsc->cap_dirty_lock);
4792 wait_unsafe_requests(mdsc, want_tid);
4793 wait_caps_flush(mdsc, want_flush);
4799 static bool done_closing_sessions(struct ceph_mds_client *mdsc, int skipped)
4801 if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN)
4803 return atomic_read(&mdsc->num_sessions) <= skipped;
4809 void ceph_mdsc_close_sessions(struct ceph_mds_client *mdsc)
4811 struct ceph_options *opts = mdsc->fsc->client->options;
4819 mutex_lock(&mdsc->mutex);
4820 for (i = 0; i < mdsc->max_sessions; i++) {
4821 session = __ceph_lookup_mds_session(mdsc, i);
4824 mutex_unlock(&mdsc->mutex);
4826 if (__close_session(mdsc, session) <= 0)
4830 mutex_lock(&mdsc->mutex);
4832 mutex_unlock(&mdsc->mutex);
4835 wait_event_timeout(mdsc->session_close_wq,
4836 done_closing_sessions(mdsc, skipped),
4840 mutex_lock(&mdsc->mutex);
4841 for (i = 0; i < mdsc->max_sessions; i++) {
4842 if (mdsc->sessions[i]) {
4843 session = ceph_get_mds_session(mdsc->sessions[i]);
4844 __unregister_session(mdsc, session);
4845 mutex_unlock(&mdsc->mutex);
4850 mutex_lock(&mdsc->mutex);
4853 WARN_ON(!list_empty(&mdsc->cap_delay_list));
4854 mutex_unlock(&mdsc->mutex);
4856 ceph_cleanup_snapid_map(mdsc);
4857 ceph_cleanup_empty_realms(mdsc);
4859 cancel_work_sync(&mdsc->cap_reclaim_work);
4860 cancel_delayed_work_sync(&mdsc->delayed_work); /* cancel timer */
4865 void ceph_mdsc_force_umount(struct ceph_mds_client *mdsc)
4872 mutex_lock(&mdsc->mutex);
4873 for (mds = 0; mds < mdsc->max_sessions; mds++) {
4874 session = __ceph_lookup_mds_session(mdsc, mds);
4879 __unregister_session(mdsc, session);
4880 __wake_requests(mdsc, &session->s_waiting);
4881 mutex_unlock(&mdsc->mutex);
4884 __close_session(mdsc, session);
4886 cleanup_session_requests(mdsc, session);
4892 mutex_lock(&mdsc->mutex);
4893 kick_requests(mdsc, mds);
4895 __wake_requests(mdsc, &mdsc->waiting_for_map);
4896 mutex_unlock(&mdsc->mutex);
4899 static void ceph_mdsc_stop(struct ceph_mds_client *mdsc)
4910 flush_delayed_work(&mdsc->delayed_work);
4912 if (mdsc->mdsmap)
4913 ceph_mdsmap_destroy(mdsc->mdsmap);
4914 kfree(mdsc->sessions);
4915 ceph_caps_finalize(mdsc);
4916 ceph_pool_perm_destroy(mdsc);
4921 struct ceph_mds_client *mdsc = fsc->mdsc;
4922 dout("mdsc_destroy %p\n", mdsc);
4924 if (!mdsc)
4930 ceph_mdsc_stop(mdsc);
4932 ceph_metric_destroy(&mdsc->metric);
4934 fsc->mdsc = NULL;
4935 kfree(mdsc);
4936 dout("mdsc_destroy %p done\n", mdsc);
4939 void ceph_mdsc_handle_fsmap(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
4941 struct ceph_fs_client *fsc = mdsc->fsc;
5009 mutex_lock(&mdsc->mutex);
5010 mdsc->mdsmap_err = err;
5011 __wake_requests(mdsc, &mdsc->waiting_for_map);
5012 mutex_unlock(&mdsc->mutex);
5018 void ceph_mdsc_handle_mdsmap(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
5030 if (ceph_check_fsid(mdsc->fsc->client, &fsid) < 0)
5037 mutex_lock(&mdsc->mutex);
5038 if (mdsc->mdsmap && epoch <= mdsc->mdsmap->m_epoch) {
5040 epoch, mdsc->mdsmap->m_epoch);
5041 mutex_unlock(&mdsc->mutex);
5052 if (mdsc->mdsmap) {
5053 oldmap = mdsc->mdsmap;
5054 mdsc->mdsmap = newmap;
5055 check_new_map(mdsc, newmap, oldmap);
5058 mdsc->mdsmap = newmap; /* first mds map */
5060 mdsc->fsc->max_file_size = min((loff_t)mdsc->mdsmap->m_max_file_size,
5063 __wake_requests(mdsc, &mdsc->waiting_for_map);
5064 ceph_monc_got_map(&mdsc->fsc->client->monc, CEPH_SUB_MDSMAP,
5065 mdsc->mdsmap->m_epoch);
5067 mutex_unlock(&mdsc->mutex);
5068 schedule_delayed(mdsc, 0);
5072 mutex_unlock(&mdsc->mutex);
5101 struct ceph_mds_client *mdsc = s->s_mdsc;
5104 send_mds_reconnect(mdsc, s);
5110 struct ceph_mds_client *mdsc = s->s_mdsc;
5113 mutex_lock(&mdsc->mutex);
5114 if (__verify_registered_session(mdsc, s) < 0) {
5115 mutex_unlock(&mdsc->mutex);
5118 mutex_unlock(&mdsc->mutex);
5122 ceph_mdsc_handle_mdsmap(mdsc, msg);
5125 ceph_mdsc_handle_fsmap(mdsc, msg);
5134 handle_forward(mdsc, s, msg);
5140 ceph_handle_snap(mdsc, s, msg);
5143 handle_lease(mdsc, s, msg);
5146 ceph_handle_quota(mdsc, s, msg);
5169 struct ceph_mds_client *mdsc = s->s_mdsc;
5170 struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
5197 struct ceph_mds_client *mdsc = s->s_mdsc;
5198 struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
5207 struct ceph_mds_client *mdsc = s->s_mdsc;
5208 struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
5216 struct ceph_mds_client *mdsc = s->s_mdsc;
5217 struct ceph_auth_client *ac = mdsc->fsc->client->monc.auth;
5221 return ceph_monc_validate_auth(&mdsc->fsc->client->monc);