Lines Matching defs:monc
33 static int __validate_auth(struct ceph_mon_client *monc);
102 static void __send_prepared_auth_request(struct ceph_mon_client *monc, int len)
104 monc->pending_auth = 1;
105 monc->m_auth->front.iov_len = len;
106 monc->m_auth->hdr.front_len = cpu_to_le32(len);
107 ceph_con_revoke(monc->con, monc->m_auth);
108 ceph_msg_get(monc->m_auth); /* keep our ref */
109 ceph_con_send(monc->con, monc->m_auth);
115 static void __close_session(struct ceph_mon_client *monc)
117 if (monc->con) {
118 dout("__close_session closing mon%d\n", monc->cur_mon);
119 ceph_con_revoke(monc->con, monc->m_auth);
120 ceph_con_close(monc->con);
121 monc->cur_mon = -1;
122 monc->pending_auth = 0;
123 ceph_auth_reset(monc->auth);
130 static int __open_session(struct ceph_mon_client *monc)
135 if (monc->cur_mon < 0) {
137 monc->cur_mon = r % monc->monmap->num_mon;
139 monc->monmap->num_mon, r, monc->cur_mon);
140 monc->sub_sent = 0;
141 monc->sub_renew_after = jiffies; /* i.e., expired */
142 monc->want_next_osdmap = !!monc->want_next_osdmap;
144 dout("open_session mon%d opening\n", monc->cur_mon);
145 monc->con->peer_name.type = CEPH_ENTITY_TYPE_MON;
146 monc->con->peer_name.num = cpu_to_le64(monc->cur_mon);
147 ceph_con_open(monc->con,
148 &monc->monmap->mon_inst[monc->cur_mon].addr);
151 ret = ceph_auth_build_hello(monc->auth,
152 monc->m_auth->front.iov_base,
153 monc->m_auth->front_max);
154 __send_prepared_auth_request(monc, ret);
156 dout("open_session mon%d already open\n", monc->cur_mon);
161 static bool __sub_expired(struct ceph_mon_client *monc)
163 return time_after_eq(jiffies, monc->sub_renew_after);
169 static void __schedule_delayed(struct ceph_mon_client *monc)
173 if (monc->cur_mon < 0 || __sub_expired(monc))
178 schedule_delayed_work(&monc->delayed_work, delay);
184 static void __send_subscribe(struct ceph_mon_client *monc)
187 (unsigned)monc->sub_sent, __sub_expired(monc),
188 monc->want_next_osdmap);
189 if ((__sub_expired(monc) && !monc->sub_sent) ||
190 monc->want_next_osdmap == 1) {
191 struct ceph_msg *msg = monc->m_subscribe;
199 (unsigned)monc->have_mdsmap);
200 if (monc->want_next_osdmap) {
202 (unsigned)monc->have_osdmap);
206 i->have = cpu_to_le64(monc->have_osdmap);
209 monc->want_next_osdmap = 2; /* requested */
215 i->have = cpu_to_le64(monc->have_mdsmap);
226 ceph_con_revoke(monc->con, msg);
227 ceph_con_send(monc->con, ceph_msg_get(msg));
229 monc->sub_sent = jiffies | 1; /* never 0 */
233 static void handle_subscribe_ack(struct ceph_mon_client *monc,
243 mutex_lock(&monc->mutex);
244 if (monc->hunting) {
246 monc->cur_mon, pr_addr(&monc->con->peer_addr.in_addr));
247 monc->hunting = false;
250 monc->sub_renew_after = monc->sub_sent + (seconds >> 1)*HZ - 1;
251 monc->sub_sent = 0;
252 mutex_unlock(&monc->mutex);
262 int ceph_monc_got_mdsmap(struct ceph_mon_client *monc, u32 got)
264 mutex_lock(&monc->mutex);
265 monc->have_mdsmap = got;
266 mutex_unlock(&monc->mutex);
270 int ceph_monc_got_osdmap(struct ceph_mon_client *monc, u32 got)
272 mutex_lock(&monc->mutex);
273 monc->have_osdmap = got;
274 monc->want_next_osdmap = 0;
275 mutex_unlock(&monc->mutex);
282 void ceph_monc_request_next_osdmap(struct ceph_mon_client *monc)
284 dout("request_next_osdmap have %u\n", monc->have_osdmap);
285 mutex_lock(&monc->mutex);
286 if (!monc->want_next_osdmap)
287 monc->want_next_osdmap = 1;
288 if (monc->want_next_osdmap < 2)
289 __send_subscribe(monc);
290 mutex_unlock(&monc->mutex);
296 int ceph_monc_open_session(struct ceph_mon_client *monc)
298 if (!monc->con) {
299 monc->con = kmalloc(sizeof(*monc->con), GFP_KERNEL);
300 if (!monc->con)
302 ceph_con_init(monc->client->msgr, monc->con);
303 monc->con->private = monc;
304 monc->con->ops = &mon_con_ops;
307 mutex_lock(&monc->mutex);
308 __open_session(monc);
309 __schedule_delayed(monc);
310 mutex_unlock(&monc->mutex);
318 static void ceph_monc_handle_map(struct ceph_mon_client *monc,
321 struct ceph_client *client = monc->client;
322 struct ceph_monmap *monmap = NULL, *old = monc->monmap;
325 mutex_lock(&monc->mutex);
338 if (ceph_check_fsid(monc->client, &monmap->fsid) < 0) {
343 client->monc.monmap = monmap;
347 mutex_unlock(&monc->mutex);
355 struct ceph_mon_client *monc, u64 tid)
358 struct rb_node *n = monc->generic_request_tree.rb_node;
372 static void __insert_generic_request(struct ceph_mon_client *monc,
375 struct rb_node **p = &monc->generic_request_tree.rb_node;
391 rb_insert_color(&new->node, &monc->generic_request_tree);
421 struct ceph_mon_client *monc = con->private;
426 mutex_lock(&monc->mutex);
427 req = __lookup_generic_req(monc, tid);
441 mutex_unlock(&monc->mutex);
445 static int do_generic_request(struct ceph_mon_client *monc,
451 mutex_lock(&monc->mutex);
452 req->tid = ++monc->last_tid;
454 __insert_generic_request(monc, req);
455 monc->num_generic_requests++;
456 ceph_con_send(monc->con, ceph_msg_get(req->request));
457 mutex_unlock(&monc->mutex);
461 mutex_lock(&monc->mutex);
462 rb_erase(&req->node, &monc->generic_request_tree);
463 monc->num_generic_requests--;
464 mutex_unlock(&monc->mutex);
474 static void handle_statfs_reply(struct ceph_mon_client *monc,
485 mutex_lock(&monc->mutex);
486 req = __lookup_generic_req(monc, tid);
492 mutex_unlock(&monc->mutex);
507 int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
535 h->fsid = monc->monmap->fsid;
537 err = do_generic_request(monc, req);
563 static void handle_poolop_reply(struct ceph_mon_client *monc,
574 mutex_lock(&monc->mutex);
575 req = __lookup_generic_req(monc, tid);
581 mutex_unlock(&monc->mutex);
587 mutex_unlock(&monc->mutex);
602 int ceph_monc_do_poolop(struct ceph_mon_client *monc, u32 op,
633 h->fsid = monc->monmap->fsid;
640 err = do_generic_request(monc, req);
647 int ceph_monc_create_snapid(struct ceph_mon_client *monc,
650 return ceph_monc_do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP,
655 int ceph_monc_delete_snapid(struct ceph_mon_client *monc,
658 return ceph_monc_do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP,
666 static void __resend_generic_request(struct ceph_mon_client *monc)
671 for (p = rb_first(&monc->generic_request_tree); p; p = rb_next(p)) {
673 ceph_con_revoke(monc->con, req->request);
674 ceph_con_send(monc->con, ceph_msg_get(req->request));
685 struct ceph_mon_client *monc =
688 dout("monc delayed_work\n");
689 mutex_lock(&monc->mutex);
690 if (monc->hunting) {
691 __close_session(monc);
692 __open_session(monc); /* continue hunting */
694 ceph_con_keepalive(monc->con);
696 __validate_auth(monc);
698 if (monc->auth->ops->is_authenticated(monc->auth))
699 __send_subscribe(monc);
701 __schedule_delayed(monc);
702 mutex_unlock(&monc->mutex);
709 static int build_initial_monmap(struct ceph_mon_client *monc)
711 struct ceph_mount_args *args = monc->client->mount_args;
717 monc->monmap = kzalloc(sizeof(*monc->monmap) +
718 num_mon*sizeof(monc->monmap->mon_inst[0]),
720 if (!monc->monmap)
723 monc->monmap->mon_inst[i].addr = mon_addr[i];
724 monc->monmap->mon_inst[i].addr.nonce = 0;
725 monc->monmap->mon_inst[i].name.type =
727 monc->monmap->mon_inst[i].name.num = cpu_to_le64(i);
729 monc->monmap->num_mon = num_mon;
730 monc->have_fsid = false;
739 int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl)
744 memset(monc, 0, sizeof(*monc));
745 monc->client = cl;
746 monc->monmap = NULL;
747 mutex_init(&monc->mutex);
749 err = build_initial_monmap(monc);
753 monc->con = NULL;
756 monc->auth = ceph_auth_init(cl->mount_args->name,
758 if (IS_ERR(monc->auth))
759 return PTR_ERR(monc->auth);
760 monc->auth->want_keys =
766 monc->m_subscribe_ack = ceph_msg_new(CEPH_MSG_MON_SUBSCRIBE_ACK,
769 if (!monc->m_subscribe_ack)
772 monc->m_subscribe = ceph_msg_new(CEPH_MSG_MON_SUBSCRIBE, 96, GFP_NOFS);
773 if (!monc->m_subscribe)
776 monc->m_auth_reply = ceph_msg_new(CEPH_MSG_AUTH_REPLY, 4096, GFP_NOFS);
777 if (!monc->m_auth_reply)
780 monc->m_auth = ceph_msg_new(CEPH_MSG_AUTH, 4096, GFP_NOFS);
781 monc->pending_auth = 0;
782 if (!monc->m_auth)
785 monc->cur_mon = -1;
786 monc->hunting = true;
787 monc->sub_renew_after = jiffies;
788 monc->sub_sent = 0;
790 INIT_DELAYED_WORK(&monc->delayed_work, delayed_work);
791 monc->generic_request_tree = RB_ROOT;
792 monc->num_generic_requests = 0;
793 monc->last_tid = 0;
795 monc->have_mdsmap = 0;
796 monc->have_osdmap = 0;
797 monc->want_next_osdmap = 1;
801 ceph_msg_put(monc->m_auth_reply);
803 ceph_msg_put(monc->m_subscribe);
805 ceph_msg_put(monc->m_subscribe_ack);
807 kfree(monc->monmap);
812 void ceph_monc_stop(struct ceph_mon_client *monc)
815 cancel_delayed_work_sync(&monc->delayed_work);
817 mutex_lock(&monc->mutex);
818 __close_session(monc);
819 if (monc->con) {
820 monc->con->private = NULL;
821 monc->con->ops->put(monc->con);
822 monc->con = NULL;
824 mutex_unlock(&monc->mutex);
826 ceph_auth_destroy(monc->auth);
828 ceph_msg_put(monc->m_auth);
829 ceph_msg_put(monc->m_auth_reply);
830 ceph_msg_put(monc->m_subscribe);
831 ceph_msg_put(monc->m_subscribe_ack);
833 kfree(monc->monmap);
836 static void handle_auth_reply(struct ceph_mon_client *monc,
842 mutex_lock(&monc->mutex);
843 if (monc->auth->ops)
844 was_auth = monc->auth->ops->is_authenticated(monc->auth);
845 monc->pending_auth = 0;
846 ret = ceph_handle_auth_reply(monc->auth, msg->front.iov_base,
848 monc->m_auth->front.iov_base,
849 monc->m_auth->front_max);
851 monc->client->auth_err = ret;
852 wake_up_all(&monc->client->auth_wq);
854 __send_prepared_auth_request(monc, ret);
855 } else if (!was_auth && monc->auth->ops->is_authenticated(monc->auth)) {
858 monc->client->msgr->inst.name.type = CEPH_ENTITY_TYPE_CLIENT;
859 monc->client->msgr->inst.name.num =
860 cpu_to_le64(monc->auth->global_id);
862 __send_subscribe(monc);
863 __resend_generic_request(monc);
865 mutex_unlock(&monc->mutex);
868 static int __validate_auth(struct ceph_mon_client *monc)
872 if (monc->pending_auth)
875 ret = ceph_build_auth(monc->auth, monc->m_auth->front.iov_base,
876 monc->m_auth->front_max);
879 __send_prepared_auth_request(monc, ret);
883 int ceph_monc_validate_auth(struct ceph_mon_client *monc)
887 mutex_lock(&monc->mutex);
888 ret = __validate_auth(monc);
889 mutex_unlock(&monc->mutex);
898 struct ceph_mon_client *monc = con->private;
901 if (!monc)
906 handle_auth_reply(monc, msg);
910 handle_subscribe_ack(monc, msg);
914 handle_statfs_reply(monc, msg);
918 handle_poolop_reply(monc, msg);
922 ceph_monc_handle_map(monc, msg);
926 ceph_mdsc_handle_map(&monc->client->mdsc, msg);
930 ceph_osdc_handle_map(&monc->client->osdc, msg);
947 struct ceph_mon_client *monc = con->private;
956 m = ceph_msg_get(monc->m_subscribe_ack);
962 m = ceph_msg_get(monc->m_auth_reply);
984 struct ceph_mon_client *monc = con->private;
986 if (!monc)
990 mutex_lock(&monc->mutex);
994 if (monc->con && !monc->hunting)
996 "hunting for new mon\n", monc->cur_mon,
997 pr_addr(&monc->con->peer_addr.in_addr));
999 __close_session(monc);
1000 if (!monc->hunting) {
1002 monc->hunting = true;
1003 __open_session(monc);
1006 __schedule_delayed(monc);
1009 mutex_unlock(&monc->mutex);