2 #include <linux/ceph/ceph_debug.h>
3 #include <linux/backing-dev.h>
4 #include <linux/ctype.h>
6 #include <linux/inet.h>
8 #include <linux/module.h>
9 #include <linux/mount.h>
10 #include <linux/parser.h>
11 #include <linux/sched.h>
12 #include <linux/seq_file.h>
13 #include <linux/slab.h>
14 #include <linux/statfs.h>
15 #include <linux/string.h>
18 #include <linux/ceph/libceph.h>
19 #include <linux/ceph/debugfs.h>
20 #include <linux/ceph/decode.h>
21 #include <linux/ceph/mon_client.h>
22 #include <linux/ceph/auth.h>
28 * find filename portion of a path (/foo/bar/baz -> baz)
30 const char *ceph_file_part(const char *s
, int len
)
32 const char *e
= s
+ len
;
34 while (e
!= s
&& *(e
-1) != '/')
38 EXPORT_SYMBOL(ceph_file_part
);
40 const char *ceph_msg_type_name(int type
)
43 case CEPH_MSG_SHUTDOWN
: return "shutdown";
44 case CEPH_MSG_PING
: return "ping";
45 case CEPH_MSG_AUTH
: return "auth";
46 case CEPH_MSG_AUTH_REPLY
: return "auth_reply";
47 case CEPH_MSG_MON_MAP
: return "mon_map";
48 case CEPH_MSG_MON_GET_MAP
: return "mon_get_map";
49 case CEPH_MSG_MON_SUBSCRIBE
: return "mon_subscribe";
50 case CEPH_MSG_MON_SUBSCRIBE_ACK
: return "mon_subscribe_ack";
51 case CEPH_MSG_STATFS
: return "statfs";
52 case CEPH_MSG_STATFS_REPLY
: return "statfs_reply";
53 case CEPH_MSG_MDS_MAP
: return "mds_map";
54 case CEPH_MSG_CLIENT_SESSION
: return "client_session";
55 case CEPH_MSG_CLIENT_RECONNECT
: return "client_reconnect";
56 case CEPH_MSG_CLIENT_REQUEST
: return "client_request";
57 case CEPH_MSG_CLIENT_REQUEST_FORWARD
: return "client_request_forward";
58 case CEPH_MSG_CLIENT_REPLY
: return "client_reply";
59 case CEPH_MSG_CLIENT_CAPS
: return "client_caps";
60 case CEPH_MSG_CLIENT_CAPRELEASE
: return "client_cap_release";
61 case CEPH_MSG_CLIENT_SNAP
: return "client_snap";
62 case CEPH_MSG_CLIENT_LEASE
: return "client_lease";
63 case CEPH_MSG_OSD_MAP
: return "osd_map";
64 case CEPH_MSG_OSD_OP
: return "osd_op";
65 case CEPH_MSG_OSD_OPREPLY
: return "osd_opreply";
66 case CEPH_MSG_WATCH_NOTIFY
: return "watch_notify";
67 default: return "unknown";
70 EXPORT_SYMBOL(ceph_msg_type_name
);
73 * Initially learn our fsid, or verify an fsid matches.
75 int ceph_check_fsid(struct ceph_client
*client
, struct ceph_fsid
*fsid
)
77 if (client
->have_fsid
) {
78 if (ceph_fsid_compare(&client
->fsid
, fsid
)) {
79 pr_err("bad fsid, had %pU got %pU",
84 pr_info("client%lld fsid %pU\n", ceph_client_id(client
), fsid
);
85 memcpy(&client
->fsid
, fsid
, sizeof(*fsid
));
86 ceph_debugfs_client_init(client
);
87 client
->have_fsid
= true;
91 EXPORT_SYMBOL(ceph_check_fsid
);
93 static int strcmp_null(const char *s1
, const char *s2
)
101 return strcmp(s1
, s2
);
104 int ceph_compare_options(struct ceph_options
*new_opt
,
105 struct ceph_client
*client
)
107 struct ceph_options
*opt1
= new_opt
;
108 struct ceph_options
*opt2
= client
->options
;
109 int ofs
= offsetof(struct ceph_options
, mon_addr
);
113 ret
= memcmp(opt1
, opt2
, ofs
);
117 ret
= strcmp_null(opt1
->name
, opt2
->name
);
121 if (opt1
->key
&& !opt2
->key
)
123 if (!opt1
->key
&& opt2
->key
)
125 if (opt1
->key
&& opt2
->key
) {
126 if (opt1
->key
->type
!= opt2
->key
->type
)
128 if (opt1
->key
->created
.tv_sec
!= opt2
->key
->created
.tv_sec
)
130 if (opt1
->key
->created
.tv_nsec
!= opt2
->key
->created
.tv_nsec
)
132 if (opt1
->key
->len
!= opt2
->key
->len
)
134 if (opt1
->key
->key
&& !opt2
->key
->key
)
136 if (!opt1
->key
->key
&& opt2
->key
->key
)
138 if (opt1
->key
->key
&& opt2
->key
->key
) {
139 ret
= memcmp(opt1
->key
->key
, opt2
->key
->key
, opt1
->key
->len
);
145 /* any matching mon ip implies a match */
146 for (i
= 0; i
< opt1
->num_mon
; i
++) {
147 if (ceph_monmap_contains(client
->monc
.monmap
,
153 EXPORT_SYMBOL(ceph_compare_options
);
156 static int parse_fsid(const char *str
, struct ceph_fsid
*fsid
)
163 dout("parse_fsid '%s'\n", str
);
165 while (*str
&& i
< 16) {
170 if (!isxdigit(str
[0]) || !isxdigit(str
[1]))
174 if (sscanf(tmp
, "%x", &d
) < 1)
176 fsid
->fsid
[i
] = d
& 0xff;
183 dout("parse_fsid ret %d got fsid %pU", err
, fsid
);
192 Opt_osdkeepalivetimeout
,
202 /* string args above */
207 static match_table_t opt_tokens
= {
208 {Opt_osdtimeout
, "osdtimeout=%d"},
209 {Opt_osdkeepalivetimeout
, "osdkeepalive=%d"},
210 {Opt_mount_timeout
, "mount_timeout=%d"},
211 {Opt_osd_idle_ttl
, "osd_idle_ttl=%d"},
213 {Opt_fsid
, "fsid=%s"},
214 {Opt_name
, "name=%s"},
215 {Opt_secret
, "secret=%s"},
217 /* string args above */
218 {Opt_noshare
, "noshare"},
219 {Opt_nocrc
, "nocrc"},
223 void ceph_destroy_options(struct ceph_options
*opt
)
225 dout("destroy_options %p\n", opt
);
228 ceph_crypto_key_destroy(opt
->key
);
233 EXPORT_SYMBOL(ceph_destroy_options
);
235 int ceph_parse_options(struct ceph_options
**popt
, char *options
,
236 const char *dev_name
, const char *dev_name_end
,
237 int (*parse_extra_token
)(char *c
, void *private),
240 struct ceph_options
*opt
;
243 substring_t argstr
[MAX_OPT_ARGS
];
245 opt
= kzalloc(sizeof(*opt
), GFP_KERNEL
);
248 opt
->mon_addr
= kcalloc(CEPH_MAX_MON
, sizeof(*opt
->mon_addr
),
253 dout("parse_options %p options '%s' dev_name '%s'\n", opt
, options
,
256 /* start with defaults */
257 opt
->flags
= CEPH_OPT_DEFAULT
;
258 opt
->osd_timeout
= CEPH_OSD_TIMEOUT_DEFAULT
;
259 opt
->osd_keepalive_timeout
= CEPH_OSD_KEEPALIVE_DEFAULT
;
260 opt
->mount_timeout
= CEPH_MOUNT_TIMEOUT_DEFAULT
; /* seconds */
261 opt
->osd_idle_ttl
= CEPH_OSD_IDLE_TTL_DEFAULT
; /* seconds */
264 /* ip1[:port1][,ip2[:port2]...] */
265 err
= ceph_parse_ips(dev_name
, dev_name_end
, opt
->mon_addr
,
266 CEPH_MAX_MON
, &opt
->num_mon
);
270 /* parse mount options */
271 while ((c
= strsep(&options
, ",")) != NULL
) {
272 int token
, intval
, ret
;
276 token
= match_token((char *)c
, opt_tokens
, argstr
);
277 if (token
< 0 && parse_extra_token
) {
279 err
= parse_extra_token((char *)c
, private);
281 pr_err("bad option at '%s'\n", c
);
286 if (token
< Opt_last_int
) {
287 ret
= match_int(&argstr
[0], &intval
);
289 pr_err("bad mount option arg (not int) "
293 dout("got int token %d val %d\n", token
, intval
);
294 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
295 dout("got string token %d val %s\n", token
,
298 dout("got token %d\n", token
);
302 err
= ceph_parse_ips(argstr
[0].from
,
308 opt
->flags
|= CEPH_OPT_MYIP
;
312 err
= parse_fsid(argstr
[0].from
, &opt
->fsid
);
314 opt
->flags
|= CEPH_OPT_FSID
;
317 opt
->name
= kstrndup(argstr
[0].from
,
318 argstr
[0].to
-argstr
[0].from
,
322 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
327 err
= ceph_crypto_key_unarmor(opt
->key
, argstr
[0].from
);
334 opt
->osd_timeout
= intval
;
336 case Opt_osdkeepalivetimeout
:
337 opt
->osd_keepalive_timeout
= intval
;
339 case Opt_osd_idle_ttl
:
340 opt
->osd_idle_ttl
= intval
;
342 case Opt_mount_timeout
:
343 opt
->mount_timeout
= intval
;
347 opt
->flags
|= CEPH_OPT_NOSHARE
;
351 opt
->flags
|= CEPH_OPT_NOCRC
;
364 ceph_destroy_options(opt
);
367 EXPORT_SYMBOL(ceph_parse_options
);
369 u64
ceph_client_id(struct ceph_client
*client
)
371 return client
->monc
.auth
->global_id
;
373 EXPORT_SYMBOL(ceph_client_id
);
376 * create a fresh client instance
378 struct ceph_client
*ceph_create_client(struct ceph_options
*opt
, void *private)
380 struct ceph_client
*client
;
383 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
385 return ERR_PTR(-ENOMEM
);
387 client
->private = private;
388 client
->options
= opt
;
390 mutex_init(&client
->mount_mutex
);
391 init_waitqueue_head(&client
->auth_wq
);
392 client
->auth_err
= 0;
394 client
->extra_mon_dispatch
= NULL
;
395 client
->supported_features
= CEPH_FEATURE_SUPPORTED_DEFAULT
;
396 client
->required_features
= CEPH_FEATURE_REQUIRED_DEFAULT
;
401 err
= ceph_monc_init(&client
->monc
, client
);
404 err
= ceph_osdc_init(&client
->osdc
, client
);
411 ceph_monc_stop(&client
->monc
);
416 EXPORT_SYMBOL(ceph_create_client
);
418 void ceph_destroy_client(struct ceph_client
*client
)
420 dout("destroy_client %p\n", client
);
423 ceph_osdc_stop(&client
->osdc
);
426 * make sure osd connections close out before destroying the
427 * auth module, which is needed to free those connections'
432 ceph_monc_stop(&client
->monc
);
434 ceph_debugfs_client_cleanup(client
);
437 ceph_messenger_destroy(client
->msgr
);
439 ceph_destroy_options(client
->options
);
442 dout("destroy_client %p done\n", client
);
444 EXPORT_SYMBOL(ceph_destroy_client
);
447 * true if we have the mon map (and have thus joined the cluster)
449 static int have_mon_and_osd_map(struct ceph_client
*client
)
451 return client
->monc
.monmap
&& client
->monc
.monmap
->epoch
&&
452 client
->osdc
.osdmap
&& client
->osdc
.osdmap
->epoch
;
456 * mount: join the ceph cluster, and open root directory.
458 int __ceph_open_session(struct ceph_client
*client
, unsigned long started
)
460 struct ceph_entity_addr
*myaddr
= NULL
;
462 unsigned long timeout
= client
->options
->mount_timeout
* HZ
;
464 /* initialize the messenger */
465 if (client
->msgr
== NULL
) {
466 if (ceph_test_opt(client
, MYIP
))
467 myaddr
= &client
->options
->my_addr
;
468 client
->msgr
= ceph_messenger_create(myaddr
,
469 client
->supported_features
,
470 client
->required_features
);
471 if (IS_ERR(client
->msgr
)) {
473 return PTR_ERR(client
->msgr
);
475 client
->msgr
->nocrc
= ceph_test_opt(client
, NOCRC
);
478 /* open session, and wait for mon and osd maps */
479 err
= ceph_monc_open_session(&client
->monc
);
483 while (!have_mon_and_osd_map(client
)) {
485 if (timeout
&& time_after_eq(jiffies
, started
+ timeout
))
489 dout("mount waiting for mon_map\n");
490 err
= wait_event_interruptible_timeout(client
->auth_wq
,
491 have_mon_and_osd_map(client
) || (client
->auth_err
< 0),
493 if (err
== -EINTR
|| err
== -ERESTARTSYS
)
495 if (client
->auth_err
< 0)
496 return client
->auth_err
;
501 EXPORT_SYMBOL(__ceph_open_session
);
504 int ceph_open_session(struct ceph_client
*client
)
507 unsigned long started
= jiffies
; /* note the start time */
509 dout("open_session start\n");
510 mutex_lock(&client
->mount_mutex
);
512 ret
= __ceph_open_session(client
, started
);
514 mutex_unlock(&client
->mount_mutex
);
517 EXPORT_SYMBOL(ceph_open_session
);
520 static int __init
init_ceph_lib(void)
524 ret
= ceph_debugfs_init();
528 ret
= ceph_msgr_init();
532 pr_info("loaded (mon/osd proto %d/%d, osdmap %d/%d %d/%d)\n",
533 CEPH_MONC_PROTOCOL
, CEPH_OSDC_PROTOCOL
,
534 CEPH_OSDMAP_VERSION
, CEPH_OSDMAP_VERSION_EXT
,
535 CEPH_OSDMAP_INC_VERSION
, CEPH_OSDMAP_INC_VERSION_EXT
);
540 ceph_debugfs_cleanup();
545 static void __exit
exit_ceph_lib(void)
547 dout("exit_ceph_lib\n");
549 ceph_debugfs_cleanup();
552 module_init(init_ceph_lib
);
553 module_exit(exit_ceph_lib
);
555 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
556 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
557 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
558 MODULE_DESCRIPTION("Ceph filesystem for Linux");
559 MODULE_LICENSE("GPL");