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>
18 #include <linux/vmalloc.h>
19 #include <linux/nsproxy.h>
20 #include <net/net_namespace.h>
23 #include <linux/ceph/ceph_features.h>
24 #include <linux/ceph/libceph.h>
25 #include <linux/ceph/debugfs.h>
26 #include <linux/ceph/decode.h>
27 #include <linux/ceph/mon_client.h>
28 #include <linux/ceph/auth.h>
33 * Module compatibility interface. For now it doesn't do anything,
34 * but its existence signals a certain level of functionality.
36 * The data buffer is used to pass information both to and from
37 * libceph. The return value indicates whether libceph determines
38 * it is compatible with the caller (from another kernel module),
39 * given the provided data.
41 * The data pointer can be null.
43 bool libceph_compatible(void *data
)
47 EXPORT_SYMBOL(libceph_compatible
);
50 * find filename portion of a path (/foo/bar/baz -> baz)
52 const char *ceph_file_part(const char *s
, int len
)
54 const char *e
= s
+ len
;
56 while (e
!= s
&& *(e
-1) != '/')
60 EXPORT_SYMBOL(ceph_file_part
);
62 const char *ceph_msg_type_name(int type
)
65 case CEPH_MSG_SHUTDOWN
: return "shutdown";
66 case CEPH_MSG_PING
: return "ping";
67 case CEPH_MSG_AUTH
: return "auth";
68 case CEPH_MSG_AUTH_REPLY
: return "auth_reply";
69 case CEPH_MSG_MON_MAP
: return "mon_map";
70 case CEPH_MSG_MON_GET_MAP
: return "mon_get_map";
71 case CEPH_MSG_MON_SUBSCRIBE
: return "mon_subscribe";
72 case CEPH_MSG_MON_SUBSCRIBE_ACK
: return "mon_subscribe_ack";
73 case CEPH_MSG_STATFS
: return "statfs";
74 case CEPH_MSG_STATFS_REPLY
: return "statfs_reply";
75 case CEPH_MSG_MDS_MAP
: return "mds_map";
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_SNAP
: return "client_snap";
84 case CEPH_MSG_CLIENT_LEASE
: return "client_lease";
85 case CEPH_MSG_OSD_MAP
: return "osd_map";
86 case CEPH_MSG_OSD_OP
: return "osd_op";
87 case CEPH_MSG_OSD_OPREPLY
: return "osd_opreply";
88 case CEPH_MSG_WATCH_NOTIFY
: return "watch_notify";
89 default: return "unknown";
92 EXPORT_SYMBOL(ceph_msg_type_name
);
95 * Initially learn our fsid, or verify an fsid matches.
97 int ceph_check_fsid(struct ceph_client
*client
, struct ceph_fsid
*fsid
)
99 if (client
->have_fsid
) {
100 if (ceph_fsid_compare(&client
->fsid
, fsid
)) {
101 pr_err("bad fsid, had %pU got %pU",
102 &client
->fsid
, fsid
);
106 memcpy(&client
->fsid
, fsid
, sizeof(*fsid
));
110 EXPORT_SYMBOL(ceph_check_fsid
);
112 static int strcmp_null(const char *s1
, const char *s2
)
120 return strcmp(s1
, s2
);
123 int ceph_compare_options(struct ceph_options
*new_opt
,
124 struct ceph_client
*client
)
126 struct ceph_options
*opt1
= new_opt
;
127 struct ceph_options
*opt2
= client
->options
;
128 int ofs
= offsetof(struct ceph_options
, mon_addr
);
132 ret
= memcmp(opt1
, opt2
, ofs
);
136 ret
= strcmp_null(opt1
->name
, opt2
->name
);
140 if (opt1
->key
&& !opt2
->key
)
142 if (!opt1
->key
&& opt2
->key
)
144 if (opt1
->key
&& opt2
->key
) {
145 if (opt1
->key
->type
!= opt2
->key
->type
)
147 if (opt1
->key
->created
.tv_sec
!= opt2
->key
->created
.tv_sec
)
149 if (opt1
->key
->created
.tv_nsec
!= opt2
->key
->created
.tv_nsec
)
151 if (opt1
->key
->len
!= opt2
->key
->len
)
153 if (opt1
->key
->key
&& !opt2
->key
->key
)
155 if (!opt1
->key
->key
&& opt2
->key
->key
)
157 if (opt1
->key
->key
&& opt2
->key
->key
) {
158 ret
= memcmp(opt1
->key
->key
, opt2
->key
->key
, opt1
->key
->len
);
164 /* any matching mon ip implies a match */
165 for (i
= 0; i
< opt1
->num_mon
; i
++) {
166 if (ceph_monmap_contains(client
->monc
.monmap
,
172 EXPORT_SYMBOL(ceph_compare_options
);
174 void *ceph_kvmalloc(size_t size
, gfp_t flags
)
176 if (size
<= (PAGE_SIZE
<< PAGE_ALLOC_COSTLY_ORDER
)) {
177 void *ptr
= kmalloc(size
, flags
| __GFP_NOWARN
);
182 return __vmalloc(size
, flags
| __GFP_HIGHMEM
, PAGE_KERNEL
);
185 void ceph_kvfree(const void *ptr
)
187 if (is_vmalloc_addr(ptr
))
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 */
248 static match_table_t opt_tokens
= {
249 {Opt_osdtimeout
, "osdtimeout=%d"},
250 {Opt_osdkeepalivetimeout
, "osdkeepalive=%d"},
251 {Opt_mount_timeout
, "mount_timeout=%d"},
252 {Opt_osd_idle_ttl
, "osd_idle_ttl=%d"},
254 {Opt_fsid
, "fsid=%s"},
255 {Opt_name
, "name=%s"},
256 {Opt_secret
, "secret=%s"},
259 /* string args above */
260 {Opt_share
, "share"},
261 {Opt_noshare
, "noshare"},
263 {Opt_nocrc
, "nocrc"},
267 void ceph_destroy_options(struct ceph_options
*opt
)
269 dout("destroy_options %p\n", opt
);
272 ceph_crypto_key_destroy(opt
->key
);
275 kfree(opt
->mon_addr
);
278 EXPORT_SYMBOL(ceph_destroy_options
);
280 /* get secret from key store */
281 static int get_secret(struct ceph_crypto_key
*dst
, const char *name
) {
285 struct ceph_crypto_key
*ckey
;
287 ukey
= request_key(&key_type_ceph
, name
, NULL
);
288 if (!ukey
|| IS_ERR(ukey
)) {
289 /* request_key errors don't map nicely to mount(2)
290 errors; don't even try, but still printk */
291 key_err
= PTR_ERR(ukey
);
294 pr_warning("ceph: Mount failed due to key not found: %s\n", name
);
297 pr_warning("ceph: Mount failed due to expired key: %s\n", name
);
300 pr_warning("ceph: Mount failed due to revoked key: %s\n", name
);
303 pr_warning("ceph: Mount failed due to unknown key error"
304 " %d: %s\n", key_err
, name
);
310 ckey
= ukey
->payload
.data
;
311 err
= ceph_crypto_key_clone(dst
, ckey
);
314 /* pass through, err is 0 */
322 struct ceph_options
*
323 ceph_parse_options(char *options
, const char *dev_name
,
324 const char *dev_name_end
,
325 int (*parse_extra_token
)(char *c
, void *private),
328 struct ceph_options
*opt
;
331 substring_t argstr
[MAX_OPT_ARGS
];
333 if (current
->nsproxy
->net_ns
!= &init_net
)
334 return ERR_PTR(-EINVAL
);
336 opt
= kzalloc(sizeof(*opt
), GFP_KERNEL
);
338 return ERR_PTR(-ENOMEM
);
339 opt
->mon_addr
= kcalloc(CEPH_MAX_MON
, sizeof(*opt
->mon_addr
),
344 dout("parse_options %p options '%s' dev_name '%s'\n", opt
, options
,
347 /* start with defaults */
348 opt
->flags
= CEPH_OPT_DEFAULT
;
349 opt
->osd_keepalive_timeout
= CEPH_OSD_KEEPALIVE_DEFAULT
;
350 opt
->mount_timeout
= CEPH_MOUNT_TIMEOUT_DEFAULT
; /* seconds */
351 opt
->osd_idle_ttl
= CEPH_OSD_IDLE_TTL_DEFAULT
; /* seconds */
354 /* ip1[:port1][,ip2[:port2]...] */
355 err
= ceph_parse_ips(dev_name
, dev_name_end
, opt
->mon_addr
,
356 CEPH_MAX_MON
, &opt
->num_mon
);
360 /* parse mount options */
361 while ((c
= strsep(&options
, ",")) != NULL
) {
362 int token
, intval
, ret
;
366 token
= match_token((char *)c
, opt_tokens
, argstr
);
367 if (token
< 0 && parse_extra_token
) {
369 err
= parse_extra_token((char *)c
, private);
371 pr_err("bad option at '%s'\n", c
);
376 if (token
< Opt_last_int
) {
377 ret
= match_int(&argstr
[0], &intval
);
379 pr_err("bad mount option arg (not int) "
383 dout("got int token %d val %d\n", token
, intval
);
384 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
385 dout("got string token %d val %s\n", token
,
388 dout("got token %d\n", token
);
392 err
= ceph_parse_ips(argstr
[0].from
,
398 opt
->flags
|= CEPH_OPT_MYIP
;
402 err
= parse_fsid(argstr
[0].from
, &opt
->fsid
);
404 opt
->flags
|= CEPH_OPT_FSID
;
407 opt
->name
= kstrndup(argstr
[0].from
,
408 argstr
[0].to
-argstr
[0].from
,
412 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
417 err
= ceph_crypto_key_unarmor(opt
->key
, argstr
[0].from
);
422 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
427 err
= get_secret(opt
->key
, argstr
[0].from
);
434 pr_warning("ignoring deprecated osdtimeout option\n");
436 case Opt_osdkeepalivetimeout
:
437 opt
->osd_keepalive_timeout
= intval
;
439 case Opt_osd_idle_ttl
:
440 opt
->osd_idle_ttl
= intval
;
442 case Opt_mount_timeout
:
443 opt
->mount_timeout
= intval
;
447 opt
->flags
&= ~CEPH_OPT_NOSHARE
;
450 opt
->flags
|= CEPH_OPT_NOSHARE
;
454 opt
->flags
&= ~CEPH_OPT_NOCRC
;
457 opt
->flags
|= CEPH_OPT_NOCRC
;
469 ceph_destroy_options(opt
);
472 EXPORT_SYMBOL(ceph_parse_options
);
474 u64
ceph_client_id(struct ceph_client
*client
)
476 return client
->monc
.auth
->global_id
;
478 EXPORT_SYMBOL(ceph_client_id
);
481 * create a fresh client instance
483 struct ceph_client
*ceph_create_client(struct ceph_options
*opt
, void *private,
484 u64 supported_features
,
485 u64 required_features
)
487 struct ceph_client
*client
;
488 struct ceph_entity_addr
*myaddr
= NULL
;
491 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
493 return ERR_PTR(-ENOMEM
);
495 client
->private = private;
496 client
->options
= opt
;
498 mutex_init(&client
->mount_mutex
);
499 init_waitqueue_head(&client
->auth_wq
);
500 client
->auth_err
= 0;
502 client
->extra_mon_dispatch
= NULL
;
503 client
->supported_features
= CEPH_FEATURES_SUPPORTED_DEFAULT
|
505 client
->required_features
= CEPH_FEATURES_REQUIRED_DEFAULT
|
509 if (ceph_test_opt(client
, MYIP
))
510 myaddr
= &client
->options
->my_addr
;
511 ceph_messenger_init(&client
->msgr
, myaddr
,
512 client
->supported_features
,
513 client
->required_features
,
514 ceph_test_opt(client
, NOCRC
));
517 err
= ceph_monc_init(&client
->monc
, client
);
520 err
= ceph_osdc_init(&client
->osdc
, client
);
527 ceph_monc_stop(&client
->monc
);
532 EXPORT_SYMBOL(ceph_create_client
);
534 void ceph_destroy_client(struct ceph_client
*client
)
536 dout("destroy_client %p\n", client
);
538 atomic_set(&client
->msgr
.stopping
, 1);
541 ceph_osdc_stop(&client
->osdc
);
543 ceph_monc_stop(&client
->monc
);
545 ceph_debugfs_client_cleanup(client
);
547 ceph_destroy_options(client
->options
);
550 dout("destroy_client %p done\n", client
);
552 EXPORT_SYMBOL(ceph_destroy_client
);
555 * true if we have the mon map (and have thus joined the cluster)
557 static int have_mon_and_osd_map(struct ceph_client
*client
)
559 return client
->monc
.monmap
&& client
->monc
.monmap
->epoch
&&
560 client
->osdc
.osdmap
&& client
->osdc
.osdmap
->epoch
;
564 * mount: join the ceph cluster, and open root directory.
566 int __ceph_open_session(struct ceph_client
*client
, unsigned long started
)
569 unsigned long timeout
= client
->options
->mount_timeout
* HZ
;
571 /* open session, and wait for mon and osd maps */
572 err
= ceph_monc_open_session(&client
->monc
);
576 while (!have_mon_and_osd_map(client
)) {
578 if (timeout
&& time_after_eq(jiffies
, started
+ timeout
))
582 dout("mount waiting for mon_map\n");
583 err
= wait_event_interruptible_timeout(client
->auth_wq
,
584 have_mon_and_osd_map(client
) || (client
->auth_err
< 0),
586 if (err
== -EINTR
|| err
== -ERESTARTSYS
)
588 if (client
->auth_err
< 0)
589 return client
->auth_err
;
594 EXPORT_SYMBOL(__ceph_open_session
);
597 int ceph_open_session(struct ceph_client
*client
)
600 unsigned long started
= jiffies
; /* note the start time */
602 dout("open_session start\n");
603 mutex_lock(&client
->mount_mutex
);
605 ret
= __ceph_open_session(client
, started
);
607 mutex_unlock(&client
->mount_mutex
);
610 EXPORT_SYMBOL(ceph_open_session
);
613 static int __init
init_ceph_lib(void)
617 ret
= ceph_debugfs_init();
621 ret
= ceph_crypto_init();
625 ret
= ceph_msgr_init();
629 ret
= ceph_osdc_setup();
633 pr_info("loaded (mon/osd proto %d/%d)\n",
634 CEPH_MONC_PROTOCOL
, CEPH_OSDC_PROTOCOL
);
641 ceph_crypto_shutdown();
643 ceph_debugfs_cleanup();
648 static void __exit
exit_ceph_lib(void)
650 dout("exit_ceph_lib\n");
653 ceph_crypto_shutdown();
654 ceph_debugfs_cleanup();
657 module_init(init_ceph_lib
);
658 module_exit(exit_ceph_lib
);
660 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
661 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
662 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
663 MODULE_DESCRIPTION("Ceph filesystem for Linux");
664 MODULE_LICENSE("GPL");