Merge tag 'ceph-for-4.17-rc1' of git://github.com/ceph/ceph-client
[sfrench/cifs-2.6.git] / net / ceph / ceph_common.c
1
2 #include <linux/ceph/ceph_debug.h>
3 #include <linux/backing-dev.h>
4 #include <linux/ctype.h>
5 #include <linux/fs.h>
6 #include <linux/inet.h>
7 #include <linux/in6.h>
8 #include <linux/key.h>
9 #include <keys/ceph-type.h>
10 #include <linux/module.h>
11 #include <linux/mount.h>
12 #include <linux/nsproxy.h>
13 #include <linux/parser.h>
14 #include <linux/sched.h>
15 #include <linux/seq_file.h>
16 #include <linux/slab.h>
17 #include <linux/statfs.h>
18 #include <linux/string.h>
19 #include <linux/vmalloc.h>
20
21
22 #include <linux/ceph/ceph_features.h>
23 #include <linux/ceph/libceph.h>
24 #include <linux/ceph/debugfs.h>
25 #include <linux/ceph/decode.h>
26 #include <linux/ceph/mon_client.h>
27 #include <linux/ceph/auth.h>
28 #include "crypto.h"
29
30
31 /*
32  * Module compatibility interface.  For now it doesn't do anything,
33  * but its existence signals a certain level of functionality.
34  *
35  * The data buffer is used to pass information both to and from
36  * libceph.  The return value indicates whether libceph determines
37  * it is compatible with the caller (from another kernel module),
38  * given the provided data.
39  *
40  * The data pointer can be null.
41  */
42 bool libceph_compatible(void *data)
43 {
44         return true;
45 }
46 EXPORT_SYMBOL(libceph_compatible);
47
48 static int param_get_supported_features(char *buffer,
49                                         const struct kernel_param *kp)
50 {
51         return sprintf(buffer, "0x%llx", CEPH_FEATURES_SUPPORTED_DEFAULT);
52 }
53 static const struct kernel_param_ops param_ops_supported_features = {
54         .get = param_get_supported_features,
55 };
56 module_param_cb(supported_features, &param_ops_supported_features, NULL,
57                 0444);
58
59 const char *ceph_msg_type_name(int type)
60 {
61         switch (type) {
62         case CEPH_MSG_SHUTDOWN: return "shutdown";
63         case CEPH_MSG_PING: return "ping";
64         case CEPH_MSG_AUTH: return "auth";
65         case CEPH_MSG_AUTH_REPLY: return "auth_reply";
66         case CEPH_MSG_MON_MAP: return "mon_map";
67         case CEPH_MSG_MON_GET_MAP: return "mon_get_map";
68         case CEPH_MSG_MON_SUBSCRIBE: return "mon_subscribe";
69         case CEPH_MSG_MON_SUBSCRIBE_ACK: return "mon_subscribe_ack";
70         case CEPH_MSG_STATFS: return "statfs";
71         case CEPH_MSG_STATFS_REPLY: return "statfs_reply";
72         case CEPH_MSG_MON_GET_VERSION: return "mon_get_version";
73         case CEPH_MSG_MON_GET_VERSION_REPLY: return "mon_get_version_reply";
74         case CEPH_MSG_MDS_MAP: return "mds_map";
75         case CEPH_MSG_FS_MAP_USER: return "fs_map_user";
76         case CEPH_MSG_CLIENT_SESSION: return "client_session";
77         case CEPH_MSG_CLIENT_RECONNECT: return "client_reconnect";
78         case CEPH_MSG_CLIENT_REQUEST: return "client_request";
79         case CEPH_MSG_CLIENT_REQUEST_FORWARD: return "client_request_forward";
80         case CEPH_MSG_CLIENT_REPLY: return "client_reply";
81         case CEPH_MSG_CLIENT_CAPS: return "client_caps";
82         case CEPH_MSG_CLIENT_CAPRELEASE: return "client_cap_release";
83         case CEPH_MSG_CLIENT_QUOTA: return "client_quota";
84         case CEPH_MSG_CLIENT_SNAP: return "client_snap";
85         case CEPH_MSG_CLIENT_LEASE: return "client_lease";
86         case CEPH_MSG_POOLOP_REPLY: return "poolop_reply";
87         case CEPH_MSG_POOLOP: return "poolop";
88         case CEPH_MSG_MON_COMMAND: return "mon_command";
89         case CEPH_MSG_MON_COMMAND_ACK: return "mon_command_ack";
90         case CEPH_MSG_OSD_MAP: return "osd_map";
91         case CEPH_MSG_OSD_OP: return "osd_op";
92         case CEPH_MSG_OSD_OPREPLY: return "osd_opreply";
93         case CEPH_MSG_WATCH_NOTIFY: return "watch_notify";
94         case CEPH_MSG_OSD_BACKOFF: return "osd_backoff";
95         default: return "unknown";
96         }
97 }
98 EXPORT_SYMBOL(ceph_msg_type_name);
99
100 /*
101  * Initially learn our fsid, or verify an fsid matches.
102  */
103 int ceph_check_fsid(struct ceph_client *client, struct ceph_fsid *fsid)
104 {
105         if (client->have_fsid) {
106                 if (ceph_fsid_compare(&client->fsid, fsid)) {
107                         pr_err("bad fsid, had %pU got %pU",
108                                &client->fsid, fsid);
109                         return -1;
110                 }
111         } else {
112                 memcpy(&client->fsid, fsid, sizeof(*fsid));
113         }
114         return 0;
115 }
116 EXPORT_SYMBOL(ceph_check_fsid);
117
118 static int strcmp_null(const char *s1, const char *s2)
119 {
120         if (!s1 && !s2)
121                 return 0;
122         if (s1 && !s2)
123                 return -1;
124         if (!s1 && s2)
125                 return 1;
126         return strcmp(s1, s2);
127 }
128
129 int ceph_compare_options(struct ceph_options *new_opt,
130                          struct ceph_client *client)
131 {
132         struct ceph_options *opt1 = new_opt;
133         struct ceph_options *opt2 = client->options;
134         int ofs = offsetof(struct ceph_options, mon_addr);
135         int i;
136         int ret;
137
138         /*
139          * Don't bother comparing options if network namespaces don't
140          * match.
141          */
142         if (!net_eq(current->nsproxy->net_ns, read_pnet(&client->msgr.net)))
143                 return -1;
144
145         ret = memcmp(opt1, opt2, ofs);
146         if (ret)
147                 return ret;
148
149         ret = strcmp_null(opt1->name, opt2->name);
150         if (ret)
151                 return ret;
152
153         if (opt1->key && !opt2->key)
154                 return -1;
155         if (!opt1->key && opt2->key)
156                 return 1;
157         if (opt1->key && opt2->key) {
158                 if (opt1->key->type != opt2->key->type)
159                         return -1;
160                 if (opt1->key->created.tv_sec != opt2->key->created.tv_sec)
161                         return -1;
162                 if (opt1->key->created.tv_nsec != opt2->key->created.tv_nsec)
163                         return -1;
164                 if (opt1->key->len != opt2->key->len)
165                         return -1;
166                 if (opt1->key->key && !opt2->key->key)
167                         return -1;
168                 if (!opt1->key->key && opt2->key->key)
169                         return 1;
170                 if (opt1->key->key && opt2->key->key) {
171                         ret = memcmp(opt1->key->key, opt2->key->key, opt1->key->len);
172                         if (ret)
173                                 return ret;
174                 }
175         }
176
177         /* any matching mon ip implies a match */
178         for (i = 0; i < opt1->num_mon; i++) {
179                 if (ceph_monmap_contains(client->monc.monmap,
180                                  &opt1->mon_addr[i]))
181                         return 0;
182         }
183         return -1;
184 }
185 EXPORT_SYMBOL(ceph_compare_options);
186
187 void *ceph_kvmalloc(size_t size, gfp_t flags)
188 {
189         if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
190                 void *ptr = kmalloc(size, flags | __GFP_NOWARN);
191                 if (ptr)
192                         return ptr;
193         }
194
195         return __vmalloc(size, flags, PAGE_KERNEL);
196 }
197
198
199 static int parse_fsid(const char *str, struct ceph_fsid *fsid)
200 {
201         int i = 0;
202         char tmp[3];
203         int err = -EINVAL;
204         int d;
205
206         dout("parse_fsid '%s'\n", str);
207         tmp[2] = 0;
208         while (*str && i < 16) {
209                 if (ispunct(*str)) {
210                         str++;
211                         continue;
212                 }
213                 if (!isxdigit(str[0]) || !isxdigit(str[1]))
214                         break;
215                 tmp[0] = str[0];
216                 tmp[1] = str[1];
217                 if (sscanf(tmp, "%x", &d) < 1)
218                         break;
219                 fsid->fsid[i] = d & 0xff;
220                 i++;
221                 str += 2;
222         }
223
224         if (i == 16)
225                 err = 0;
226         dout("parse_fsid ret %d got fsid %pU\n", err, fsid);
227         return err;
228 }
229
230 /*
231  * ceph options
232  */
233 enum {
234         Opt_osdtimeout,
235         Opt_osdkeepalivetimeout,
236         Opt_mount_timeout,
237         Opt_osd_idle_ttl,
238         Opt_osd_request_timeout,
239         Opt_last_int,
240         /* int args above */
241         Opt_fsid,
242         Opt_name,
243         Opt_secret,
244         Opt_key,
245         Opt_ip,
246         Opt_last_string,
247         /* string args above */
248         Opt_share,
249         Opt_noshare,
250         Opt_crc,
251         Opt_nocrc,
252         Opt_cephx_require_signatures,
253         Opt_nocephx_require_signatures,
254         Opt_cephx_sign_messages,
255         Opt_nocephx_sign_messages,
256         Opt_tcp_nodelay,
257         Opt_notcp_nodelay,
258 };
259
260 static match_table_t opt_tokens = {
261         {Opt_osdtimeout, "osdtimeout=%d"},
262         {Opt_osdkeepalivetimeout, "osdkeepalive=%d"},
263         {Opt_mount_timeout, "mount_timeout=%d"},
264         {Opt_osd_idle_ttl, "osd_idle_ttl=%d"},
265         {Opt_osd_request_timeout, "osd_request_timeout=%d"},
266         /* int args above */
267         {Opt_fsid, "fsid=%s"},
268         {Opt_name, "name=%s"},
269         {Opt_secret, "secret=%s"},
270         {Opt_key, "key=%s"},
271         {Opt_ip, "ip=%s"},
272         /* string args above */
273         {Opt_share, "share"},
274         {Opt_noshare, "noshare"},
275         {Opt_crc, "crc"},
276         {Opt_nocrc, "nocrc"},
277         {Opt_cephx_require_signatures, "cephx_require_signatures"},
278         {Opt_nocephx_require_signatures, "nocephx_require_signatures"},
279         {Opt_cephx_sign_messages, "cephx_sign_messages"},
280         {Opt_nocephx_sign_messages, "nocephx_sign_messages"},
281         {Opt_tcp_nodelay, "tcp_nodelay"},
282         {Opt_notcp_nodelay, "notcp_nodelay"},
283         {-1, NULL}
284 };
285
286 void ceph_destroy_options(struct ceph_options *opt)
287 {
288         dout("destroy_options %p\n", opt);
289         kfree(opt->name);
290         if (opt->key) {
291                 ceph_crypto_key_destroy(opt->key);
292                 kfree(opt->key);
293         }
294         kfree(opt->mon_addr);
295         kfree(opt);
296 }
297 EXPORT_SYMBOL(ceph_destroy_options);
298
299 /* get secret from key store */
300 static int get_secret(struct ceph_crypto_key *dst, const char *name) {
301         struct key *ukey;
302         int key_err;
303         int err = 0;
304         struct ceph_crypto_key *ckey;
305
306         ukey = request_key(&key_type_ceph, name, NULL);
307         if (!ukey || IS_ERR(ukey)) {
308                 /* request_key errors don't map nicely to mount(2)
309                    errors; don't even try, but still printk */
310                 key_err = PTR_ERR(ukey);
311                 switch (key_err) {
312                 case -ENOKEY:
313                         pr_warn("ceph: Mount failed due to key not found: %s\n",
314                                 name);
315                         break;
316                 case -EKEYEXPIRED:
317                         pr_warn("ceph: Mount failed due to expired key: %s\n",
318                                 name);
319                         break;
320                 case -EKEYREVOKED:
321                         pr_warn("ceph: Mount failed due to revoked key: %s\n",
322                                 name);
323                         break;
324                 default:
325                         pr_warn("ceph: Mount failed due to unknown key error %d: %s\n",
326                                 key_err, name);
327                 }
328                 err = -EPERM;
329                 goto out;
330         }
331
332         ckey = ukey->payload.data[0];
333         err = ceph_crypto_key_clone(dst, ckey);
334         if (err)
335                 goto out_key;
336         /* pass through, err is 0 */
337
338 out_key:
339         key_put(ukey);
340 out:
341         return err;
342 }
343
344 struct ceph_options *
345 ceph_parse_options(char *options, const char *dev_name,
346                         const char *dev_name_end,
347                         int (*parse_extra_token)(char *c, void *private),
348                         void *private)
349 {
350         struct ceph_options *opt;
351         const char *c;
352         int err = -ENOMEM;
353         substring_t argstr[MAX_OPT_ARGS];
354
355         opt = kzalloc(sizeof(*opt), GFP_KERNEL);
356         if (!opt)
357                 return ERR_PTR(-ENOMEM);
358         opt->mon_addr = kcalloc(CEPH_MAX_MON, sizeof(*opt->mon_addr),
359                                 GFP_KERNEL);
360         if (!opt->mon_addr)
361                 goto out;
362
363         dout("parse_options %p options '%s' dev_name '%s'\n", opt, options,
364              dev_name);
365
366         /* start with defaults */
367         opt->flags = CEPH_OPT_DEFAULT;
368         opt->osd_keepalive_timeout = CEPH_OSD_KEEPALIVE_DEFAULT;
369         opt->mount_timeout = CEPH_MOUNT_TIMEOUT_DEFAULT;
370         opt->osd_idle_ttl = CEPH_OSD_IDLE_TTL_DEFAULT;
371         opt->osd_request_timeout = CEPH_OSD_REQUEST_TIMEOUT_DEFAULT;
372
373         /* get mon ip(s) */
374         /* ip1[:port1][,ip2[:port2]...] */
375         err = ceph_parse_ips(dev_name, dev_name_end, opt->mon_addr,
376                              CEPH_MAX_MON, &opt->num_mon);
377         if (err < 0)
378                 goto out;
379
380         /* parse mount options */
381         while ((c = strsep(&options, ",")) != NULL) {
382                 int token, intval, ret;
383                 if (!*c)
384                         continue;
385                 err = -EINVAL;
386                 token = match_token((char *)c, opt_tokens, argstr);
387                 if (token < 0 && parse_extra_token) {
388                         /* extra? */
389                         err = parse_extra_token((char *)c, private);
390                         if (err < 0) {
391                                 pr_err("bad option at '%s'\n", c);
392                                 goto out;
393                         }
394                         continue;
395                 }
396                 if (token < Opt_last_int) {
397                         ret = match_int(&argstr[0], &intval);
398                         if (ret < 0) {
399                                 pr_err("bad mount option arg (not int) "
400                                        "at '%s'\n", c);
401                                 continue;
402                         }
403                         dout("got int token %d val %d\n", token, intval);
404                 } else if (token > Opt_last_int && token < Opt_last_string) {
405                         dout("got string token %d val %s\n", token,
406                              argstr[0].from);
407                 } else {
408                         dout("got token %d\n", token);
409                 }
410                 switch (token) {
411                 case Opt_ip:
412                         err = ceph_parse_ips(argstr[0].from,
413                                              argstr[0].to,
414                                              &opt->my_addr,
415                                              1, NULL);
416                         if (err < 0)
417                                 goto out;
418                         opt->flags |= CEPH_OPT_MYIP;
419                         break;
420
421                 case Opt_fsid:
422                         err = parse_fsid(argstr[0].from, &opt->fsid);
423                         if (err == 0)
424                                 opt->flags |= CEPH_OPT_FSID;
425                         break;
426                 case Opt_name:
427                         kfree(opt->name);
428                         opt->name = kstrndup(argstr[0].from,
429                                               argstr[0].to-argstr[0].from,
430                                               GFP_KERNEL);
431                         if (!opt->name) {
432                                 err = -ENOMEM;
433                                 goto out;
434                         }
435                         break;
436                 case Opt_secret:
437                         ceph_crypto_key_destroy(opt->key);
438                         kfree(opt->key);
439
440                         opt->key = kzalloc(sizeof(*opt->key), GFP_KERNEL);
441                         if (!opt->key) {
442                                 err = -ENOMEM;
443                                 goto out;
444                         }
445                         err = ceph_crypto_key_unarmor(opt->key, argstr[0].from);
446                         if (err < 0)
447                                 goto out;
448                         break;
449                 case Opt_key:
450                         ceph_crypto_key_destroy(opt->key);
451                         kfree(opt->key);
452
453                         opt->key = kzalloc(sizeof(*opt->key), GFP_KERNEL);
454                         if (!opt->key) {
455                                 err = -ENOMEM;
456                                 goto out;
457                         }
458                         err = get_secret(opt->key, argstr[0].from);
459                         if (err < 0)
460                                 goto out;
461                         break;
462
463                         /* misc */
464                 case Opt_osdtimeout:
465                         pr_warn("ignoring deprecated osdtimeout option\n");
466                         break;
467                 case Opt_osdkeepalivetimeout:
468                         /* 0 isn't well defined right now, reject it */
469                         if (intval < 1 || intval > INT_MAX / 1000) {
470                                 pr_err("osdkeepalive out of range\n");
471                                 err = -EINVAL;
472                                 goto out;
473                         }
474                         opt->osd_keepalive_timeout =
475                                         msecs_to_jiffies(intval * 1000);
476                         break;
477                 case Opt_osd_idle_ttl:
478                         /* 0 isn't well defined right now, reject it */
479                         if (intval < 1 || intval > INT_MAX / 1000) {
480                                 pr_err("osd_idle_ttl out of range\n");
481                                 err = -EINVAL;
482                                 goto out;
483                         }
484                         opt->osd_idle_ttl = msecs_to_jiffies(intval * 1000);
485                         break;
486                 case Opt_mount_timeout:
487                         /* 0 is "wait forever" (i.e. infinite timeout) */
488                         if (intval < 0 || intval > INT_MAX / 1000) {
489                                 pr_err("mount_timeout out of range\n");
490                                 err = -EINVAL;
491                                 goto out;
492                         }
493                         opt->mount_timeout = msecs_to_jiffies(intval * 1000);
494                         break;
495                 case Opt_osd_request_timeout:
496                         /* 0 is "wait forever" (i.e. infinite timeout) */
497                         if (intval < 0 || intval > INT_MAX / 1000) {
498                                 pr_err("osd_request_timeout out of range\n");
499                                 err = -EINVAL;
500                                 goto out;
501                         }
502                         opt->osd_request_timeout = msecs_to_jiffies(intval * 1000);
503                         break;
504
505                 case Opt_share:
506                         opt->flags &= ~CEPH_OPT_NOSHARE;
507                         break;
508                 case Opt_noshare:
509                         opt->flags |= CEPH_OPT_NOSHARE;
510                         break;
511
512                 case Opt_crc:
513                         opt->flags &= ~CEPH_OPT_NOCRC;
514                         break;
515                 case Opt_nocrc:
516                         opt->flags |= CEPH_OPT_NOCRC;
517                         break;
518
519                 case Opt_cephx_require_signatures:
520                         opt->flags &= ~CEPH_OPT_NOMSGAUTH;
521                         break;
522                 case Opt_nocephx_require_signatures:
523                         opt->flags |= CEPH_OPT_NOMSGAUTH;
524                         break;
525                 case Opt_cephx_sign_messages:
526                         opt->flags &= ~CEPH_OPT_NOMSGSIGN;
527                         break;
528                 case Opt_nocephx_sign_messages:
529                         opt->flags |= CEPH_OPT_NOMSGSIGN;
530                         break;
531
532                 case Opt_tcp_nodelay:
533                         opt->flags |= CEPH_OPT_TCP_NODELAY;
534                         break;
535                 case Opt_notcp_nodelay:
536                         opt->flags &= ~CEPH_OPT_TCP_NODELAY;
537                         break;
538
539                 default:
540                         BUG_ON(token);
541                 }
542         }
543
544         /* success */
545         return opt;
546
547 out:
548         ceph_destroy_options(opt);
549         return ERR_PTR(err);
550 }
551 EXPORT_SYMBOL(ceph_parse_options);
552
553 int ceph_print_client_options(struct seq_file *m, struct ceph_client *client)
554 {
555         struct ceph_options *opt = client->options;
556         size_t pos = m->count;
557
558         if (opt->name) {
559                 seq_puts(m, "name=");
560                 seq_escape(m, opt->name, ", \t\n\\");
561                 seq_putc(m, ',');
562         }
563         if (opt->key)
564                 seq_puts(m, "secret=<hidden>,");
565
566         if (opt->flags & CEPH_OPT_FSID)
567                 seq_printf(m, "fsid=%pU,", &opt->fsid);
568         if (opt->flags & CEPH_OPT_NOSHARE)
569                 seq_puts(m, "noshare,");
570         if (opt->flags & CEPH_OPT_NOCRC)
571                 seq_puts(m, "nocrc,");
572         if (opt->flags & CEPH_OPT_NOMSGAUTH)
573                 seq_puts(m, "nocephx_require_signatures,");
574         if (opt->flags & CEPH_OPT_NOMSGSIGN)
575                 seq_puts(m, "nocephx_sign_messages,");
576         if ((opt->flags & CEPH_OPT_TCP_NODELAY) == 0)
577                 seq_puts(m, "notcp_nodelay,");
578
579         if (opt->mount_timeout != CEPH_MOUNT_TIMEOUT_DEFAULT)
580                 seq_printf(m, "mount_timeout=%d,",
581                            jiffies_to_msecs(opt->mount_timeout) / 1000);
582         if (opt->osd_idle_ttl != CEPH_OSD_IDLE_TTL_DEFAULT)
583                 seq_printf(m, "osd_idle_ttl=%d,",
584                            jiffies_to_msecs(opt->osd_idle_ttl) / 1000);
585         if (opt->osd_keepalive_timeout != CEPH_OSD_KEEPALIVE_DEFAULT)
586                 seq_printf(m, "osdkeepalivetimeout=%d,",
587                     jiffies_to_msecs(opt->osd_keepalive_timeout) / 1000);
588         if (opt->osd_request_timeout != CEPH_OSD_REQUEST_TIMEOUT_DEFAULT)
589                 seq_printf(m, "osd_request_timeout=%d,",
590                            jiffies_to_msecs(opt->osd_request_timeout) / 1000);
591
592         /* drop redundant comma */
593         if (m->count != pos)
594                 m->count--;
595
596         return 0;
597 }
598 EXPORT_SYMBOL(ceph_print_client_options);
599
600 struct ceph_entity_addr *ceph_client_addr(struct ceph_client *client)
601 {
602         return &client->msgr.inst.addr;
603 }
604 EXPORT_SYMBOL(ceph_client_addr);
605
606 u64 ceph_client_gid(struct ceph_client *client)
607 {
608         return client->monc.auth->global_id;
609 }
610 EXPORT_SYMBOL(ceph_client_gid);
611
612 /*
613  * create a fresh client instance
614  */
615 struct ceph_client *ceph_create_client(struct ceph_options *opt, void *private)
616 {
617         struct ceph_client *client;
618         struct ceph_entity_addr *myaddr = NULL;
619         int err;
620
621         err = wait_for_random_bytes();
622         if (err < 0)
623                 return ERR_PTR(err);
624
625         client = kzalloc(sizeof(*client), GFP_KERNEL);
626         if (client == NULL)
627                 return ERR_PTR(-ENOMEM);
628
629         client->private = private;
630         client->options = opt;
631
632         mutex_init(&client->mount_mutex);
633         init_waitqueue_head(&client->auth_wq);
634         client->auth_err = 0;
635
636         client->extra_mon_dispatch = NULL;
637         client->supported_features = CEPH_FEATURES_SUPPORTED_DEFAULT;
638         client->required_features = CEPH_FEATURES_REQUIRED_DEFAULT;
639
640         if (!ceph_test_opt(client, NOMSGAUTH))
641                 client->required_features |= CEPH_FEATURE_MSG_AUTH;
642
643         /* msgr */
644         if (ceph_test_opt(client, MYIP))
645                 myaddr = &client->options->my_addr;
646
647         ceph_messenger_init(&client->msgr, myaddr);
648
649         /* subsystems */
650         err = ceph_monc_init(&client->monc, client);
651         if (err < 0)
652                 goto fail;
653         err = ceph_osdc_init(&client->osdc, client);
654         if (err < 0)
655                 goto fail_monc;
656
657         return client;
658
659 fail_monc:
660         ceph_monc_stop(&client->monc);
661 fail:
662         ceph_messenger_fini(&client->msgr);
663         kfree(client);
664         return ERR_PTR(err);
665 }
666 EXPORT_SYMBOL(ceph_create_client);
667
668 void ceph_destroy_client(struct ceph_client *client)
669 {
670         dout("destroy_client %p\n", client);
671
672         atomic_set(&client->msgr.stopping, 1);
673
674         /* unmount */
675         ceph_osdc_stop(&client->osdc);
676         ceph_monc_stop(&client->monc);
677         ceph_messenger_fini(&client->msgr);
678
679         ceph_debugfs_client_cleanup(client);
680
681         ceph_destroy_options(client->options);
682
683         kfree(client);
684         dout("destroy_client %p done\n", client);
685 }
686 EXPORT_SYMBOL(ceph_destroy_client);
687
688 /*
689  * true if we have the mon map (and have thus joined the cluster)
690  */
691 static bool have_mon_and_osd_map(struct ceph_client *client)
692 {
693         return client->monc.monmap && client->monc.monmap->epoch &&
694                client->osdc.osdmap && client->osdc.osdmap->epoch;
695 }
696
697 /*
698  * mount: join the ceph cluster, and open root directory.
699  */
700 int __ceph_open_session(struct ceph_client *client, unsigned long started)
701 {
702         unsigned long timeout = client->options->mount_timeout;
703         long err;
704
705         /* open session, and wait for mon and osd maps */
706         err = ceph_monc_open_session(&client->monc);
707         if (err < 0)
708                 return err;
709
710         while (!have_mon_and_osd_map(client)) {
711                 if (timeout && time_after_eq(jiffies, started + timeout))
712                         return -ETIMEDOUT;
713
714                 /* wait */
715                 dout("mount waiting for mon_map\n");
716                 err = wait_event_interruptible_timeout(client->auth_wq,
717                         have_mon_and_osd_map(client) || (client->auth_err < 0),
718                         ceph_timeout_jiffies(timeout));
719                 if (err < 0)
720                         return err;
721                 if (client->auth_err < 0)
722                         return client->auth_err;
723         }
724
725         pr_info("client%llu fsid %pU\n", ceph_client_gid(client),
726                 &client->fsid);
727         ceph_debugfs_client_init(client);
728
729         return 0;
730 }
731 EXPORT_SYMBOL(__ceph_open_session);
732
733
734 int ceph_open_session(struct ceph_client *client)
735 {
736         int ret;
737         unsigned long started = jiffies;  /* note the start time */
738
739         dout("open_session start\n");
740         mutex_lock(&client->mount_mutex);
741
742         ret = __ceph_open_session(client, started);
743
744         mutex_unlock(&client->mount_mutex);
745         return ret;
746 }
747 EXPORT_SYMBOL(ceph_open_session);
748
749
750 static int __init init_ceph_lib(void)
751 {
752         int ret = 0;
753
754         ret = ceph_debugfs_init();
755         if (ret < 0)
756                 goto out;
757
758         ret = ceph_crypto_init();
759         if (ret < 0)
760                 goto out_debugfs;
761
762         ret = ceph_msgr_init();
763         if (ret < 0)
764                 goto out_crypto;
765
766         ret = ceph_osdc_setup();
767         if (ret < 0)
768                 goto out_msgr;
769
770         pr_info("loaded (mon/osd proto %d/%d)\n",
771                 CEPH_MONC_PROTOCOL, CEPH_OSDC_PROTOCOL);
772
773         return 0;
774
775 out_msgr:
776         ceph_msgr_exit();
777 out_crypto:
778         ceph_crypto_shutdown();
779 out_debugfs:
780         ceph_debugfs_cleanup();
781 out:
782         return ret;
783 }
784
785 static void __exit exit_ceph_lib(void)
786 {
787         dout("exit_ceph_lib\n");
788         WARN_ON(!ceph_strings_empty());
789
790         ceph_osdc_cleanup();
791         ceph_msgr_exit();
792         ceph_crypto_shutdown();
793         ceph_debugfs_cleanup();
794 }
795
796 module_init(init_ceph_lib);
797 module_exit(exit_ceph_lib);
798
799 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
800 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
801 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
802 MODULE_DESCRIPTION("Ceph core library");
803 MODULE_LICENSE("GPL");