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/parser.h>
13 #include <linux/sched.h>
14 #include <linux/seq_file.h>
15 #include <linux/slab.h>
16 #include <linux/statfs.h>
17 #include <linux/string.h>
20 #include <linux/ceph/ceph_features.h>
21 #include <linux/ceph/libceph.h>
22 #include <linux/ceph/debugfs.h>
23 #include <linux/ceph/decode.h>
24 #include <linux/ceph/mon_client.h>
25 #include <linux/ceph/auth.h>
30 * Module compatibility interface. For now it doesn't do anything,
31 * but its existence signals a certain level of functionality.
33 * The data buffer is used to pass information both to and from
34 * libceph. The return value indicates whether libceph determines
35 * it is compatible with the caller (from another kernel module),
36 * given the provided data.
38 * The data pointer can be null.
40 bool libceph_compatible(void *data
)
44 EXPORT_SYMBOL(libceph_compatible
);
47 * find filename portion of a path (/foo/bar/baz -> baz)
49 const char *ceph_file_part(const char *s
, int len
)
51 const char *e
= s
+ len
;
53 while (e
!= s
&& *(e
-1) != '/')
57 EXPORT_SYMBOL(ceph_file_part
);
59 const char *ceph_msg_type_name(int 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_MDS_MAP
: return "mds_map";
73 case CEPH_MSG_CLIENT_SESSION
: return "client_session";
74 case CEPH_MSG_CLIENT_RECONNECT
: return "client_reconnect";
75 case CEPH_MSG_CLIENT_REQUEST
: return "client_request";
76 case CEPH_MSG_CLIENT_REQUEST_FORWARD
: return "client_request_forward";
77 case CEPH_MSG_CLIENT_REPLY
: return "client_reply";
78 case CEPH_MSG_CLIENT_CAPS
: return "client_caps";
79 case CEPH_MSG_CLIENT_CAPRELEASE
: return "client_cap_release";
80 case CEPH_MSG_CLIENT_SNAP
: return "client_snap";
81 case CEPH_MSG_CLIENT_LEASE
: return "client_lease";
82 case CEPH_MSG_OSD_MAP
: return "osd_map";
83 case CEPH_MSG_OSD_OP
: return "osd_op";
84 case CEPH_MSG_OSD_OPREPLY
: return "osd_opreply";
85 case CEPH_MSG_WATCH_NOTIFY
: return "watch_notify";
86 default: return "unknown";
89 EXPORT_SYMBOL(ceph_msg_type_name
);
92 * Initially learn our fsid, or verify an fsid matches.
94 int ceph_check_fsid(struct ceph_client
*client
, struct ceph_fsid
*fsid
)
96 if (client
->have_fsid
) {
97 if (ceph_fsid_compare(&client
->fsid
, fsid
)) {
98 pr_err("bad fsid, had %pU got %pU",
103 memcpy(&client
->fsid
, fsid
, sizeof(*fsid
));
107 EXPORT_SYMBOL(ceph_check_fsid
);
109 static int strcmp_null(const char *s1
, const char *s2
)
117 return strcmp(s1
, s2
);
120 int ceph_compare_options(struct ceph_options
*new_opt
,
121 struct ceph_client
*client
)
123 struct ceph_options
*opt1
= new_opt
;
124 struct ceph_options
*opt2
= client
->options
;
125 int ofs
= offsetof(struct ceph_options
, mon_addr
);
129 ret
= memcmp(opt1
, opt2
, ofs
);
133 ret
= strcmp_null(opt1
->name
, opt2
->name
);
137 if (opt1
->key
&& !opt2
->key
)
139 if (!opt1
->key
&& opt2
->key
)
141 if (opt1
->key
&& opt2
->key
) {
142 if (opt1
->key
->type
!= opt2
->key
->type
)
144 if (opt1
->key
->created
.tv_sec
!= opt2
->key
->created
.tv_sec
)
146 if (opt1
->key
->created
.tv_nsec
!= opt2
->key
->created
.tv_nsec
)
148 if (opt1
->key
->len
!= opt2
->key
->len
)
150 if (opt1
->key
->key
&& !opt2
->key
->key
)
152 if (!opt1
->key
->key
&& opt2
->key
->key
)
154 if (opt1
->key
->key
&& opt2
->key
->key
) {
155 ret
= memcmp(opt1
->key
->key
, opt2
->key
->key
, opt1
->key
->len
);
161 /* any matching mon ip implies a match */
162 for (i
= 0; i
< opt1
->num_mon
; i
++) {
163 if (ceph_monmap_contains(client
->monc
.monmap
,
169 EXPORT_SYMBOL(ceph_compare_options
);
172 static int parse_fsid(const char *str
, struct ceph_fsid
*fsid
)
179 dout("parse_fsid '%s'\n", str
);
181 while (*str
&& i
< 16) {
186 if (!isxdigit(str
[0]) || !isxdigit(str
[1]))
190 if (sscanf(tmp
, "%x", &d
) < 1)
192 fsid
->fsid
[i
] = d
& 0xff;
199 dout("parse_fsid ret %d got fsid %pU", err
, fsid
);
208 Opt_osdkeepalivetimeout
,
219 /* string args above */
226 static match_table_t opt_tokens
= {
227 {Opt_osdtimeout
, "osdtimeout=%d"},
228 {Opt_osdkeepalivetimeout
, "osdkeepalive=%d"},
229 {Opt_mount_timeout
, "mount_timeout=%d"},
230 {Opt_osd_idle_ttl
, "osd_idle_ttl=%d"},
232 {Opt_fsid
, "fsid=%s"},
233 {Opt_name
, "name=%s"},
234 {Opt_secret
, "secret=%s"},
237 /* string args above */
238 {Opt_share
, "share"},
239 {Opt_noshare
, "noshare"},
241 {Opt_nocrc
, "nocrc"},
245 void ceph_destroy_options(struct ceph_options
*opt
)
247 dout("destroy_options %p\n", opt
);
250 ceph_crypto_key_destroy(opt
->key
);
253 kfree(opt
->mon_addr
);
256 EXPORT_SYMBOL(ceph_destroy_options
);
258 /* get secret from key store */
259 static int get_secret(struct ceph_crypto_key
*dst
, const char *name
) {
263 struct ceph_crypto_key
*ckey
;
265 ukey
= request_key(&key_type_ceph
, name
, NULL
);
266 if (!ukey
|| IS_ERR(ukey
)) {
267 /* request_key errors don't map nicely to mount(2)
268 errors; don't even try, but still printk */
269 key_err
= PTR_ERR(ukey
);
272 pr_warning("ceph: Mount failed due to key not found: %s\n", name
);
275 pr_warning("ceph: Mount failed due to expired key: %s\n", name
);
278 pr_warning("ceph: Mount failed due to revoked key: %s\n", name
);
281 pr_warning("ceph: Mount failed due to unknown key error"
282 " %d: %s\n", key_err
, name
);
288 ckey
= ukey
->payload
.data
;
289 err
= ceph_crypto_key_clone(dst
, ckey
);
292 /* pass through, err is 0 */
300 struct ceph_options
*
301 ceph_parse_options(char *options
, const char *dev_name
,
302 const char *dev_name_end
,
303 int (*parse_extra_token
)(char *c
, void *private),
306 struct ceph_options
*opt
;
309 substring_t argstr
[MAX_OPT_ARGS
];
311 opt
= kzalloc(sizeof(*opt
), GFP_KERNEL
);
313 return ERR_PTR(-ENOMEM
);
314 opt
->mon_addr
= kcalloc(CEPH_MAX_MON
, sizeof(*opt
->mon_addr
),
319 dout("parse_options %p options '%s' dev_name '%s'\n", opt
, options
,
322 /* start with defaults */
323 opt
->flags
= CEPH_OPT_DEFAULT
;
324 opt
->osd_keepalive_timeout
= CEPH_OSD_KEEPALIVE_DEFAULT
;
325 opt
->mount_timeout
= CEPH_MOUNT_TIMEOUT_DEFAULT
; /* seconds */
326 opt
->osd_idle_ttl
= CEPH_OSD_IDLE_TTL_DEFAULT
; /* seconds */
329 /* ip1[:port1][,ip2[:port2]...] */
330 err
= ceph_parse_ips(dev_name
, dev_name_end
, opt
->mon_addr
,
331 CEPH_MAX_MON
, &opt
->num_mon
);
335 /* parse mount options */
336 while ((c
= strsep(&options
, ",")) != NULL
) {
337 int token
, intval
, ret
;
341 token
= match_token((char *)c
, opt_tokens
, argstr
);
342 if (token
< 0 && parse_extra_token
) {
344 err
= parse_extra_token((char *)c
, private);
346 pr_err("bad option at '%s'\n", c
);
351 if (token
< Opt_last_int
) {
352 ret
= match_int(&argstr
[0], &intval
);
354 pr_err("bad mount option arg (not int) "
358 dout("got int token %d val %d\n", token
, intval
);
359 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
360 dout("got string token %d val %s\n", token
,
363 dout("got token %d\n", token
);
367 err
= ceph_parse_ips(argstr
[0].from
,
373 opt
->flags
|= CEPH_OPT_MYIP
;
377 err
= parse_fsid(argstr
[0].from
, &opt
->fsid
);
379 opt
->flags
|= CEPH_OPT_FSID
;
382 opt
->name
= kstrndup(argstr
[0].from
,
383 argstr
[0].to
-argstr
[0].from
,
387 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
392 err
= ceph_crypto_key_unarmor(opt
->key
, argstr
[0].from
);
397 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
402 err
= get_secret(opt
->key
, argstr
[0].from
);
409 pr_warning("ignoring deprecated osdtimeout option\n");
411 case Opt_osdkeepalivetimeout
:
412 opt
->osd_keepalive_timeout
= intval
;
414 case Opt_osd_idle_ttl
:
415 opt
->osd_idle_ttl
= intval
;
417 case Opt_mount_timeout
:
418 opt
->mount_timeout
= intval
;
422 opt
->flags
&= ~CEPH_OPT_NOSHARE
;
425 opt
->flags
|= CEPH_OPT_NOSHARE
;
429 opt
->flags
&= ~CEPH_OPT_NOCRC
;
432 opt
->flags
|= CEPH_OPT_NOCRC
;
444 ceph_destroy_options(opt
);
447 EXPORT_SYMBOL(ceph_parse_options
);
449 u64
ceph_client_id(struct ceph_client
*client
)
451 return client
->monc
.auth
->global_id
;
453 EXPORT_SYMBOL(ceph_client_id
);
456 * create a fresh client instance
458 struct ceph_client
*ceph_create_client(struct ceph_options
*opt
, void *private,
459 unsigned int supported_features
,
460 unsigned int required_features
)
462 struct ceph_client
*client
;
463 struct ceph_entity_addr
*myaddr
= NULL
;
466 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
468 return ERR_PTR(-ENOMEM
);
470 client
->private = private;
471 client
->options
= opt
;
473 mutex_init(&client
->mount_mutex
);
474 init_waitqueue_head(&client
->auth_wq
);
475 client
->auth_err
= 0;
477 client
->extra_mon_dispatch
= NULL
;
478 client
->supported_features
= CEPH_FEATURES_SUPPORTED_DEFAULT
|
480 client
->required_features
= CEPH_FEATURES_REQUIRED_DEFAULT
|
484 if (ceph_test_opt(client
, MYIP
))
485 myaddr
= &client
->options
->my_addr
;
486 ceph_messenger_init(&client
->msgr
, myaddr
,
487 client
->supported_features
,
488 client
->required_features
,
489 ceph_test_opt(client
, NOCRC
));
492 err
= ceph_monc_init(&client
->monc
, client
);
495 err
= ceph_osdc_init(&client
->osdc
, client
);
502 ceph_monc_stop(&client
->monc
);
507 EXPORT_SYMBOL(ceph_create_client
);
509 void ceph_destroy_client(struct ceph_client
*client
)
511 dout("destroy_client %p\n", client
);
513 atomic_set(&client
->msgr
.stopping
, 1);
516 ceph_osdc_stop(&client
->osdc
);
518 ceph_monc_stop(&client
->monc
);
520 ceph_debugfs_client_cleanup(client
);
522 ceph_destroy_options(client
->options
);
525 dout("destroy_client %p done\n", client
);
527 EXPORT_SYMBOL(ceph_destroy_client
);
530 * true if we have the mon map (and have thus joined the cluster)
532 static int have_mon_and_osd_map(struct ceph_client
*client
)
534 return client
->monc
.monmap
&& client
->monc
.monmap
->epoch
&&
535 client
->osdc
.osdmap
&& client
->osdc
.osdmap
->epoch
;
539 * mount: join the ceph cluster, and open root directory.
541 int __ceph_open_session(struct ceph_client
*client
, unsigned long started
)
544 unsigned long timeout
= client
->options
->mount_timeout
* HZ
;
546 /* open session, and wait for mon and osd maps */
547 err
= ceph_monc_open_session(&client
->monc
);
551 while (!have_mon_and_osd_map(client
)) {
553 if (timeout
&& time_after_eq(jiffies
, started
+ timeout
))
557 dout("mount waiting for mon_map\n");
558 err
= wait_event_interruptible_timeout(client
->auth_wq
,
559 have_mon_and_osd_map(client
) || (client
->auth_err
< 0),
561 if (err
== -EINTR
|| err
== -ERESTARTSYS
)
563 if (client
->auth_err
< 0)
564 return client
->auth_err
;
569 EXPORT_SYMBOL(__ceph_open_session
);
572 int ceph_open_session(struct ceph_client
*client
)
575 unsigned long started
= jiffies
; /* note the start time */
577 dout("open_session start\n");
578 mutex_lock(&client
->mount_mutex
);
580 ret
= __ceph_open_session(client
, started
);
582 mutex_unlock(&client
->mount_mutex
);
585 EXPORT_SYMBOL(ceph_open_session
);
588 static int __init
init_ceph_lib(void)
592 ret
= ceph_debugfs_init();
596 ret
= ceph_crypto_init();
600 ret
= ceph_msgr_init();
604 pr_info("loaded (mon/osd proto %d/%d, osdmap %d/%d %d/%d)\n",
605 CEPH_MONC_PROTOCOL
, CEPH_OSDC_PROTOCOL
,
606 CEPH_OSDMAP_VERSION
, CEPH_OSDMAP_VERSION_EXT
,
607 CEPH_OSDMAP_INC_VERSION
, CEPH_OSDMAP_INC_VERSION_EXT
);
612 ceph_crypto_shutdown();
614 ceph_debugfs_cleanup();
619 static void __exit
exit_ceph_lib(void)
621 dout("exit_ceph_lib\n");
623 ceph_crypto_shutdown();
624 ceph_debugfs_cleanup();
627 module_init(init_ceph_lib
);
628 module_exit(exit_ceph_lib
);
630 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
631 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
632 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
633 MODULE_DESCRIPTION("Ceph filesystem for Linux");
634 MODULE_LICENSE("GPL");