2 #include <linux/ceph/ceph_debug.h>
3 #include <linux/backing-dev.h>
4 #include <linux/ctype.h>
6 #include <linux/inet.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>
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>
32 * Module compatibility interface. For now it doesn't do anything,
33 * but its existence signals a certain level of functionality.
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.
40 * The data pointer can be null.
42 bool libceph_compatible(void *data
)
46 EXPORT_SYMBOL(libceph_compatible
);
49 * find filename portion of a path (/foo/bar/baz -> baz)
51 const char *ceph_file_part(const char *s
, int len
)
53 const char *e
= s
+ len
;
55 while (e
!= s
&& *(e
-1) != '/')
59 EXPORT_SYMBOL(ceph_file_part
);
61 const char *ceph_msg_type_name(int type
)
64 case CEPH_MSG_SHUTDOWN
: return "shutdown";
65 case CEPH_MSG_PING
: return "ping";
66 case CEPH_MSG_AUTH
: return "auth";
67 case CEPH_MSG_AUTH_REPLY
: return "auth_reply";
68 case CEPH_MSG_MON_MAP
: return "mon_map";
69 case CEPH_MSG_MON_GET_MAP
: return "mon_get_map";
70 case CEPH_MSG_MON_SUBSCRIBE
: return "mon_subscribe";
71 case CEPH_MSG_MON_SUBSCRIBE_ACK
: return "mon_subscribe_ack";
72 case CEPH_MSG_STATFS
: return "statfs";
73 case CEPH_MSG_STATFS_REPLY
: return "statfs_reply";
74 case CEPH_MSG_MON_GET_VERSION
: return "mon_get_version";
75 case CEPH_MSG_MON_GET_VERSION_REPLY
: return "mon_get_version_reply";
76 case CEPH_MSG_MDS_MAP
: return "mds_map";
77 case CEPH_MSG_CLIENT_SESSION
: return "client_session";
78 case CEPH_MSG_CLIENT_RECONNECT
: return "client_reconnect";
79 case CEPH_MSG_CLIENT_REQUEST
: return "client_request";
80 case CEPH_MSG_CLIENT_REQUEST_FORWARD
: return "client_request_forward";
81 case CEPH_MSG_CLIENT_REPLY
: return "client_reply";
82 case CEPH_MSG_CLIENT_CAPS
: return "client_caps";
83 case CEPH_MSG_CLIENT_CAPRELEASE
: return "client_cap_release";
84 case CEPH_MSG_CLIENT_SNAP
: return "client_snap";
85 case CEPH_MSG_CLIENT_LEASE
: return "client_lease";
86 case CEPH_MSG_OSD_MAP
: return "osd_map";
87 case CEPH_MSG_OSD_OP
: return "osd_op";
88 case CEPH_MSG_OSD_OPREPLY
: return "osd_opreply";
89 case CEPH_MSG_WATCH_NOTIFY
: return "watch_notify";
90 default: return "unknown";
93 EXPORT_SYMBOL(ceph_msg_type_name
);
96 * Initially learn our fsid, or verify an fsid matches.
98 int ceph_check_fsid(struct ceph_client
*client
, struct ceph_fsid
*fsid
)
100 if (client
->have_fsid
) {
101 if (ceph_fsid_compare(&client
->fsid
, fsid
)) {
102 pr_err("bad fsid, had %pU got %pU",
103 &client
->fsid
, fsid
);
107 memcpy(&client
->fsid
, fsid
, sizeof(*fsid
));
111 EXPORT_SYMBOL(ceph_check_fsid
);
113 static int strcmp_null(const char *s1
, const char *s2
)
121 return strcmp(s1
, s2
);
124 int ceph_compare_options(struct ceph_options
*new_opt
,
125 struct ceph_client
*client
)
127 struct ceph_options
*opt1
= new_opt
;
128 struct ceph_options
*opt2
= client
->options
;
129 int ofs
= offsetof(struct ceph_options
, mon_addr
);
134 * Don't bother comparing options if network namespaces don't
137 if (!net_eq(current
->nsproxy
->net_ns
, read_pnet(&client
->msgr
.net
)))
140 ret
= memcmp(opt1
, opt2
, ofs
);
144 ret
= strcmp_null(opt1
->name
, opt2
->name
);
148 if (opt1
->key
&& !opt2
->key
)
150 if (!opt1
->key
&& opt2
->key
)
152 if (opt1
->key
&& opt2
->key
) {
153 if (opt1
->key
->type
!= opt2
->key
->type
)
155 if (opt1
->key
->created
.tv_sec
!= opt2
->key
->created
.tv_sec
)
157 if (opt1
->key
->created
.tv_nsec
!= opt2
->key
->created
.tv_nsec
)
159 if (opt1
->key
->len
!= opt2
->key
->len
)
161 if (opt1
->key
->key
&& !opt2
->key
->key
)
163 if (!opt1
->key
->key
&& opt2
->key
->key
)
165 if (opt1
->key
->key
&& opt2
->key
->key
) {
166 ret
= memcmp(opt1
->key
->key
, opt2
->key
->key
, opt1
->key
->len
);
172 /* any matching mon ip implies a match */
173 for (i
= 0; i
< opt1
->num_mon
; i
++) {
174 if (ceph_monmap_contains(client
->monc
.monmap
,
180 EXPORT_SYMBOL(ceph_compare_options
);
182 void *ceph_kvmalloc(size_t size
, gfp_t flags
)
184 if (size
<= (PAGE_SIZE
<< PAGE_ALLOC_COSTLY_ORDER
)) {
185 void *ptr
= kmalloc(size
, flags
| __GFP_NOWARN
);
190 return __vmalloc(size
, flags
| __GFP_HIGHMEM
, PAGE_KERNEL
);
194 static int parse_fsid(const char *str
, struct ceph_fsid
*fsid
)
201 dout("parse_fsid '%s'\n", str
);
203 while (*str
&& i
< 16) {
208 if (!isxdigit(str
[0]) || !isxdigit(str
[1]))
212 if (sscanf(tmp
, "%x", &d
) < 1)
214 fsid
->fsid
[i
] = d
& 0xff;
221 dout("parse_fsid ret %d got fsid %pU", err
, fsid
);
230 Opt_osdkeepalivetimeout
,
241 /* string args above */
246 Opt_cephx_require_signatures
,
247 Opt_nocephx_require_signatures
,
252 static match_table_t opt_tokens
= {
253 {Opt_osdtimeout
, "osdtimeout=%d"},
254 {Opt_osdkeepalivetimeout
, "osdkeepalive=%d"},
255 {Opt_mount_timeout
, "mount_timeout=%d"},
256 {Opt_osd_idle_ttl
, "osd_idle_ttl=%d"},
258 {Opt_fsid
, "fsid=%s"},
259 {Opt_name
, "name=%s"},
260 {Opt_secret
, "secret=%s"},
263 /* string args above */
264 {Opt_share
, "share"},
265 {Opt_noshare
, "noshare"},
267 {Opt_nocrc
, "nocrc"},
268 {Opt_cephx_require_signatures
, "cephx_require_signatures"},
269 {Opt_nocephx_require_signatures
, "nocephx_require_signatures"},
270 {Opt_tcp_nodelay
, "tcp_nodelay"},
271 {Opt_notcp_nodelay
, "notcp_nodelay"},
275 void ceph_destroy_options(struct ceph_options
*opt
)
277 dout("destroy_options %p\n", opt
);
280 ceph_crypto_key_destroy(opt
->key
);
283 kfree(opt
->mon_addr
);
286 EXPORT_SYMBOL(ceph_destroy_options
);
288 /* get secret from key store */
289 static int get_secret(struct ceph_crypto_key
*dst
, const char *name
) {
293 struct ceph_crypto_key
*ckey
;
295 ukey
= request_key(&key_type_ceph
, name
, NULL
);
296 if (!ukey
|| IS_ERR(ukey
)) {
297 /* request_key errors don't map nicely to mount(2)
298 errors; don't even try, but still printk */
299 key_err
= PTR_ERR(ukey
);
302 pr_warn("ceph: Mount failed due to key not found: %s\n",
306 pr_warn("ceph: Mount failed due to expired key: %s\n",
310 pr_warn("ceph: Mount failed due to revoked key: %s\n",
314 pr_warn("ceph: Mount failed due to unknown key error %d: %s\n",
321 ckey
= ukey
->payload
.data
;
322 err
= ceph_crypto_key_clone(dst
, ckey
);
325 /* pass through, err is 0 */
333 struct ceph_options
*
334 ceph_parse_options(char *options
, const char *dev_name
,
335 const char *dev_name_end
,
336 int (*parse_extra_token
)(char *c
, void *private),
339 struct ceph_options
*opt
;
342 substring_t argstr
[MAX_OPT_ARGS
];
344 opt
= kzalloc(sizeof(*opt
), GFP_KERNEL
);
346 return ERR_PTR(-ENOMEM
);
347 opt
->mon_addr
= kcalloc(CEPH_MAX_MON
, sizeof(*opt
->mon_addr
),
352 dout("parse_options %p options '%s' dev_name '%s'\n", opt
, options
,
355 /* start with defaults */
356 opt
->flags
= CEPH_OPT_DEFAULT
;
357 opt
->osd_keepalive_timeout
= CEPH_OSD_KEEPALIVE_DEFAULT
;
358 opt
->mount_timeout
= CEPH_MOUNT_TIMEOUT_DEFAULT
;
359 opt
->osd_idle_ttl
= CEPH_OSD_IDLE_TTL_DEFAULT
;
362 /* ip1[:port1][,ip2[:port2]...] */
363 err
= ceph_parse_ips(dev_name
, dev_name_end
, opt
->mon_addr
,
364 CEPH_MAX_MON
, &opt
->num_mon
);
368 /* parse mount options */
369 while ((c
= strsep(&options
, ",")) != NULL
) {
370 int token
, intval
, ret
;
374 token
= match_token((char *)c
, opt_tokens
, argstr
);
375 if (token
< 0 && parse_extra_token
) {
377 err
= parse_extra_token((char *)c
, private);
379 pr_err("bad option at '%s'\n", c
);
384 if (token
< Opt_last_int
) {
385 ret
= match_int(&argstr
[0], &intval
);
387 pr_err("bad mount option arg (not int) "
391 dout("got int token %d val %d\n", token
, intval
);
392 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
393 dout("got string token %d val %s\n", token
,
396 dout("got token %d\n", token
);
400 err
= ceph_parse_ips(argstr
[0].from
,
406 opt
->flags
|= CEPH_OPT_MYIP
;
410 err
= parse_fsid(argstr
[0].from
, &opt
->fsid
);
412 opt
->flags
|= CEPH_OPT_FSID
;
415 opt
->name
= kstrndup(argstr
[0].from
,
416 argstr
[0].to
-argstr
[0].from
,
420 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
425 err
= ceph_crypto_key_unarmor(opt
->key
, argstr
[0].from
);
430 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
435 err
= get_secret(opt
->key
, argstr
[0].from
);
442 pr_warn("ignoring deprecated osdtimeout option\n");
444 case Opt_osdkeepalivetimeout
:
445 /* 0 isn't well defined right now, reject it */
446 if (intval
< 1 || intval
> INT_MAX
/ 1000) {
447 pr_err("osdkeepalive out of range\n");
451 opt
->osd_keepalive_timeout
=
452 msecs_to_jiffies(intval
* 1000);
454 case Opt_osd_idle_ttl
:
455 /* 0 isn't well defined right now, reject it */
456 if (intval
< 1 || intval
> INT_MAX
/ 1000) {
457 pr_err("osd_idle_ttl out of range\n");
461 opt
->osd_idle_ttl
= msecs_to_jiffies(intval
* 1000);
463 case Opt_mount_timeout
:
464 /* 0 is "wait forever" (i.e. infinite timeout) */
465 if (intval
< 0 || intval
> INT_MAX
/ 1000) {
466 pr_err("mount_timeout out of range\n");
470 opt
->mount_timeout
= msecs_to_jiffies(intval
* 1000);
474 opt
->flags
&= ~CEPH_OPT_NOSHARE
;
477 opt
->flags
|= CEPH_OPT_NOSHARE
;
481 opt
->flags
&= ~CEPH_OPT_NOCRC
;
484 opt
->flags
|= CEPH_OPT_NOCRC
;
487 case Opt_cephx_require_signatures
:
488 opt
->flags
&= ~CEPH_OPT_NOMSGAUTH
;
490 case Opt_nocephx_require_signatures
:
491 opt
->flags
|= CEPH_OPT_NOMSGAUTH
;
494 case Opt_tcp_nodelay
:
495 opt
->flags
|= CEPH_OPT_TCP_NODELAY
;
497 case Opt_notcp_nodelay
:
498 opt
->flags
&= ~CEPH_OPT_TCP_NODELAY
;
510 ceph_destroy_options(opt
);
513 EXPORT_SYMBOL(ceph_parse_options
);
515 int ceph_print_client_options(struct seq_file
*m
, struct ceph_client
*client
)
517 struct ceph_options
*opt
= client
->options
;
518 size_t pos
= m
->count
;
521 seq_printf(m
, "name=%s,", opt
->name
);
523 seq_puts(m
, "secret=<hidden>,");
525 if (opt
->flags
& CEPH_OPT_FSID
)
526 seq_printf(m
, "fsid=%pU,", &opt
->fsid
);
527 if (opt
->flags
& CEPH_OPT_NOSHARE
)
528 seq_puts(m
, "noshare,");
529 if (opt
->flags
& CEPH_OPT_NOCRC
)
530 seq_puts(m
, "nocrc,");
531 if (opt
->flags
& CEPH_OPT_NOMSGAUTH
)
532 seq_puts(m
, "nocephx_require_signatures,");
533 if ((opt
->flags
& CEPH_OPT_TCP_NODELAY
) == 0)
534 seq_puts(m
, "notcp_nodelay,");
536 if (opt
->mount_timeout
!= CEPH_MOUNT_TIMEOUT_DEFAULT
)
537 seq_printf(m
, "mount_timeout=%d,",
538 jiffies_to_msecs(opt
->mount_timeout
) / 1000);
539 if (opt
->osd_idle_ttl
!= CEPH_OSD_IDLE_TTL_DEFAULT
)
540 seq_printf(m
, "osd_idle_ttl=%d,",
541 jiffies_to_msecs(opt
->osd_idle_ttl
) / 1000);
542 if (opt
->osd_keepalive_timeout
!= CEPH_OSD_KEEPALIVE_DEFAULT
)
543 seq_printf(m
, "osdkeepalivetimeout=%d,",
544 jiffies_to_msecs(opt
->osd_keepalive_timeout
) / 1000);
546 /* drop redundant comma */
552 EXPORT_SYMBOL(ceph_print_client_options
);
554 u64
ceph_client_id(struct ceph_client
*client
)
556 return client
->monc
.auth
->global_id
;
558 EXPORT_SYMBOL(ceph_client_id
);
561 * create a fresh client instance
563 struct ceph_client
*ceph_create_client(struct ceph_options
*opt
, void *private,
564 u64 supported_features
,
565 u64 required_features
)
567 struct ceph_client
*client
;
568 struct ceph_entity_addr
*myaddr
= NULL
;
571 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
573 return ERR_PTR(-ENOMEM
);
575 client
->private = private;
576 client
->options
= opt
;
578 mutex_init(&client
->mount_mutex
);
579 init_waitqueue_head(&client
->auth_wq
);
580 client
->auth_err
= 0;
582 if (!ceph_test_opt(client
, NOMSGAUTH
))
583 required_features
|= CEPH_FEATURE_MSG_AUTH
;
585 client
->extra_mon_dispatch
= NULL
;
586 client
->supported_features
= CEPH_FEATURES_SUPPORTED_DEFAULT
|
588 client
->required_features
= CEPH_FEATURES_REQUIRED_DEFAULT
|
592 if (ceph_test_opt(client
, MYIP
))
593 myaddr
= &client
->options
->my_addr
;
595 ceph_messenger_init(&client
->msgr
, myaddr
,
596 client
->supported_features
,
597 client
->required_features
,
598 ceph_test_opt(client
, NOCRC
),
599 ceph_test_opt(client
, TCP_NODELAY
));
602 err
= ceph_monc_init(&client
->monc
, client
);
605 err
= ceph_osdc_init(&client
->osdc
, client
);
612 ceph_monc_stop(&client
->monc
);
614 ceph_messenger_fini(&client
->msgr
);
618 EXPORT_SYMBOL(ceph_create_client
);
620 void ceph_destroy_client(struct ceph_client
*client
)
622 dout("destroy_client %p\n", client
);
624 atomic_set(&client
->msgr
.stopping
, 1);
627 ceph_osdc_stop(&client
->osdc
);
628 ceph_monc_stop(&client
->monc
);
629 ceph_messenger_fini(&client
->msgr
);
631 ceph_debugfs_client_cleanup(client
);
633 ceph_destroy_options(client
->options
);
636 dout("destroy_client %p done\n", client
);
638 EXPORT_SYMBOL(ceph_destroy_client
);
641 * true if we have the mon map (and have thus joined the cluster)
643 static int have_mon_and_osd_map(struct ceph_client
*client
)
645 return client
->monc
.monmap
&& client
->monc
.monmap
->epoch
&&
646 client
->osdc
.osdmap
&& client
->osdc
.osdmap
->epoch
;
650 * mount: join the ceph cluster, and open root directory.
652 int __ceph_open_session(struct ceph_client
*client
, unsigned long started
)
654 unsigned long timeout
= client
->options
->mount_timeout
;
657 /* open session, and wait for mon and osd maps */
658 err
= ceph_monc_open_session(&client
->monc
);
662 while (!have_mon_and_osd_map(client
)) {
663 if (timeout
&& time_after_eq(jiffies
, started
+ timeout
))
667 dout("mount waiting for mon_map\n");
668 err
= wait_event_interruptible_timeout(client
->auth_wq
,
669 have_mon_and_osd_map(client
) || (client
->auth_err
< 0),
670 ceph_timeout_jiffies(timeout
));
673 if (client
->auth_err
< 0)
674 return client
->auth_err
;
679 EXPORT_SYMBOL(__ceph_open_session
);
682 int ceph_open_session(struct ceph_client
*client
)
685 unsigned long started
= jiffies
; /* note the start time */
687 dout("open_session start\n");
688 mutex_lock(&client
->mount_mutex
);
690 ret
= __ceph_open_session(client
, started
);
692 mutex_unlock(&client
->mount_mutex
);
695 EXPORT_SYMBOL(ceph_open_session
);
698 static int __init
init_ceph_lib(void)
702 ret
= ceph_debugfs_init();
706 ret
= ceph_crypto_init();
710 ret
= ceph_msgr_init();
714 ret
= ceph_osdc_setup();
718 pr_info("loaded (mon/osd proto %d/%d)\n",
719 CEPH_MONC_PROTOCOL
, CEPH_OSDC_PROTOCOL
);
726 ceph_crypto_shutdown();
728 ceph_debugfs_cleanup();
733 static void __exit
exit_ceph_lib(void)
735 dout("exit_ceph_lib\n");
738 ceph_crypto_shutdown();
739 ceph_debugfs_cleanup();
742 module_init(init_ceph_lib
);
743 module_exit(exit_ceph_lib
);
745 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
746 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
747 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
748 MODULE_DESCRIPTION("Ceph core library");
749 MODULE_LICENSE("GPL");