1 // SPDX-License-Identifier: GPL-2.0-only
3 #include <linux/ceph/ceph_debug.h>
4 #include <linux/backing-dev.h>
5 #include <linux/ctype.h>
7 #include <linux/inet.h>
10 #include <keys/ceph-type.h>
11 #include <linux/module.h>
12 #include <linux/mount.h>
13 #include <linux/nsproxy.h>
14 #include <linux/fs_parser.h>
15 #include <linux/sched.h>
16 #include <linux/sched/mm.h>
17 #include <linux/seq_file.h>
18 #include <linux/slab.h>
19 #include <linux/statfs.h>
20 #include <linux/string.h>
21 #include <linux/vmalloc.h>
24 #include <linux/ceph/ceph_features.h>
25 #include <linux/ceph/libceph.h>
26 #include <linux/ceph/debugfs.h>
27 #include <linux/ceph/decode.h>
28 #include <linux/ceph/mon_client.h>
29 #include <linux/ceph/auth.h>
34 * Module compatibility interface. For now it doesn't do anything,
35 * but its existence signals a certain level of functionality.
37 * The data buffer is used to pass information both to and from
38 * libceph. The return value indicates whether libceph determines
39 * it is compatible with the caller (from another kernel module),
40 * given the provided data.
42 * The data pointer can be null.
44 bool libceph_compatible(void *data
)
48 EXPORT_SYMBOL(libceph_compatible
);
50 static int param_get_supported_features(char *buffer
,
51 const struct kernel_param
*kp
)
53 return sprintf(buffer
, "0x%llx", CEPH_FEATURES_SUPPORTED_DEFAULT
);
55 static const struct kernel_param_ops param_ops_supported_features
= {
56 .get
= param_get_supported_features
,
58 module_param_cb(supported_features
, ¶m_ops_supported_features
, NULL
,
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_FS_MAP_USER
: return "fs_map_user";
78 case CEPH_MSG_CLIENT_SESSION
: return "client_session";
79 case CEPH_MSG_CLIENT_RECONNECT
: return "client_reconnect";
80 case CEPH_MSG_CLIENT_REQUEST
: return "client_request";
81 case CEPH_MSG_CLIENT_REQUEST_FORWARD
: return "client_request_forward";
82 case CEPH_MSG_CLIENT_REPLY
: return "client_reply";
83 case CEPH_MSG_CLIENT_CAPS
: return "client_caps";
84 case CEPH_MSG_CLIENT_CAPRELEASE
: return "client_cap_release";
85 case CEPH_MSG_CLIENT_QUOTA
: return "client_quota";
86 case CEPH_MSG_CLIENT_SNAP
: return "client_snap";
87 case CEPH_MSG_CLIENT_LEASE
: return "client_lease";
88 case CEPH_MSG_POOLOP_REPLY
: return "poolop_reply";
89 case CEPH_MSG_POOLOP
: return "poolop";
90 case CEPH_MSG_MON_COMMAND
: return "mon_command";
91 case CEPH_MSG_MON_COMMAND_ACK
: return "mon_command_ack";
92 case CEPH_MSG_OSD_MAP
: return "osd_map";
93 case CEPH_MSG_OSD_OP
: return "osd_op";
94 case CEPH_MSG_OSD_OPREPLY
: return "osd_opreply";
95 case CEPH_MSG_WATCH_NOTIFY
: return "watch_notify";
96 case CEPH_MSG_OSD_BACKOFF
: return "osd_backoff";
97 default: return "unknown";
100 EXPORT_SYMBOL(ceph_msg_type_name
);
103 * Initially learn our fsid, or verify an fsid matches.
105 int ceph_check_fsid(struct ceph_client
*client
, struct ceph_fsid
*fsid
)
107 if (client
->have_fsid
) {
108 if (ceph_fsid_compare(&client
->fsid
, fsid
)) {
109 pr_err("bad fsid, had %pU got %pU",
110 &client
->fsid
, fsid
);
114 memcpy(&client
->fsid
, fsid
, sizeof(*fsid
));
118 EXPORT_SYMBOL(ceph_check_fsid
);
120 static int strcmp_null(const char *s1
, const char *s2
)
128 return strcmp(s1
, s2
);
131 int ceph_compare_options(struct ceph_options
*new_opt
,
132 struct ceph_client
*client
)
134 struct ceph_options
*opt1
= new_opt
;
135 struct ceph_options
*opt2
= client
->options
;
136 int ofs
= offsetof(struct ceph_options
, mon_addr
);
141 * Don't bother comparing options if network namespaces don't
144 if (!net_eq(current
->nsproxy
->net_ns
, read_pnet(&client
->msgr
.net
)))
147 ret
= memcmp(opt1
, opt2
, ofs
);
151 ret
= strcmp_null(opt1
->name
, opt2
->name
);
155 if (opt1
->key
&& !opt2
->key
)
157 if (!opt1
->key
&& opt2
->key
)
159 if (opt1
->key
&& opt2
->key
) {
160 if (opt1
->key
->type
!= opt2
->key
->type
)
162 if (opt1
->key
->created
.tv_sec
!= opt2
->key
->created
.tv_sec
)
164 if (opt1
->key
->created
.tv_nsec
!= opt2
->key
->created
.tv_nsec
)
166 if (opt1
->key
->len
!= opt2
->key
->len
)
168 if (opt1
->key
->key
&& !opt2
->key
->key
)
170 if (!opt1
->key
->key
&& opt2
->key
->key
)
172 if (opt1
->key
->key
&& opt2
->key
->key
) {
173 ret
= memcmp(opt1
->key
->key
, opt2
->key
->key
, opt1
->key
->len
);
179 /* any matching mon ip implies a match */
180 for (i
= 0; i
< opt1
->num_mon
; i
++) {
181 if (ceph_monmap_contains(client
->monc
.monmap
,
187 EXPORT_SYMBOL(ceph_compare_options
);
190 * kvmalloc() doesn't fall back to the vmalloc allocator unless flags are
191 * compatible with (a superset of) GFP_KERNEL. This is because while the
192 * actual pages are allocated with the specified flags, the page table pages
193 * are always allocated with GFP_KERNEL.
195 * ceph_kvmalloc() may be called with GFP_KERNEL, GFP_NOFS or GFP_NOIO.
197 void *ceph_kvmalloc(size_t size
, gfp_t flags
)
201 if ((flags
& (__GFP_IO
| __GFP_FS
)) == (__GFP_IO
| __GFP_FS
)) {
202 p
= kvmalloc(size
, flags
);
203 } else if ((flags
& (__GFP_IO
| __GFP_FS
)) == __GFP_IO
) {
204 unsigned int nofs_flag
= memalloc_nofs_save();
205 p
= kvmalloc(size
, GFP_KERNEL
);
206 memalloc_nofs_restore(nofs_flag
);
208 unsigned int noio_flag
= memalloc_noio_save();
209 p
= kvmalloc(size
, GFP_KERNEL
);
210 memalloc_noio_restore(noio_flag
);
216 static int parse_fsid(const char *str
, struct ceph_fsid
*fsid
)
223 dout("parse_fsid '%s'\n", str
);
225 while (*str
&& i
< 16) {
230 if (!isxdigit(str
[0]) || !isxdigit(str
[1]))
234 if (sscanf(tmp
, "%x", &d
) < 1)
236 fsid
->fsid
[i
] = d
& 0xff;
243 dout("parse_fsid ret %d got fsid %pU\n", err
, fsid
);
252 Opt_osdkeepalivetimeout
,
255 Opt_osd_request_timeout
,
262 /* string args above */
265 Opt_cephx_require_signatures
,
266 Opt_cephx_sign_messages
,
271 static const struct fs_parameter_spec ceph_parameters
[] = {
272 fsparam_flag ("abort_on_full", Opt_abort_on_full
),
273 fsparam_flag_no ("cephx_require_signatures", Opt_cephx_require_signatures
),
274 fsparam_flag_no ("cephx_sign_messages", Opt_cephx_sign_messages
),
275 fsparam_flag_no ("crc", Opt_crc
),
276 fsparam_string ("fsid", Opt_fsid
),
277 fsparam_string ("ip", Opt_ip
),
278 fsparam_string ("key", Opt_key
),
279 fsparam_u32 ("mount_timeout", Opt_mount_timeout
),
280 fsparam_string ("name", Opt_name
),
281 fsparam_u32 ("osd_idle_ttl", Opt_osd_idle_ttl
),
282 fsparam_u32 ("osd_request_timeout", Opt_osd_request_timeout
),
283 fsparam_u32 ("osdkeepalive", Opt_osdkeepalivetimeout
),
284 __fsparam (fs_param_is_s32
, "osdtimeout", Opt_osdtimeout
,
285 fs_param_deprecated
, NULL
),
286 fsparam_string ("secret", Opt_secret
),
287 fsparam_flag_no ("share", Opt_share
),
288 fsparam_flag_no ("tcp_nodelay", Opt_tcp_nodelay
),
292 struct ceph_options
*ceph_alloc_options(void)
294 struct ceph_options
*opt
;
296 opt
= kzalloc(sizeof(*opt
), GFP_KERNEL
);
300 opt
->mon_addr
= kcalloc(CEPH_MAX_MON
, sizeof(*opt
->mon_addr
),
302 if (!opt
->mon_addr
) {
307 opt
->flags
= CEPH_OPT_DEFAULT
;
308 opt
->osd_keepalive_timeout
= CEPH_OSD_KEEPALIVE_DEFAULT
;
309 opt
->mount_timeout
= CEPH_MOUNT_TIMEOUT_DEFAULT
;
310 opt
->osd_idle_ttl
= CEPH_OSD_IDLE_TTL_DEFAULT
;
311 opt
->osd_request_timeout
= CEPH_OSD_REQUEST_TIMEOUT_DEFAULT
;
314 EXPORT_SYMBOL(ceph_alloc_options
);
316 void ceph_destroy_options(struct ceph_options
*opt
)
318 dout("destroy_options %p\n", opt
);
324 ceph_crypto_key_destroy(opt
->key
);
327 kfree(opt
->mon_addr
);
330 EXPORT_SYMBOL(ceph_destroy_options
);
332 /* get secret from key store */
333 static int get_secret(struct ceph_crypto_key
*dst
, const char *name
,
339 struct ceph_crypto_key
*ckey
;
341 ukey
= request_key(&key_type_ceph
, name
, NULL
);
343 /* request_key errors don't map nicely to mount(2)
344 errors; don't even try, but still printk */
345 key_err
= PTR_ERR(ukey
);
348 error_plog(log
, "Failed due to key not found: %s",
352 error_plog(log
, "Failed due to expired key: %s",
356 error_plog(log
, "Failed due to revoked key: %s",
360 error_plog(log
, "Failed due to key error %d: %s",
367 ckey
= ukey
->payload
.data
[0];
368 err
= ceph_crypto_key_clone(dst
, ckey
);
371 /* pass through, err is 0 */
379 int ceph_parse_mon_ips(const char *buf
, size_t len
, struct ceph_options
*opt
,
382 struct p_log log
= {.prefix
= "libceph", .log
= l
};
385 /* ip1[:port1][,ip2[:port2]...] */
386 ret
= ceph_parse_ips(buf
, buf
+ len
, opt
->mon_addr
, CEPH_MAX_MON
,
389 error_plog(&log
, "Failed to parse monitor IPs: %d", ret
);
395 EXPORT_SYMBOL(ceph_parse_mon_ips
);
397 int ceph_parse_param(struct fs_parameter
*param
, struct ceph_options
*opt
,
400 struct fs_parse_result result
;
402 struct p_log log
= {.prefix
= "libceph", .log
= l
};
404 token
= __fs_parse(&log
, ceph_parameters
, param
, &result
);
405 dout("%s fs_parse '%s' token %d\n", __func__
, param
->key
, token
);
411 err
= ceph_parse_ips(param
->string
,
412 param
->string
+ param
->size
,
416 error_plog(&log
, "Failed to parse ip: %d", err
);
419 opt
->flags
|= CEPH_OPT_MYIP
;
423 err
= parse_fsid(param
->string
, &opt
->fsid
);
425 error_plog(&log
, "Failed to parse fsid: %d", err
);
428 opt
->flags
|= CEPH_OPT_FSID
;
432 opt
->name
= param
->string
;
433 param
->string
= NULL
;
436 ceph_crypto_key_destroy(opt
->key
);
439 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
442 err
= ceph_crypto_key_unarmor(opt
->key
, param
->string
);
444 error_plog(&log
, "Failed to parse secret: %d", err
);
449 ceph_crypto_key_destroy(opt
->key
);
452 opt
->key
= kzalloc(sizeof(*opt
->key
), GFP_KERNEL
);
455 return get_secret(opt
->key
, param
->string
, &log
);
458 warn_plog(&log
, "Ignoring osdtimeout");
460 case Opt_osdkeepalivetimeout
:
461 /* 0 isn't well defined right now, reject it */
462 if (result
.uint_32
< 1 || result
.uint_32
> INT_MAX
/ 1000)
464 opt
->osd_keepalive_timeout
=
465 msecs_to_jiffies(result
.uint_32
* 1000);
467 case Opt_osd_idle_ttl
:
468 /* 0 isn't well defined right now, reject it */
469 if (result
.uint_32
< 1 || result
.uint_32
> INT_MAX
/ 1000)
471 opt
->osd_idle_ttl
= msecs_to_jiffies(result
.uint_32
* 1000);
473 case Opt_mount_timeout
:
474 /* 0 is "wait forever" (i.e. infinite timeout) */
475 if (result
.uint_32
> INT_MAX
/ 1000)
477 opt
->mount_timeout
= msecs_to_jiffies(result
.uint_32
* 1000);
479 case Opt_osd_request_timeout
:
480 /* 0 is "wait forever" (i.e. infinite timeout) */
481 if (result
.uint_32
> INT_MAX
/ 1000)
483 opt
->osd_request_timeout
=
484 msecs_to_jiffies(result
.uint_32
* 1000);
489 opt
->flags
&= ~CEPH_OPT_NOSHARE
;
491 opt
->flags
|= CEPH_OPT_NOSHARE
;
495 opt
->flags
&= ~CEPH_OPT_NOCRC
;
497 opt
->flags
|= CEPH_OPT_NOCRC
;
499 case Opt_cephx_require_signatures
:
501 opt
->flags
&= ~CEPH_OPT_NOMSGAUTH
;
503 opt
->flags
|= CEPH_OPT_NOMSGAUTH
;
505 case Opt_cephx_sign_messages
:
507 opt
->flags
&= ~CEPH_OPT_NOMSGSIGN
;
509 opt
->flags
|= CEPH_OPT_NOMSGSIGN
;
511 case Opt_tcp_nodelay
:
513 opt
->flags
|= CEPH_OPT_TCP_NODELAY
;
515 opt
->flags
&= ~CEPH_OPT_TCP_NODELAY
;
518 case Opt_abort_on_full
:
519 opt
->flags
|= CEPH_OPT_ABORT_ON_FULL
;
529 return inval_plog(&log
, "%s out of range", param
->key
);
531 EXPORT_SYMBOL(ceph_parse_param
);
533 int ceph_print_client_options(struct seq_file
*m
, struct ceph_client
*client
,
536 struct ceph_options
*opt
= client
->options
;
537 size_t pos
= m
->count
;
540 seq_puts(m
, "name=");
541 seq_escape(m
, opt
->name
, ", \t\n\\");
545 seq_puts(m
, "secret=<hidden>,");
547 if (opt
->flags
& CEPH_OPT_FSID
)
548 seq_printf(m
, "fsid=%pU,", &opt
->fsid
);
549 if (opt
->flags
& CEPH_OPT_NOSHARE
)
550 seq_puts(m
, "noshare,");
551 if (opt
->flags
& CEPH_OPT_NOCRC
)
552 seq_puts(m
, "nocrc,");
553 if (opt
->flags
& CEPH_OPT_NOMSGAUTH
)
554 seq_puts(m
, "nocephx_require_signatures,");
555 if (opt
->flags
& CEPH_OPT_NOMSGSIGN
)
556 seq_puts(m
, "nocephx_sign_messages,");
557 if ((opt
->flags
& CEPH_OPT_TCP_NODELAY
) == 0)
558 seq_puts(m
, "notcp_nodelay,");
559 if (show_all
&& (opt
->flags
& CEPH_OPT_ABORT_ON_FULL
))
560 seq_puts(m
, "abort_on_full,");
562 if (opt
->mount_timeout
!= CEPH_MOUNT_TIMEOUT_DEFAULT
)
563 seq_printf(m
, "mount_timeout=%d,",
564 jiffies_to_msecs(opt
->mount_timeout
) / 1000);
565 if (opt
->osd_idle_ttl
!= CEPH_OSD_IDLE_TTL_DEFAULT
)
566 seq_printf(m
, "osd_idle_ttl=%d,",
567 jiffies_to_msecs(opt
->osd_idle_ttl
) / 1000);
568 if (opt
->osd_keepalive_timeout
!= CEPH_OSD_KEEPALIVE_DEFAULT
)
569 seq_printf(m
, "osdkeepalivetimeout=%d,",
570 jiffies_to_msecs(opt
->osd_keepalive_timeout
) / 1000);
571 if (opt
->osd_request_timeout
!= CEPH_OSD_REQUEST_TIMEOUT_DEFAULT
)
572 seq_printf(m
, "osd_request_timeout=%d,",
573 jiffies_to_msecs(opt
->osd_request_timeout
) / 1000);
575 /* drop redundant comma */
581 EXPORT_SYMBOL(ceph_print_client_options
);
583 struct ceph_entity_addr
*ceph_client_addr(struct ceph_client
*client
)
585 return &client
->msgr
.inst
.addr
;
587 EXPORT_SYMBOL(ceph_client_addr
);
589 u64
ceph_client_gid(struct ceph_client
*client
)
591 return client
->monc
.auth
->global_id
;
593 EXPORT_SYMBOL(ceph_client_gid
);
596 * create a fresh client instance
598 struct ceph_client
*ceph_create_client(struct ceph_options
*opt
, void *private)
600 struct ceph_client
*client
;
601 struct ceph_entity_addr
*myaddr
= NULL
;
604 err
= wait_for_random_bytes();
608 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
610 return ERR_PTR(-ENOMEM
);
612 client
->private = private;
613 client
->options
= opt
;
615 mutex_init(&client
->mount_mutex
);
616 init_waitqueue_head(&client
->auth_wq
);
617 client
->auth_err
= 0;
619 client
->extra_mon_dispatch
= NULL
;
620 client
->supported_features
= CEPH_FEATURES_SUPPORTED_DEFAULT
;
621 client
->required_features
= CEPH_FEATURES_REQUIRED_DEFAULT
;
623 if (!ceph_test_opt(client
, NOMSGAUTH
))
624 client
->required_features
|= CEPH_FEATURE_MSG_AUTH
;
627 if (ceph_test_opt(client
, MYIP
))
628 myaddr
= &client
->options
->my_addr
;
630 ceph_messenger_init(&client
->msgr
, myaddr
);
633 err
= ceph_monc_init(&client
->monc
, client
);
636 err
= ceph_osdc_init(&client
->osdc
, client
);
643 ceph_monc_stop(&client
->monc
);
645 ceph_messenger_fini(&client
->msgr
);
649 EXPORT_SYMBOL(ceph_create_client
);
651 void ceph_destroy_client(struct ceph_client
*client
)
653 dout("destroy_client %p\n", client
);
655 atomic_set(&client
->msgr
.stopping
, 1);
658 ceph_osdc_stop(&client
->osdc
);
659 ceph_monc_stop(&client
->monc
);
660 ceph_messenger_fini(&client
->msgr
);
662 ceph_debugfs_client_cleanup(client
);
664 ceph_destroy_options(client
->options
);
667 dout("destroy_client %p done\n", client
);
669 EXPORT_SYMBOL(ceph_destroy_client
);
671 void ceph_reset_client_addr(struct ceph_client
*client
)
673 ceph_messenger_reset_nonce(&client
->msgr
);
674 ceph_monc_reopen_session(&client
->monc
);
675 ceph_osdc_reopen_osds(&client
->osdc
);
677 EXPORT_SYMBOL(ceph_reset_client_addr
);
680 * true if we have the mon map (and have thus joined the cluster)
682 static bool have_mon_and_osd_map(struct ceph_client
*client
)
684 return client
->monc
.monmap
&& client
->monc
.monmap
->epoch
&&
685 client
->osdc
.osdmap
&& client
->osdc
.osdmap
->epoch
;
689 * mount: join the ceph cluster, and open root directory.
691 int __ceph_open_session(struct ceph_client
*client
, unsigned long started
)
693 unsigned long timeout
= client
->options
->mount_timeout
;
696 /* open session, and wait for mon and osd maps */
697 err
= ceph_monc_open_session(&client
->monc
);
701 while (!have_mon_and_osd_map(client
)) {
702 if (timeout
&& time_after_eq(jiffies
, started
+ timeout
))
706 dout("mount waiting for mon_map\n");
707 err
= wait_event_interruptible_timeout(client
->auth_wq
,
708 have_mon_and_osd_map(client
) || (client
->auth_err
< 0),
709 ceph_timeout_jiffies(timeout
));
712 if (client
->auth_err
< 0)
713 return client
->auth_err
;
716 pr_info("client%llu fsid %pU\n", ceph_client_gid(client
),
718 ceph_debugfs_client_init(client
);
722 EXPORT_SYMBOL(__ceph_open_session
);
724 int ceph_open_session(struct ceph_client
*client
)
727 unsigned long started
= jiffies
; /* note the start time */
729 dout("open_session start\n");
730 mutex_lock(&client
->mount_mutex
);
732 ret
= __ceph_open_session(client
, started
);
734 mutex_unlock(&client
->mount_mutex
);
737 EXPORT_SYMBOL(ceph_open_session
);
739 int ceph_wait_for_latest_osdmap(struct ceph_client
*client
,
740 unsigned long timeout
)
745 ret
= ceph_monc_get_version(&client
->monc
, "osdmap", &newest_epoch
);
749 if (client
->osdc
.osdmap
->epoch
>= newest_epoch
)
752 ceph_osdc_maybe_request_map(&client
->osdc
);
753 return ceph_monc_wait_osdmap(&client
->monc
, newest_epoch
, timeout
);
755 EXPORT_SYMBOL(ceph_wait_for_latest_osdmap
);
757 static int __init
init_ceph_lib(void)
763 ret
= ceph_crypto_init();
767 ret
= ceph_msgr_init();
771 ret
= ceph_osdc_setup();
775 pr_info("loaded (mon/osd proto %d/%d)\n",
776 CEPH_MONC_PROTOCOL
, CEPH_OSDC_PROTOCOL
);
783 ceph_crypto_shutdown();
785 ceph_debugfs_cleanup();
789 static void __exit
exit_ceph_lib(void)
791 dout("exit_ceph_lib\n");
792 WARN_ON(!ceph_strings_empty());
796 ceph_crypto_shutdown();
797 ceph_debugfs_cleanup();
800 module_init(init_ceph_lib
);
801 module_exit(exit_ceph_lib
);
803 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
804 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
805 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
806 MODULE_DESCRIPTION("Ceph core library");
807 MODULE_LICENSE("GPL");