xref: /openbmc/linux/net/ceph/ceph_common.c (revision 6774def6)
1 
2 #include <linux/ceph/ceph_debug.h>
3 #include <linux/backing-dev.h>
4 #include <linux/ctype.h>
5 #include <linux/fs.h>
6 #include <linux/inet.h>
7 #include <linux/in6.h>
8 #include <linux/key.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>
21 
22 
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>
29 #include "crypto.h"
30 
31 
32 /*
33  * Module compatibility interface.  For now it doesn't do anything,
34  * but its existence signals a certain level of functionality.
35  *
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.
40  *
41  * The data pointer can be null.
42  */
43 bool libceph_compatible(void *data)
44 {
45 	return true;
46 }
47 EXPORT_SYMBOL(libceph_compatible);
48 
49 /*
50  * find filename portion of a path (/foo/bar/baz -> baz)
51  */
52 const char *ceph_file_part(const char *s, int len)
53 {
54 	const char *e = s + len;
55 
56 	while (e != s && *(e-1) != '/')
57 		e--;
58 	return e;
59 }
60 EXPORT_SYMBOL(ceph_file_part);
61 
62 const char *ceph_msg_type_name(int type)
63 {
64 	switch (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_MON_GET_VERSION: return "mon_get_version";
76 	case CEPH_MSG_MON_GET_VERSION_REPLY: return "mon_get_version_reply";
77 	case CEPH_MSG_MDS_MAP: return "mds_map";
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_SNAP: return "client_snap";
86 	case CEPH_MSG_CLIENT_LEASE: return "client_lease";
87 	case CEPH_MSG_OSD_MAP: return "osd_map";
88 	case CEPH_MSG_OSD_OP: return "osd_op";
89 	case CEPH_MSG_OSD_OPREPLY: return "osd_opreply";
90 	case CEPH_MSG_WATCH_NOTIFY: return "watch_notify";
91 	default: return "unknown";
92 	}
93 }
94 EXPORT_SYMBOL(ceph_msg_type_name);
95 
96 /*
97  * Initially learn our fsid, or verify an fsid matches.
98  */
99 int ceph_check_fsid(struct ceph_client *client, struct ceph_fsid *fsid)
100 {
101 	if (client->have_fsid) {
102 		if (ceph_fsid_compare(&client->fsid, fsid)) {
103 			pr_err("bad fsid, had %pU got %pU",
104 			       &client->fsid, fsid);
105 			return -1;
106 		}
107 	} else {
108 		memcpy(&client->fsid, fsid, sizeof(*fsid));
109 	}
110 	return 0;
111 }
112 EXPORT_SYMBOL(ceph_check_fsid);
113 
114 static int strcmp_null(const char *s1, const char *s2)
115 {
116 	if (!s1 && !s2)
117 		return 0;
118 	if (s1 && !s2)
119 		return -1;
120 	if (!s1 && s2)
121 		return 1;
122 	return strcmp(s1, s2);
123 }
124 
125 int ceph_compare_options(struct ceph_options *new_opt,
126 			 struct ceph_client *client)
127 {
128 	struct ceph_options *opt1 = new_opt;
129 	struct ceph_options *opt2 = client->options;
130 	int ofs = offsetof(struct ceph_options, mon_addr);
131 	int i;
132 	int ret;
133 
134 	ret = memcmp(opt1, opt2, ofs);
135 	if (ret)
136 		return ret;
137 
138 	ret = strcmp_null(opt1->name, opt2->name);
139 	if (ret)
140 		return ret;
141 
142 	if (opt1->key && !opt2->key)
143 		return -1;
144 	if (!opt1->key && opt2->key)
145 		return 1;
146 	if (opt1->key && opt2->key) {
147 		if (opt1->key->type != opt2->key->type)
148 			return -1;
149 		if (opt1->key->created.tv_sec != opt2->key->created.tv_sec)
150 			return -1;
151 		if (opt1->key->created.tv_nsec != opt2->key->created.tv_nsec)
152 			return -1;
153 		if (opt1->key->len != opt2->key->len)
154 			return -1;
155 		if (opt1->key->key && !opt2->key->key)
156 			return -1;
157 		if (!opt1->key->key && opt2->key->key)
158 			return 1;
159 		if (opt1->key->key && opt2->key->key) {
160 			ret = memcmp(opt1->key->key, opt2->key->key, opt1->key->len);
161 			if (ret)
162 				return ret;
163 		}
164 	}
165 
166 	/* any matching mon ip implies a match */
167 	for (i = 0; i < opt1->num_mon; i++) {
168 		if (ceph_monmap_contains(client->monc.monmap,
169 				 &opt1->mon_addr[i]))
170 			return 0;
171 	}
172 	return -1;
173 }
174 EXPORT_SYMBOL(ceph_compare_options);
175 
176 void *ceph_kvmalloc(size_t size, gfp_t flags)
177 {
178 	if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
179 		void *ptr = kmalloc(size, flags | __GFP_NOWARN);
180 		if (ptr)
181 			return ptr;
182 	}
183 
184 	return __vmalloc(size, flags | __GFP_HIGHMEM, PAGE_KERNEL);
185 }
186 
187 void ceph_kvfree(const void *ptr)
188 {
189 	if (is_vmalloc_addr(ptr))
190 		vfree(ptr);
191 	else
192 		kfree(ptr);
193 }
194 
195 
196 static int parse_fsid(const char *str, struct ceph_fsid *fsid)
197 {
198 	int i = 0;
199 	char tmp[3];
200 	int err = -EINVAL;
201 	int d;
202 
203 	dout("parse_fsid '%s'\n", str);
204 	tmp[2] = 0;
205 	while (*str && i < 16) {
206 		if (ispunct(*str)) {
207 			str++;
208 			continue;
209 		}
210 		if (!isxdigit(str[0]) || !isxdigit(str[1]))
211 			break;
212 		tmp[0] = str[0];
213 		tmp[1] = str[1];
214 		if (sscanf(tmp, "%x", &d) < 1)
215 			break;
216 		fsid->fsid[i] = d & 0xff;
217 		i++;
218 		str += 2;
219 	}
220 
221 	if (i == 16)
222 		err = 0;
223 	dout("parse_fsid ret %d got fsid %pU", err, fsid);
224 	return err;
225 }
226 
227 /*
228  * ceph options
229  */
230 enum {
231 	Opt_osdtimeout,
232 	Opt_osdkeepalivetimeout,
233 	Opt_mount_timeout,
234 	Opt_osd_idle_ttl,
235 	Opt_last_int,
236 	/* int args above */
237 	Opt_fsid,
238 	Opt_name,
239 	Opt_secret,
240 	Opt_key,
241 	Opt_ip,
242 	Opt_last_string,
243 	/* string args above */
244 	Opt_share,
245 	Opt_noshare,
246 	Opt_crc,
247 	Opt_nocrc,
248 };
249 
250 static match_table_t opt_tokens = {
251 	{Opt_osdtimeout, "osdtimeout=%d"},
252 	{Opt_osdkeepalivetimeout, "osdkeepalive=%d"},
253 	{Opt_mount_timeout, "mount_timeout=%d"},
254 	{Opt_osd_idle_ttl, "osd_idle_ttl=%d"},
255 	/* int args above */
256 	{Opt_fsid, "fsid=%s"},
257 	{Opt_name, "name=%s"},
258 	{Opt_secret, "secret=%s"},
259 	{Opt_key, "key=%s"},
260 	{Opt_ip, "ip=%s"},
261 	/* string args above */
262 	{Opt_share, "share"},
263 	{Opt_noshare, "noshare"},
264 	{Opt_crc, "crc"},
265 	{Opt_nocrc, "nocrc"},
266 	{-1, NULL}
267 };
268 
269 void ceph_destroy_options(struct ceph_options *opt)
270 {
271 	dout("destroy_options %p\n", opt);
272 	kfree(opt->name);
273 	if (opt->key) {
274 		ceph_crypto_key_destroy(opt->key);
275 		kfree(opt->key);
276 	}
277 	kfree(opt->mon_addr);
278 	kfree(opt);
279 }
280 EXPORT_SYMBOL(ceph_destroy_options);
281 
282 /* get secret from key store */
283 static int get_secret(struct ceph_crypto_key *dst, const char *name) {
284 	struct key *ukey;
285 	int key_err;
286 	int err = 0;
287 	struct ceph_crypto_key *ckey;
288 
289 	ukey = request_key(&key_type_ceph, name, NULL);
290 	if (!ukey || IS_ERR(ukey)) {
291 		/* request_key errors don't map nicely to mount(2)
292 		   errors; don't even try, but still printk */
293 		key_err = PTR_ERR(ukey);
294 		switch (key_err) {
295 		case -ENOKEY:
296 			pr_warn("ceph: Mount failed due to key not found: %s\n",
297 				name);
298 			break;
299 		case -EKEYEXPIRED:
300 			pr_warn("ceph: Mount failed due to expired key: %s\n",
301 				name);
302 			break;
303 		case -EKEYREVOKED:
304 			pr_warn("ceph: Mount failed due to revoked key: %s\n",
305 				name);
306 			break;
307 		default:
308 			pr_warn("ceph: Mount failed due to unknown key error %d: %s\n",
309 				key_err, name);
310 		}
311 		err = -EPERM;
312 		goto out;
313 	}
314 
315 	ckey = ukey->payload.data;
316 	err = ceph_crypto_key_clone(dst, ckey);
317 	if (err)
318 		goto out_key;
319 	/* pass through, err is 0 */
320 
321 out_key:
322 	key_put(ukey);
323 out:
324 	return err;
325 }
326 
327 struct ceph_options *
328 ceph_parse_options(char *options, const char *dev_name,
329 			const char *dev_name_end,
330 			int (*parse_extra_token)(char *c, void *private),
331 			void *private)
332 {
333 	struct ceph_options *opt;
334 	const char *c;
335 	int err = -ENOMEM;
336 	substring_t argstr[MAX_OPT_ARGS];
337 
338 	if (current->nsproxy->net_ns != &init_net)
339 		return ERR_PTR(-EINVAL);
340 
341 	opt = kzalloc(sizeof(*opt), GFP_KERNEL);
342 	if (!opt)
343 		return ERR_PTR(-ENOMEM);
344 	opt->mon_addr = kcalloc(CEPH_MAX_MON, sizeof(*opt->mon_addr),
345 				GFP_KERNEL);
346 	if (!opt->mon_addr)
347 		goto out;
348 
349 	dout("parse_options %p options '%s' dev_name '%s'\n", opt, options,
350 	     dev_name);
351 
352 	/* start with defaults */
353 	opt->flags = CEPH_OPT_DEFAULT;
354 	opt->osd_keepalive_timeout = CEPH_OSD_KEEPALIVE_DEFAULT;
355 	opt->mount_timeout = CEPH_MOUNT_TIMEOUT_DEFAULT; /* seconds */
356 	opt->osd_idle_ttl = CEPH_OSD_IDLE_TTL_DEFAULT;   /* seconds */
357 
358 	/* get mon ip(s) */
359 	/* ip1[:port1][,ip2[:port2]...] */
360 	err = ceph_parse_ips(dev_name, dev_name_end, opt->mon_addr,
361 			     CEPH_MAX_MON, &opt->num_mon);
362 	if (err < 0)
363 		goto out;
364 
365 	/* parse mount options */
366 	while ((c = strsep(&options, ",")) != NULL) {
367 		int token, intval, ret;
368 		if (!*c)
369 			continue;
370 		err = -EINVAL;
371 		token = match_token((char *)c, opt_tokens, argstr);
372 		if (token < 0 && parse_extra_token) {
373 			/* extra? */
374 			err = parse_extra_token((char *)c, private);
375 			if (err < 0) {
376 				pr_err("bad option at '%s'\n", c);
377 				goto out;
378 			}
379 			continue;
380 		}
381 		if (token < Opt_last_int) {
382 			ret = match_int(&argstr[0], &intval);
383 			if (ret < 0) {
384 				pr_err("bad mount option arg (not int) "
385 				       "at '%s'\n", c);
386 				continue;
387 			}
388 			dout("got int token %d val %d\n", token, intval);
389 		} else if (token > Opt_last_int && token < Opt_last_string) {
390 			dout("got string token %d val %s\n", token,
391 			     argstr[0].from);
392 		} else {
393 			dout("got token %d\n", token);
394 		}
395 		switch (token) {
396 		case Opt_ip:
397 			err = ceph_parse_ips(argstr[0].from,
398 					     argstr[0].to,
399 					     &opt->my_addr,
400 					     1, NULL);
401 			if (err < 0)
402 				goto out;
403 			opt->flags |= CEPH_OPT_MYIP;
404 			break;
405 
406 		case Opt_fsid:
407 			err = parse_fsid(argstr[0].from, &opt->fsid);
408 			if (err == 0)
409 				opt->flags |= CEPH_OPT_FSID;
410 			break;
411 		case Opt_name:
412 			opt->name = kstrndup(argstr[0].from,
413 					      argstr[0].to-argstr[0].from,
414 					      GFP_KERNEL);
415 			break;
416 		case Opt_secret:
417 		        opt->key = kzalloc(sizeof(*opt->key), GFP_KERNEL);
418 			if (!opt->key) {
419 				err = -ENOMEM;
420 				goto out;
421 			}
422 			err = ceph_crypto_key_unarmor(opt->key, argstr[0].from);
423 			if (err < 0)
424 				goto out;
425 			break;
426 		case Opt_key:
427 		        opt->key = kzalloc(sizeof(*opt->key), GFP_KERNEL);
428 			if (!opt->key) {
429 				err = -ENOMEM;
430 				goto out;
431 			}
432 			err = get_secret(opt->key, argstr[0].from);
433 			if (err < 0)
434 				goto out;
435 			break;
436 
437 			/* misc */
438 		case Opt_osdtimeout:
439 			pr_warn("ignoring deprecated osdtimeout option\n");
440 			break;
441 		case Opt_osdkeepalivetimeout:
442 			opt->osd_keepalive_timeout = intval;
443 			break;
444 		case Opt_osd_idle_ttl:
445 			opt->osd_idle_ttl = intval;
446 			break;
447 		case Opt_mount_timeout:
448 			opt->mount_timeout = intval;
449 			break;
450 
451 		case Opt_share:
452 			opt->flags &= ~CEPH_OPT_NOSHARE;
453 			break;
454 		case Opt_noshare:
455 			opt->flags |= CEPH_OPT_NOSHARE;
456 			break;
457 
458 		case Opt_crc:
459 			opt->flags &= ~CEPH_OPT_NOCRC;
460 			break;
461 		case Opt_nocrc:
462 			opt->flags |= CEPH_OPT_NOCRC;
463 			break;
464 
465 		default:
466 			BUG_ON(token);
467 		}
468 	}
469 
470 	/* success */
471 	return opt;
472 
473 out:
474 	ceph_destroy_options(opt);
475 	return ERR_PTR(err);
476 }
477 EXPORT_SYMBOL(ceph_parse_options);
478 
479 u64 ceph_client_id(struct ceph_client *client)
480 {
481 	return client->monc.auth->global_id;
482 }
483 EXPORT_SYMBOL(ceph_client_id);
484 
485 /*
486  * create a fresh client instance
487  */
488 struct ceph_client *ceph_create_client(struct ceph_options *opt, void *private,
489 				       u64 supported_features,
490 				       u64 required_features)
491 {
492 	struct ceph_client *client;
493 	struct ceph_entity_addr *myaddr = NULL;
494 	int err = -ENOMEM;
495 
496 	client = kzalloc(sizeof(*client), GFP_KERNEL);
497 	if (client == NULL)
498 		return ERR_PTR(-ENOMEM);
499 
500 	client->private = private;
501 	client->options = opt;
502 
503 	mutex_init(&client->mount_mutex);
504 	init_waitqueue_head(&client->auth_wq);
505 	client->auth_err = 0;
506 
507 	client->extra_mon_dispatch = NULL;
508 	client->supported_features = CEPH_FEATURES_SUPPORTED_DEFAULT |
509 		supported_features;
510 	client->required_features = CEPH_FEATURES_REQUIRED_DEFAULT |
511 		required_features;
512 
513 	/* msgr */
514 	if (ceph_test_opt(client, MYIP))
515 		myaddr = &client->options->my_addr;
516 	ceph_messenger_init(&client->msgr, myaddr,
517 		client->supported_features,
518 		client->required_features,
519 		ceph_test_opt(client, NOCRC));
520 
521 	/* subsystems */
522 	err = ceph_monc_init(&client->monc, client);
523 	if (err < 0)
524 		goto fail;
525 	err = ceph_osdc_init(&client->osdc, client);
526 	if (err < 0)
527 		goto fail_monc;
528 
529 	return client;
530 
531 fail_monc:
532 	ceph_monc_stop(&client->monc);
533 fail:
534 	kfree(client);
535 	return ERR_PTR(err);
536 }
537 EXPORT_SYMBOL(ceph_create_client);
538 
539 void ceph_destroy_client(struct ceph_client *client)
540 {
541 	dout("destroy_client %p\n", client);
542 
543 	atomic_set(&client->msgr.stopping, 1);
544 
545 	/* unmount */
546 	ceph_osdc_stop(&client->osdc);
547 
548 	ceph_monc_stop(&client->monc);
549 
550 	ceph_debugfs_client_cleanup(client);
551 
552 	ceph_destroy_options(client->options);
553 
554 	kfree(client);
555 	dout("destroy_client %p done\n", client);
556 }
557 EXPORT_SYMBOL(ceph_destroy_client);
558 
559 /*
560  * true if we have the mon map (and have thus joined the cluster)
561  */
562 static int have_mon_and_osd_map(struct ceph_client *client)
563 {
564 	return client->monc.monmap && client->monc.monmap->epoch &&
565 	       client->osdc.osdmap && client->osdc.osdmap->epoch;
566 }
567 
568 /*
569  * mount: join the ceph cluster, and open root directory.
570  */
571 int __ceph_open_session(struct ceph_client *client, unsigned long started)
572 {
573 	int err;
574 	unsigned long timeout = client->options->mount_timeout * HZ;
575 
576 	/* open session, and wait for mon and osd maps */
577 	err = ceph_monc_open_session(&client->monc);
578 	if (err < 0)
579 		return err;
580 
581 	while (!have_mon_and_osd_map(client)) {
582 		err = -EIO;
583 		if (timeout && time_after_eq(jiffies, started + timeout))
584 			return err;
585 
586 		/* wait */
587 		dout("mount waiting for mon_map\n");
588 		err = wait_event_interruptible_timeout(client->auth_wq,
589 			have_mon_and_osd_map(client) || (client->auth_err < 0),
590 			timeout);
591 		if (err == -EINTR || err == -ERESTARTSYS)
592 			return err;
593 		if (client->auth_err < 0)
594 			return client->auth_err;
595 	}
596 
597 	return 0;
598 }
599 EXPORT_SYMBOL(__ceph_open_session);
600 
601 
602 int ceph_open_session(struct ceph_client *client)
603 {
604 	int ret;
605 	unsigned long started = jiffies;  /* note the start time */
606 
607 	dout("open_session start\n");
608 	mutex_lock(&client->mount_mutex);
609 
610 	ret = __ceph_open_session(client, started);
611 
612 	mutex_unlock(&client->mount_mutex);
613 	return ret;
614 }
615 EXPORT_SYMBOL(ceph_open_session);
616 
617 
618 static int __init init_ceph_lib(void)
619 {
620 	int ret = 0;
621 
622 	ret = ceph_debugfs_init();
623 	if (ret < 0)
624 		goto out;
625 
626 	ret = ceph_crypto_init();
627 	if (ret < 0)
628 		goto out_debugfs;
629 
630 	ret = ceph_msgr_init();
631 	if (ret < 0)
632 		goto out_crypto;
633 
634 	ret = ceph_osdc_setup();
635 	if (ret < 0)
636 		goto out_msgr;
637 
638 	pr_info("loaded (mon/osd proto %d/%d)\n",
639 		CEPH_MONC_PROTOCOL, CEPH_OSDC_PROTOCOL);
640 
641 	return 0;
642 
643 out_msgr:
644 	ceph_msgr_exit();
645 out_crypto:
646 	ceph_crypto_shutdown();
647 out_debugfs:
648 	ceph_debugfs_cleanup();
649 out:
650 	return ret;
651 }
652 
653 static void __exit exit_ceph_lib(void)
654 {
655 	dout("exit_ceph_lib\n");
656 	ceph_osdc_cleanup();
657 	ceph_msgr_exit();
658 	ceph_crypto_shutdown();
659 	ceph_debugfs_cleanup();
660 }
661 
662 module_init(init_ceph_lib);
663 module_exit(exit_ceph_lib);
664 
665 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
666 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
667 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
668 MODULE_DESCRIPTION("Ceph filesystem for Linux");
669 MODULE_LICENSE("GPL");
670