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