1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/ceph/ceph_debug.h> 4 5 #include <linux/backing-dev.h> 6 #include <linux/ctype.h> 7 #include <linux/fs.h> 8 #include <linux/inet.h> 9 #include <linux/in6.h> 10 #include <linux/module.h> 11 #include <linux/mount.h> 12 #include <linux/fs_context.h> 13 #include <linux/fs_parser.h> 14 #include <linux/sched.h> 15 #include <linux/seq_file.h> 16 #include <linux/slab.h> 17 #include <linux/statfs.h> 18 #include <linux/string.h> 19 20 #include "super.h" 21 #include "mds_client.h" 22 #include "cache.h" 23 #include "crypto.h" 24 25 #include <linux/ceph/ceph_features.h> 26 #include <linux/ceph/decode.h> 27 #include <linux/ceph/mon_client.h> 28 #include <linux/ceph/auth.h> 29 #include <linux/ceph/debugfs.h> 30 31 #include <uapi/linux/magic.h> 32 33 static DEFINE_SPINLOCK(ceph_fsc_lock); 34 static LIST_HEAD(ceph_fsc_list); 35 36 /* 37 * Ceph superblock operations 38 * 39 * Handle the basics of mounting, unmounting. 40 */ 41 42 /* 43 * super ops 44 */ 45 static void ceph_put_super(struct super_block *s) 46 { 47 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(s); 48 49 doutc(fsc->client, "begin\n"); 50 ceph_fscrypt_free_dummy_policy(fsc); 51 ceph_mdsc_close_sessions(fsc->mdsc); 52 doutc(fsc->client, "done\n"); 53 } 54 55 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf) 56 { 57 struct ceph_fs_client *fsc = ceph_inode_to_fs_client(d_inode(dentry)); 58 struct ceph_mon_client *monc = &fsc->client->monc; 59 struct ceph_statfs st; 60 int i, err; 61 u64 data_pool; 62 63 doutc(fsc->client, "begin\n"); 64 if (fsc->mdsc->mdsmap->m_num_data_pg_pools == 1) { 65 data_pool = fsc->mdsc->mdsmap->m_data_pg_pools[0]; 66 } else { 67 data_pool = CEPH_NOPOOL; 68 } 69 70 err = ceph_monc_do_statfs(monc, data_pool, &st); 71 if (err < 0) 72 return err; 73 74 /* fill in kstatfs */ 75 buf->f_type = CEPH_SUPER_MAGIC; /* ?? */ 76 77 /* 78 * Express utilization in terms of large blocks to avoid 79 * overflow on 32-bit machines. 80 */ 81 buf->f_frsize = 1 << CEPH_BLOCK_SHIFT; 82 83 /* 84 * By default use root quota for stats; fallback to overall filesystem 85 * usage if using 'noquotadf' mount option or if the root dir doesn't 86 * have max_bytes quota set. 87 */ 88 if (ceph_test_mount_opt(fsc, NOQUOTADF) || 89 !ceph_quota_update_statfs(fsc, buf)) { 90 buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10); 91 buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10); 92 buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10); 93 } 94 95 /* 96 * NOTE: for the time being, we make bsize == frsize to humor 97 * not-yet-ancient versions of glibc that are broken. 98 * Someday, we will probably want to report a real block 99 * size... whatever that may mean for a network file system! 100 */ 101 buf->f_bsize = buf->f_frsize; 102 103 buf->f_files = le64_to_cpu(st.num_objects); 104 buf->f_ffree = -1; 105 buf->f_namelen = NAME_MAX; 106 107 /* Must convert the fsid, for consistent values across arches */ 108 buf->f_fsid.val[0] = 0; 109 mutex_lock(&monc->mutex); 110 for (i = 0 ; i < sizeof(monc->monmap->fsid) / sizeof(__le32) ; ++i) 111 buf->f_fsid.val[0] ^= le32_to_cpu(((__le32 *)&monc->monmap->fsid)[i]); 112 mutex_unlock(&monc->mutex); 113 114 /* fold the fs_cluster_id into the upper bits */ 115 buf->f_fsid.val[1] = monc->fs_cluster_id; 116 117 doutc(fsc->client, "done\n"); 118 return 0; 119 } 120 121 static int ceph_sync_fs(struct super_block *sb, int wait) 122 { 123 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); 124 struct ceph_client *cl = fsc->client; 125 126 if (!wait) { 127 doutc(cl, "(non-blocking)\n"); 128 ceph_flush_dirty_caps(fsc->mdsc); 129 ceph_flush_cap_releases(fsc->mdsc); 130 doutc(cl, "(non-blocking) done\n"); 131 return 0; 132 } 133 134 doutc(cl, "(blocking)\n"); 135 ceph_osdc_sync(&fsc->client->osdc); 136 ceph_mdsc_sync(fsc->mdsc); 137 doutc(cl, "(blocking) done\n"); 138 return 0; 139 } 140 141 /* 142 * mount options 143 */ 144 enum { 145 Opt_wsize, 146 Opt_rsize, 147 Opt_rasize, 148 Opt_caps_wanted_delay_min, 149 Opt_caps_wanted_delay_max, 150 Opt_caps_max, 151 Opt_readdir_max_entries, 152 Opt_readdir_max_bytes, 153 Opt_congestion_kb, 154 /* int args above */ 155 Opt_snapdirname, 156 Opt_mds_namespace, 157 Opt_recover_session, 158 Opt_source, 159 Opt_mon_addr, 160 Opt_test_dummy_encryption, 161 /* string args above */ 162 Opt_dirstat, 163 Opt_rbytes, 164 Opt_asyncreaddir, 165 Opt_dcache, 166 Opt_ino32, 167 Opt_fscache, 168 Opt_poolperm, 169 Opt_require_active_mds, 170 Opt_acl, 171 Opt_quotadf, 172 Opt_copyfrom, 173 Opt_wsync, 174 Opt_pagecache, 175 Opt_sparseread, 176 }; 177 178 enum ceph_recover_session_mode { 179 ceph_recover_session_no, 180 ceph_recover_session_clean 181 }; 182 183 static const struct constant_table ceph_param_recover[] = { 184 { "no", ceph_recover_session_no }, 185 { "clean", ceph_recover_session_clean }, 186 {} 187 }; 188 189 static const struct fs_parameter_spec ceph_mount_parameters[] = { 190 fsparam_flag_no ("acl", Opt_acl), 191 fsparam_flag_no ("asyncreaddir", Opt_asyncreaddir), 192 fsparam_s32 ("caps_max", Opt_caps_max), 193 fsparam_u32 ("caps_wanted_delay_max", Opt_caps_wanted_delay_max), 194 fsparam_u32 ("caps_wanted_delay_min", Opt_caps_wanted_delay_min), 195 fsparam_u32 ("write_congestion_kb", Opt_congestion_kb), 196 fsparam_flag_no ("copyfrom", Opt_copyfrom), 197 fsparam_flag_no ("dcache", Opt_dcache), 198 fsparam_flag_no ("dirstat", Opt_dirstat), 199 fsparam_flag_no ("fsc", Opt_fscache), // fsc|nofsc 200 fsparam_string ("fsc", Opt_fscache), // fsc=... 201 fsparam_flag_no ("ino32", Opt_ino32), 202 fsparam_string ("mds_namespace", Opt_mds_namespace), 203 fsparam_string ("mon_addr", Opt_mon_addr), 204 fsparam_flag_no ("poolperm", Opt_poolperm), 205 fsparam_flag_no ("quotadf", Opt_quotadf), 206 fsparam_u32 ("rasize", Opt_rasize), 207 fsparam_flag_no ("rbytes", Opt_rbytes), 208 fsparam_u32 ("readdir_max_bytes", Opt_readdir_max_bytes), 209 fsparam_u32 ("readdir_max_entries", Opt_readdir_max_entries), 210 fsparam_enum ("recover_session", Opt_recover_session, ceph_param_recover), 211 fsparam_flag_no ("require_active_mds", Opt_require_active_mds), 212 fsparam_u32 ("rsize", Opt_rsize), 213 fsparam_string ("snapdirname", Opt_snapdirname), 214 fsparam_string ("source", Opt_source), 215 fsparam_flag ("test_dummy_encryption", Opt_test_dummy_encryption), 216 fsparam_string ("test_dummy_encryption", Opt_test_dummy_encryption), 217 fsparam_u32 ("wsize", Opt_wsize), 218 fsparam_flag_no ("wsync", Opt_wsync), 219 fsparam_flag_no ("pagecache", Opt_pagecache), 220 fsparam_flag_no ("sparseread", Opt_sparseread), 221 {} 222 }; 223 224 struct ceph_parse_opts_ctx { 225 struct ceph_options *copts; 226 struct ceph_mount_options *opts; 227 }; 228 229 /* 230 * Remove adjacent slashes and then the trailing slash, unless it is 231 * the only remaining character. 232 * 233 * E.g. "//dir1////dir2///" --> "/dir1/dir2", "///" --> "/". 234 */ 235 static void canonicalize_path(char *path) 236 { 237 int i, j = 0; 238 239 for (i = 0; path[i] != '\0'; i++) { 240 if (path[i] != '/' || j < 1 || path[j - 1] != '/') 241 path[j++] = path[i]; 242 } 243 244 if (j > 1 && path[j - 1] == '/') 245 j--; 246 path[j] = '\0'; 247 } 248 249 /* 250 * Check if the mds namespace in ceph_mount_options matches 251 * the passed in namespace string. First time match (when 252 * ->mds_namespace is NULL) is treated specially, since 253 * ->mds_namespace needs to be initialized by the caller. 254 */ 255 static int namespace_equals(struct ceph_mount_options *fsopt, 256 const char *namespace, size_t len) 257 { 258 return !(fsopt->mds_namespace && 259 (strlen(fsopt->mds_namespace) != len || 260 strncmp(fsopt->mds_namespace, namespace, len))); 261 } 262 263 static int ceph_parse_old_source(const char *dev_name, const char *dev_name_end, 264 struct fs_context *fc) 265 { 266 int r; 267 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 268 struct ceph_mount_options *fsopt = pctx->opts; 269 270 if (*dev_name_end != ':') 271 return invalfc(fc, "separator ':' missing in source"); 272 273 r = ceph_parse_mon_ips(dev_name, dev_name_end - dev_name, 274 pctx->copts, fc->log.log, ','); 275 if (r) 276 return r; 277 278 fsopt->new_dev_syntax = false; 279 return 0; 280 } 281 282 static int ceph_parse_new_source(const char *dev_name, const char *dev_name_end, 283 struct fs_context *fc) 284 { 285 size_t len; 286 struct ceph_fsid fsid; 287 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 288 struct ceph_options *opts = pctx->copts; 289 struct ceph_mount_options *fsopt = pctx->opts; 290 const char *name_start = dev_name; 291 const char *fsid_start, *fs_name_start; 292 293 if (*dev_name_end != '=') { 294 dout("separator '=' missing in source"); 295 return -EINVAL; 296 } 297 298 fsid_start = strchr(dev_name, '@'); 299 if (!fsid_start) 300 return invalfc(fc, "missing cluster fsid"); 301 len = fsid_start - name_start; 302 kfree(opts->name); 303 opts->name = kstrndup(name_start, len, GFP_KERNEL); 304 if (!opts->name) 305 return -ENOMEM; 306 dout("using %s entity name", opts->name); 307 308 ++fsid_start; /* start of cluster fsid */ 309 fs_name_start = strchr(fsid_start, '.'); 310 if (!fs_name_start) 311 return invalfc(fc, "missing file system name"); 312 313 if (ceph_parse_fsid(fsid_start, &fsid)) 314 return invalfc(fc, "Invalid FSID"); 315 316 ++fs_name_start; /* start of file system name */ 317 len = dev_name_end - fs_name_start; 318 319 if (!namespace_equals(fsopt, fs_name_start, len)) 320 return invalfc(fc, "Mismatching mds_namespace"); 321 kfree(fsopt->mds_namespace); 322 fsopt->mds_namespace = kstrndup(fs_name_start, len, GFP_KERNEL); 323 if (!fsopt->mds_namespace) 324 return -ENOMEM; 325 dout("file system (mds namespace) '%s'\n", fsopt->mds_namespace); 326 327 fsopt->new_dev_syntax = true; 328 return 0; 329 } 330 331 /* 332 * Parse the source parameter for new device format. Distinguish the device 333 * spec from the path. Try parsing new device format and fallback to old 334 * format if needed. 335 * 336 * New device syntax will looks like: 337 * <device_spec>=/<path> 338 * where 339 * <device_spec> is name@fsid.fsname 340 * <path> is optional, but if present must begin with '/' 341 * (monitor addresses are passed via mount option) 342 * 343 * Old device syntax is: 344 * <server_spec>[,<server_spec>...]:[<path>] 345 * where 346 * <server_spec> is <ip>[:<port>] 347 * <path> is optional, but if present must begin with '/' 348 */ 349 static int ceph_parse_source(struct fs_parameter *param, struct fs_context *fc) 350 { 351 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 352 struct ceph_mount_options *fsopt = pctx->opts; 353 char *dev_name = param->string, *dev_name_end; 354 int ret; 355 356 dout("'%s'\n", dev_name); 357 if (!dev_name || !*dev_name) 358 return invalfc(fc, "Empty source"); 359 360 dev_name_end = strchr(dev_name, '/'); 361 if (dev_name_end) { 362 /* 363 * The server_path will include the whole chars from userland 364 * including the leading '/'. 365 */ 366 kfree(fsopt->server_path); 367 fsopt->server_path = kstrdup(dev_name_end, GFP_KERNEL); 368 if (!fsopt->server_path) 369 return -ENOMEM; 370 371 canonicalize_path(fsopt->server_path); 372 } else { 373 dev_name_end = dev_name + strlen(dev_name); 374 } 375 376 dev_name_end--; /* back up to separator */ 377 if (dev_name_end < dev_name) 378 return invalfc(fc, "Path missing in source"); 379 380 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name); 381 if (fsopt->server_path) 382 dout("server path '%s'\n", fsopt->server_path); 383 384 dout("trying new device syntax"); 385 ret = ceph_parse_new_source(dev_name, dev_name_end, fc); 386 if (ret) { 387 if (ret != -EINVAL) 388 return ret; 389 dout("trying old device syntax"); 390 ret = ceph_parse_old_source(dev_name, dev_name_end, fc); 391 if (ret) 392 return ret; 393 } 394 395 fc->source = param->string; 396 param->string = NULL; 397 return 0; 398 } 399 400 static int ceph_parse_mon_addr(struct fs_parameter *param, 401 struct fs_context *fc) 402 { 403 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 404 struct ceph_mount_options *fsopt = pctx->opts; 405 406 kfree(fsopt->mon_addr); 407 fsopt->mon_addr = param->string; 408 param->string = NULL; 409 410 return ceph_parse_mon_ips(fsopt->mon_addr, strlen(fsopt->mon_addr), 411 pctx->copts, fc->log.log, '/'); 412 } 413 414 static int ceph_parse_mount_param(struct fs_context *fc, 415 struct fs_parameter *param) 416 { 417 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 418 struct ceph_mount_options *fsopt = pctx->opts; 419 struct fs_parse_result result; 420 unsigned int mode; 421 int token, ret; 422 423 ret = ceph_parse_param(param, pctx->copts, fc->log.log); 424 if (ret != -ENOPARAM) 425 return ret; 426 427 token = fs_parse(fc, ceph_mount_parameters, param, &result); 428 dout("%s: fs_parse '%s' token %d\n",__func__, param->key, token); 429 if (token < 0) 430 return token; 431 432 switch (token) { 433 case Opt_snapdirname: 434 if (strlen(param->string) > NAME_MAX) 435 return invalfc(fc, "snapdirname too long"); 436 kfree(fsopt->snapdir_name); 437 fsopt->snapdir_name = param->string; 438 param->string = NULL; 439 break; 440 case Opt_mds_namespace: 441 if (!namespace_equals(fsopt, param->string, strlen(param->string))) 442 return invalfc(fc, "Mismatching mds_namespace"); 443 kfree(fsopt->mds_namespace); 444 fsopt->mds_namespace = param->string; 445 param->string = NULL; 446 break; 447 case Opt_recover_session: 448 mode = result.uint_32; 449 if (mode == ceph_recover_session_no) 450 fsopt->flags &= ~CEPH_MOUNT_OPT_CLEANRECOVER; 451 else if (mode == ceph_recover_session_clean) 452 fsopt->flags |= CEPH_MOUNT_OPT_CLEANRECOVER; 453 else 454 BUG(); 455 break; 456 case Opt_source: 457 if (fc->source) 458 return invalfc(fc, "Multiple sources specified"); 459 return ceph_parse_source(param, fc); 460 case Opt_mon_addr: 461 return ceph_parse_mon_addr(param, fc); 462 case Opt_wsize: 463 if (result.uint_32 < PAGE_SIZE || 464 result.uint_32 > CEPH_MAX_WRITE_SIZE) 465 goto out_of_range; 466 fsopt->wsize = ALIGN(result.uint_32, PAGE_SIZE); 467 break; 468 case Opt_rsize: 469 if (result.uint_32 < PAGE_SIZE || 470 result.uint_32 > CEPH_MAX_READ_SIZE) 471 goto out_of_range; 472 fsopt->rsize = ALIGN(result.uint_32, PAGE_SIZE); 473 break; 474 case Opt_rasize: 475 fsopt->rasize = ALIGN(result.uint_32, PAGE_SIZE); 476 break; 477 case Opt_caps_wanted_delay_min: 478 if (result.uint_32 < 1) 479 goto out_of_range; 480 fsopt->caps_wanted_delay_min = result.uint_32; 481 break; 482 case Opt_caps_wanted_delay_max: 483 if (result.uint_32 < 1) 484 goto out_of_range; 485 fsopt->caps_wanted_delay_max = result.uint_32; 486 break; 487 case Opt_caps_max: 488 if (result.int_32 < 0) 489 goto out_of_range; 490 fsopt->caps_max = result.int_32; 491 break; 492 case Opt_readdir_max_entries: 493 if (result.uint_32 < 1) 494 goto out_of_range; 495 fsopt->max_readdir = result.uint_32; 496 break; 497 case Opt_readdir_max_bytes: 498 if (result.uint_32 < PAGE_SIZE && result.uint_32 != 0) 499 goto out_of_range; 500 fsopt->max_readdir_bytes = result.uint_32; 501 break; 502 case Opt_congestion_kb: 503 if (result.uint_32 < 1024) /* at least 1M */ 504 goto out_of_range; 505 fsopt->congestion_kb = result.uint_32; 506 break; 507 case Opt_dirstat: 508 if (!result.negated) 509 fsopt->flags |= CEPH_MOUNT_OPT_DIRSTAT; 510 else 511 fsopt->flags &= ~CEPH_MOUNT_OPT_DIRSTAT; 512 break; 513 case Opt_rbytes: 514 if (!result.negated) 515 fsopt->flags |= CEPH_MOUNT_OPT_RBYTES; 516 else 517 fsopt->flags &= ~CEPH_MOUNT_OPT_RBYTES; 518 break; 519 case Opt_asyncreaddir: 520 if (!result.negated) 521 fsopt->flags &= ~CEPH_MOUNT_OPT_NOASYNCREADDIR; 522 else 523 fsopt->flags |= CEPH_MOUNT_OPT_NOASYNCREADDIR; 524 break; 525 case Opt_dcache: 526 if (!result.negated) 527 fsopt->flags |= CEPH_MOUNT_OPT_DCACHE; 528 else 529 fsopt->flags &= ~CEPH_MOUNT_OPT_DCACHE; 530 break; 531 case Opt_ino32: 532 if (!result.negated) 533 fsopt->flags |= CEPH_MOUNT_OPT_INO32; 534 else 535 fsopt->flags &= ~CEPH_MOUNT_OPT_INO32; 536 break; 537 538 case Opt_fscache: 539 #ifdef CONFIG_CEPH_FSCACHE 540 kfree(fsopt->fscache_uniq); 541 fsopt->fscache_uniq = NULL; 542 if (result.negated) { 543 fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE; 544 } else { 545 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE; 546 fsopt->fscache_uniq = param->string; 547 param->string = NULL; 548 } 549 break; 550 #else 551 return invalfc(fc, "fscache support is disabled"); 552 #endif 553 case Opt_poolperm: 554 if (!result.negated) 555 fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM; 556 else 557 fsopt->flags |= CEPH_MOUNT_OPT_NOPOOLPERM; 558 break; 559 case Opt_require_active_mds: 560 if (!result.negated) 561 fsopt->flags &= ~CEPH_MOUNT_OPT_MOUNTWAIT; 562 else 563 fsopt->flags |= CEPH_MOUNT_OPT_MOUNTWAIT; 564 break; 565 case Opt_quotadf: 566 if (!result.negated) 567 fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF; 568 else 569 fsopt->flags |= CEPH_MOUNT_OPT_NOQUOTADF; 570 break; 571 case Opt_copyfrom: 572 if (!result.negated) 573 fsopt->flags &= ~CEPH_MOUNT_OPT_NOCOPYFROM; 574 else 575 fsopt->flags |= CEPH_MOUNT_OPT_NOCOPYFROM; 576 break; 577 case Opt_acl: 578 if (!result.negated) { 579 #ifdef CONFIG_CEPH_FS_POSIX_ACL 580 fc->sb_flags |= SB_POSIXACL; 581 #else 582 return invalfc(fc, "POSIX ACL support is disabled"); 583 #endif 584 } else { 585 fc->sb_flags &= ~SB_POSIXACL; 586 } 587 break; 588 case Opt_wsync: 589 if (!result.negated) 590 fsopt->flags &= ~CEPH_MOUNT_OPT_ASYNC_DIROPS; 591 else 592 fsopt->flags |= CEPH_MOUNT_OPT_ASYNC_DIROPS; 593 break; 594 case Opt_pagecache: 595 if (result.negated) 596 fsopt->flags |= CEPH_MOUNT_OPT_NOPAGECACHE; 597 else 598 fsopt->flags &= ~CEPH_MOUNT_OPT_NOPAGECACHE; 599 break; 600 case Opt_sparseread: 601 if (result.negated) 602 fsopt->flags &= ~CEPH_MOUNT_OPT_SPARSEREAD; 603 else 604 fsopt->flags |= CEPH_MOUNT_OPT_SPARSEREAD; 605 break; 606 case Opt_test_dummy_encryption: 607 #ifdef CONFIG_FS_ENCRYPTION 608 fscrypt_free_dummy_policy(&fsopt->dummy_enc_policy); 609 ret = fscrypt_parse_test_dummy_encryption(param, 610 &fsopt->dummy_enc_policy); 611 if (ret == -EINVAL) { 612 warnfc(fc, "Value of option \"%s\" is unrecognized", 613 param->key); 614 } else if (ret == -EEXIST) { 615 warnfc(fc, "Conflicting test_dummy_encryption options"); 616 ret = -EINVAL; 617 } 618 #else 619 warnfc(fc, 620 "FS encryption not supported: test_dummy_encryption mount option ignored"); 621 #endif 622 break; 623 default: 624 BUG(); 625 } 626 return 0; 627 628 out_of_range: 629 return invalfc(fc, "%s out of range", param->key); 630 } 631 632 static void destroy_mount_options(struct ceph_mount_options *args) 633 { 634 dout("destroy_mount_options %p\n", args); 635 if (!args) 636 return; 637 638 kfree(args->snapdir_name); 639 kfree(args->mds_namespace); 640 kfree(args->server_path); 641 kfree(args->fscache_uniq); 642 kfree(args->mon_addr); 643 fscrypt_free_dummy_policy(&args->dummy_enc_policy); 644 kfree(args); 645 } 646 647 static int strcmp_null(const char *s1, const char *s2) 648 { 649 if (!s1 && !s2) 650 return 0; 651 if (s1 && !s2) 652 return -1; 653 if (!s1 && s2) 654 return 1; 655 return strcmp(s1, s2); 656 } 657 658 static int compare_mount_options(struct ceph_mount_options *new_fsopt, 659 struct ceph_options *new_opt, 660 struct ceph_fs_client *fsc) 661 { 662 struct ceph_mount_options *fsopt1 = new_fsopt; 663 struct ceph_mount_options *fsopt2 = fsc->mount_options; 664 int ofs = offsetof(struct ceph_mount_options, snapdir_name); 665 int ret; 666 667 ret = memcmp(fsopt1, fsopt2, ofs); 668 if (ret) 669 return ret; 670 671 ret = strcmp_null(fsopt1->snapdir_name, fsopt2->snapdir_name); 672 if (ret) 673 return ret; 674 675 ret = strcmp_null(fsopt1->mds_namespace, fsopt2->mds_namespace); 676 if (ret) 677 return ret; 678 679 ret = strcmp_null(fsopt1->server_path, fsopt2->server_path); 680 if (ret) 681 return ret; 682 683 ret = strcmp_null(fsopt1->fscache_uniq, fsopt2->fscache_uniq); 684 if (ret) 685 return ret; 686 687 ret = strcmp_null(fsopt1->mon_addr, fsopt2->mon_addr); 688 if (ret) 689 return ret; 690 691 return ceph_compare_options(new_opt, fsc->client); 692 } 693 694 /** 695 * ceph_show_options - Show mount options in /proc/mounts 696 * @m: seq_file to write to 697 * @root: root of that (sub)tree 698 */ 699 static int ceph_show_options(struct seq_file *m, struct dentry *root) 700 { 701 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(root->d_sb); 702 struct ceph_mount_options *fsopt = fsc->mount_options; 703 size_t pos; 704 int ret; 705 706 /* a comma between MNT/MS and client options */ 707 seq_putc(m, ','); 708 pos = m->count; 709 710 ret = ceph_print_client_options(m, fsc->client, false); 711 if (ret) 712 return ret; 713 714 /* retract our comma if no client options */ 715 if (m->count == pos) 716 m->count--; 717 718 if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT) 719 seq_puts(m, ",dirstat"); 720 if ((fsopt->flags & CEPH_MOUNT_OPT_RBYTES)) 721 seq_puts(m, ",rbytes"); 722 if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR) 723 seq_puts(m, ",noasyncreaddir"); 724 if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0) 725 seq_puts(m, ",nodcache"); 726 if (fsopt->flags & CEPH_MOUNT_OPT_INO32) 727 seq_puts(m, ",ino32"); 728 if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) { 729 seq_show_option(m, "fsc", fsopt->fscache_uniq); 730 } 731 if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM) 732 seq_puts(m, ",nopoolperm"); 733 if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF) 734 seq_puts(m, ",noquotadf"); 735 736 #ifdef CONFIG_CEPH_FS_POSIX_ACL 737 if (root->d_sb->s_flags & SB_POSIXACL) 738 seq_puts(m, ",acl"); 739 else 740 seq_puts(m, ",noacl"); 741 #endif 742 743 if ((fsopt->flags & CEPH_MOUNT_OPT_NOCOPYFROM) == 0) 744 seq_puts(m, ",copyfrom"); 745 746 /* dump mds_namespace when old device syntax is in use */ 747 if (fsopt->mds_namespace && !fsopt->new_dev_syntax) 748 seq_show_option(m, "mds_namespace", fsopt->mds_namespace); 749 750 if (fsopt->mon_addr) 751 seq_printf(m, ",mon_addr=%s", fsopt->mon_addr); 752 753 if (fsopt->flags & CEPH_MOUNT_OPT_CLEANRECOVER) 754 seq_show_option(m, "recover_session", "clean"); 755 756 if (!(fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS)) 757 seq_puts(m, ",wsync"); 758 if (fsopt->flags & CEPH_MOUNT_OPT_NOPAGECACHE) 759 seq_puts(m, ",nopagecache"); 760 if (fsopt->flags & CEPH_MOUNT_OPT_SPARSEREAD) 761 seq_puts(m, ",sparseread"); 762 763 fscrypt_show_test_dummy_encryption(m, ',', root->d_sb); 764 765 if (fsopt->wsize != CEPH_MAX_WRITE_SIZE) 766 seq_printf(m, ",wsize=%u", fsopt->wsize); 767 if (fsopt->rsize != CEPH_MAX_READ_SIZE) 768 seq_printf(m, ",rsize=%u", fsopt->rsize); 769 if (fsopt->rasize != CEPH_RASIZE_DEFAULT) 770 seq_printf(m, ",rasize=%u", fsopt->rasize); 771 if (fsopt->congestion_kb != default_congestion_kb()) 772 seq_printf(m, ",write_congestion_kb=%u", fsopt->congestion_kb); 773 if (fsopt->caps_max) 774 seq_printf(m, ",caps_max=%d", fsopt->caps_max); 775 if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT) 776 seq_printf(m, ",caps_wanted_delay_min=%u", 777 fsopt->caps_wanted_delay_min); 778 if (fsopt->caps_wanted_delay_max != CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT) 779 seq_printf(m, ",caps_wanted_delay_max=%u", 780 fsopt->caps_wanted_delay_max); 781 if (fsopt->max_readdir != CEPH_MAX_READDIR_DEFAULT) 782 seq_printf(m, ",readdir_max_entries=%u", fsopt->max_readdir); 783 if (fsopt->max_readdir_bytes != CEPH_MAX_READDIR_BYTES_DEFAULT) 784 seq_printf(m, ",readdir_max_bytes=%u", fsopt->max_readdir_bytes); 785 if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT)) 786 seq_show_option(m, "snapdirname", fsopt->snapdir_name); 787 788 return 0; 789 } 790 791 /* 792 * handle any mon messages the standard library doesn't understand. 793 * return error if we don't either. 794 */ 795 static int extra_mon_dispatch(struct ceph_client *client, struct ceph_msg *msg) 796 { 797 struct ceph_fs_client *fsc = client->private; 798 int type = le16_to_cpu(msg->hdr.type); 799 800 switch (type) { 801 case CEPH_MSG_MDS_MAP: 802 ceph_mdsc_handle_mdsmap(fsc->mdsc, msg); 803 return 0; 804 case CEPH_MSG_FS_MAP_USER: 805 ceph_mdsc_handle_fsmap(fsc->mdsc, msg); 806 return 0; 807 default: 808 return -1; 809 } 810 } 811 812 /* 813 * create a new fs client 814 * 815 * Success or not, this function consumes @fsopt and @opt. 816 */ 817 static struct ceph_fs_client *create_fs_client(struct ceph_mount_options *fsopt, 818 struct ceph_options *opt) 819 { 820 struct ceph_fs_client *fsc; 821 int err; 822 823 fsc = kzalloc(sizeof(*fsc), GFP_KERNEL); 824 if (!fsc) { 825 err = -ENOMEM; 826 goto fail; 827 } 828 829 fsc->client = ceph_create_client(opt, fsc); 830 if (IS_ERR(fsc->client)) { 831 err = PTR_ERR(fsc->client); 832 goto fail; 833 } 834 opt = NULL; /* fsc->client now owns this */ 835 836 fsc->client->extra_mon_dispatch = extra_mon_dispatch; 837 ceph_set_opt(fsc->client, ABORT_ON_FULL); 838 839 if (!fsopt->mds_namespace) { 840 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_MDSMAP, 841 0, true); 842 } else { 843 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_FSMAP, 844 0, false); 845 } 846 847 fsc->mount_options = fsopt; 848 849 fsc->sb = NULL; 850 fsc->mount_state = CEPH_MOUNT_MOUNTING; 851 fsc->filp_gen = 1; 852 fsc->have_copy_from2 = true; 853 854 atomic_long_set(&fsc->writeback_count, 0); 855 fsc->write_congested = false; 856 857 err = -ENOMEM; 858 /* 859 * The number of concurrent works can be high but they don't need 860 * to be processed in parallel, limit concurrency. 861 */ 862 fsc->inode_wq = alloc_workqueue("ceph-inode", WQ_UNBOUND, 0); 863 if (!fsc->inode_wq) 864 goto fail_client; 865 fsc->cap_wq = alloc_workqueue("ceph-cap", 0, 1); 866 if (!fsc->cap_wq) 867 goto fail_inode_wq; 868 869 hash_init(fsc->async_unlink_conflict); 870 spin_lock_init(&fsc->async_unlink_conflict_lock); 871 872 spin_lock(&ceph_fsc_lock); 873 list_add_tail(&fsc->metric_wakeup, &ceph_fsc_list); 874 spin_unlock(&ceph_fsc_lock); 875 876 return fsc; 877 878 fail_inode_wq: 879 destroy_workqueue(fsc->inode_wq); 880 fail_client: 881 ceph_destroy_client(fsc->client); 882 fail: 883 kfree(fsc); 884 if (opt) 885 ceph_destroy_options(opt); 886 destroy_mount_options(fsopt); 887 return ERR_PTR(err); 888 } 889 890 static void flush_fs_workqueues(struct ceph_fs_client *fsc) 891 { 892 flush_workqueue(fsc->inode_wq); 893 flush_workqueue(fsc->cap_wq); 894 } 895 896 static void destroy_fs_client(struct ceph_fs_client *fsc) 897 { 898 doutc(fsc->client, "%p\n", fsc); 899 900 spin_lock(&ceph_fsc_lock); 901 list_del(&fsc->metric_wakeup); 902 spin_unlock(&ceph_fsc_lock); 903 904 ceph_mdsc_destroy(fsc); 905 destroy_workqueue(fsc->inode_wq); 906 destroy_workqueue(fsc->cap_wq); 907 908 destroy_mount_options(fsc->mount_options); 909 910 ceph_destroy_client(fsc->client); 911 912 kfree(fsc); 913 dout("%s: %p done\n", __func__, fsc); 914 } 915 916 /* 917 * caches 918 */ 919 struct kmem_cache *ceph_inode_cachep; 920 struct kmem_cache *ceph_cap_cachep; 921 struct kmem_cache *ceph_cap_snap_cachep; 922 struct kmem_cache *ceph_cap_flush_cachep; 923 struct kmem_cache *ceph_dentry_cachep; 924 struct kmem_cache *ceph_file_cachep; 925 struct kmem_cache *ceph_dir_file_cachep; 926 struct kmem_cache *ceph_mds_request_cachep; 927 mempool_t *ceph_wb_pagevec_pool; 928 929 static void ceph_inode_init_once(void *foo) 930 { 931 struct ceph_inode_info *ci = foo; 932 inode_init_once(&ci->netfs.inode); 933 } 934 935 static int __init init_caches(void) 936 { 937 int error = -ENOMEM; 938 939 ceph_inode_cachep = kmem_cache_create("ceph_inode_info", 940 sizeof(struct ceph_inode_info), 941 __alignof__(struct ceph_inode_info), 942 SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 943 ceph_inode_init_once); 944 if (!ceph_inode_cachep) 945 return -ENOMEM; 946 947 ceph_cap_cachep = KMEM_CACHE(ceph_cap, 0); 948 if (!ceph_cap_cachep) 949 goto bad_cap; 950 ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, 0); 951 if (!ceph_cap_snap_cachep) 952 goto bad_cap_snap; 953 ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush, 954 SLAB_RECLAIM_ACCOUNT); 955 if (!ceph_cap_flush_cachep) 956 goto bad_cap_flush; 957 958 ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info, 959 SLAB_RECLAIM_ACCOUNT); 960 if (!ceph_dentry_cachep) 961 goto bad_dentry; 962 963 ceph_file_cachep = KMEM_CACHE(ceph_file_info, 0); 964 if (!ceph_file_cachep) 965 goto bad_file; 966 967 ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, 0); 968 if (!ceph_dir_file_cachep) 969 goto bad_dir_file; 970 971 ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, 0); 972 if (!ceph_mds_request_cachep) 973 goto bad_mds_req; 974 975 ceph_wb_pagevec_pool = mempool_create_kmalloc_pool(10, 976 (CEPH_MAX_WRITE_SIZE >> PAGE_SHIFT) * sizeof(struct page *)); 977 if (!ceph_wb_pagevec_pool) 978 goto bad_pagevec_pool; 979 980 return 0; 981 982 bad_pagevec_pool: 983 kmem_cache_destroy(ceph_mds_request_cachep); 984 bad_mds_req: 985 kmem_cache_destroy(ceph_dir_file_cachep); 986 bad_dir_file: 987 kmem_cache_destroy(ceph_file_cachep); 988 bad_file: 989 kmem_cache_destroy(ceph_dentry_cachep); 990 bad_dentry: 991 kmem_cache_destroy(ceph_cap_flush_cachep); 992 bad_cap_flush: 993 kmem_cache_destroy(ceph_cap_snap_cachep); 994 bad_cap_snap: 995 kmem_cache_destroy(ceph_cap_cachep); 996 bad_cap: 997 kmem_cache_destroy(ceph_inode_cachep); 998 return error; 999 } 1000 1001 static void destroy_caches(void) 1002 { 1003 /* 1004 * Make sure all delayed rcu free inodes are flushed before we 1005 * destroy cache. 1006 */ 1007 rcu_barrier(); 1008 1009 kmem_cache_destroy(ceph_inode_cachep); 1010 kmem_cache_destroy(ceph_cap_cachep); 1011 kmem_cache_destroy(ceph_cap_snap_cachep); 1012 kmem_cache_destroy(ceph_cap_flush_cachep); 1013 kmem_cache_destroy(ceph_dentry_cachep); 1014 kmem_cache_destroy(ceph_file_cachep); 1015 kmem_cache_destroy(ceph_dir_file_cachep); 1016 kmem_cache_destroy(ceph_mds_request_cachep); 1017 mempool_destroy(ceph_wb_pagevec_pool); 1018 } 1019 1020 static void __ceph_umount_begin(struct ceph_fs_client *fsc) 1021 { 1022 ceph_osdc_abort_requests(&fsc->client->osdc, -EIO); 1023 ceph_mdsc_force_umount(fsc->mdsc); 1024 fsc->filp_gen++; // invalidate open files 1025 } 1026 1027 /* 1028 * ceph_umount_begin - initiate forced umount. Tear down the 1029 * mount, skipping steps that may hang while waiting for server(s). 1030 */ 1031 void ceph_umount_begin(struct super_block *sb) 1032 { 1033 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); 1034 1035 doutc(fsc->client, "starting forced umount\n"); 1036 if (!fsc) 1037 return; 1038 fsc->mount_state = CEPH_MOUNT_SHUTDOWN; 1039 __ceph_umount_begin(fsc); 1040 } 1041 1042 static const struct super_operations ceph_super_ops = { 1043 .alloc_inode = ceph_alloc_inode, 1044 .free_inode = ceph_free_inode, 1045 .write_inode = ceph_write_inode, 1046 .drop_inode = generic_delete_inode, 1047 .evict_inode = ceph_evict_inode, 1048 .sync_fs = ceph_sync_fs, 1049 .put_super = ceph_put_super, 1050 .show_options = ceph_show_options, 1051 .statfs = ceph_statfs, 1052 .umount_begin = ceph_umount_begin, 1053 }; 1054 1055 /* 1056 * Bootstrap mount by opening the root directory. Note the mount 1057 * @started time from caller, and time out if this takes too long. 1058 */ 1059 static struct dentry *open_root_dentry(struct ceph_fs_client *fsc, 1060 const char *path, 1061 unsigned long started) 1062 { 1063 struct ceph_client *cl = fsc->client; 1064 struct ceph_mds_client *mdsc = fsc->mdsc; 1065 struct ceph_mds_request *req = NULL; 1066 int err; 1067 struct dentry *root; 1068 1069 /* open dir */ 1070 doutc(cl, "opening '%s'\n", path); 1071 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS); 1072 if (IS_ERR(req)) 1073 return ERR_CAST(req); 1074 req->r_path1 = kstrdup(path, GFP_NOFS); 1075 if (!req->r_path1) { 1076 root = ERR_PTR(-ENOMEM); 1077 goto out; 1078 } 1079 1080 req->r_ino1.ino = CEPH_INO_ROOT; 1081 req->r_ino1.snap = CEPH_NOSNAP; 1082 req->r_started = started; 1083 req->r_timeout = fsc->client->options->mount_timeout; 1084 req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE); 1085 req->r_num_caps = 2; 1086 err = ceph_mdsc_do_request(mdsc, NULL, req); 1087 if (err == 0) { 1088 struct inode *inode = req->r_target_inode; 1089 req->r_target_inode = NULL; 1090 doutc(cl, "success\n"); 1091 root = d_make_root(inode); 1092 if (!root) { 1093 root = ERR_PTR(-ENOMEM); 1094 goto out; 1095 } 1096 doutc(cl, "success, root dentry is %p\n", root); 1097 } else { 1098 root = ERR_PTR(err); 1099 } 1100 out: 1101 ceph_mdsc_put_request(req); 1102 return root; 1103 } 1104 1105 #ifdef CONFIG_FS_ENCRYPTION 1106 static int ceph_apply_test_dummy_encryption(struct super_block *sb, 1107 struct fs_context *fc, 1108 struct ceph_mount_options *fsopt) 1109 { 1110 struct ceph_fs_client *fsc = sb->s_fs_info; 1111 1112 if (!fscrypt_is_dummy_policy_set(&fsopt->dummy_enc_policy)) 1113 return 0; 1114 1115 /* No changing encryption context on remount. */ 1116 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE && 1117 !fscrypt_is_dummy_policy_set(&fsc->fsc_dummy_enc_policy)) { 1118 if (fscrypt_dummy_policies_equal(&fsopt->dummy_enc_policy, 1119 &fsc->fsc_dummy_enc_policy)) 1120 return 0; 1121 errorfc(fc, "Can't set test_dummy_encryption on remount"); 1122 return -EINVAL; 1123 } 1124 1125 /* Also make sure fsopt doesn't contain a conflicting value. */ 1126 if (fscrypt_is_dummy_policy_set(&fsc->fsc_dummy_enc_policy)) { 1127 if (fscrypt_dummy_policies_equal(&fsopt->dummy_enc_policy, 1128 &fsc->fsc_dummy_enc_policy)) 1129 return 0; 1130 errorfc(fc, "Conflicting test_dummy_encryption options"); 1131 return -EINVAL; 1132 } 1133 1134 fsc->fsc_dummy_enc_policy = fsopt->dummy_enc_policy; 1135 memset(&fsopt->dummy_enc_policy, 0, sizeof(fsopt->dummy_enc_policy)); 1136 1137 warnfc(fc, "test_dummy_encryption mode enabled"); 1138 return 0; 1139 } 1140 #else 1141 static int ceph_apply_test_dummy_encryption(struct super_block *sb, 1142 struct fs_context *fc, 1143 struct ceph_mount_options *fsopt) 1144 { 1145 return 0; 1146 } 1147 #endif 1148 1149 /* 1150 * mount: join the ceph cluster, and open root directory. 1151 */ 1152 static struct dentry *ceph_real_mount(struct ceph_fs_client *fsc, 1153 struct fs_context *fc) 1154 { 1155 struct ceph_client *cl = fsc->client; 1156 int err; 1157 unsigned long started = jiffies; /* note the start time */ 1158 struct dentry *root; 1159 1160 doutc(cl, "mount start %p\n", fsc); 1161 mutex_lock(&fsc->client->mount_mutex); 1162 1163 if (!fsc->sb->s_root) { 1164 const char *path = fsc->mount_options->server_path ? 1165 fsc->mount_options->server_path + 1 : ""; 1166 1167 err = __ceph_open_session(fsc->client, started); 1168 if (err < 0) 1169 goto out; 1170 1171 /* setup fscache */ 1172 if (fsc->mount_options->flags & CEPH_MOUNT_OPT_FSCACHE) { 1173 err = ceph_fscache_register_fs(fsc, fc); 1174 if (err < 0) 1175 goto out; 1176 } 1177 1178 err = ceph_apply_test_dummy_encryption(fsc->sb, fc, 1179 fsc->mount_options); 1180 if (err) 1181 goto out; 1182 1183 doutc(cl, "mount opening path '%s'\n", path); 1184 1185 ceph_fs_debugfs_init(fsc); 1186 1187 root = open_root_dentry(fsc, path, started); 1188 if (IS_ERR(root)) { 1189 err = PTR_ERR(root); 1190 goto out; 1191 } 1192 fsc->sb->s_root = dget(root); 1193 } else { 1194 root = dget(fsc->sb->s_root); 1195 } 1196 1197 fsc->mount_state = CEPH_MOUNT_MOUNTED; 1198 doutc(cl, "mount success\n"); 1199 mutex_unlock(&fsc->client->mount_mutex); 1200 return root; 1201 1202 out: 1203 mutex_unlock(&fsc->client->mount_mutex); 1204 ceph_fscrypt_free_dummy_policy(fsc); 1205 return ERR_PTR(err); 1206 } 1207 1208 static int ceph_set_super(struct super_block *s, struct fs_context *fc) 1209 { 1210 struct ceph_fs_client *fsc = s->s_fs_info; 1211 struct ceph_client *cl = fsc->client; 1212 int ret; 1213 1214 doutc(cl, "%p\n", s); 1215 1216 s->s_maxbytes = MAX_LFS_FILESIZE; 1217 1218 s->s_xattr = ceph_xattr_handlers; 1219 fsc->sb = s; 1220 fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */ 1221 1222 s->s_op = &ceph_super_ops; 1223 s->s_d_op = &ceph_dentry_ops; 1224 s->s_export_op = &ceph_export_ops; 1225 1226 s->s_time_gran = 1; 1227 s->s_time_min = 0; 1228 s->s_time_max = U32_MAX; 1229 s->s_flags |= SB_NODIRATIME | SB_NOATIME; 1230 1231 ceph_fscrypt_set_ops(s); 1232 1233 ret = set_anon_super_fc(s, fc); 1234 if (ret != 0) 1235 fsc->sb = NULL; 1236 return ret; 1237 } 1238 1239 /* 1240 * share superblock if same fs AND options 1241 */ 1242 static int ceph_compare_super(struct super_block *sb, struct fs_context *fc) 1243 { 1244 struct ceph_fs_client *new = fc->s_fs_info; 1245 struct ceph_mount_options *fsopt = new->mount_options; 1246 struct ceph_options *opt = new->client->options; 1247 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); 1248 struct ceph_client *cl = fsc->client; 1249 1250 doutc(cl, "%p\n", sb); 1251 1252 if (compare_mount_options(fsopt, opt, fsc)) { 1253 doutc(cl, "monitor(s)/mount options don't match\n"); 1254 return 0; 1255 } 1256 if ((opt->flags & CEPH_OPT_FSID) && 1257 ceph_fsid_compare(&opt->fsid, &fsc->client->fsid)) { 1258 doutc(cl, "fsid doesn't match\n"); 1259 return 0; 1260 } 1261 if (fc->sb_flags != (sb->s_flags & ~SB_BORN)) { 1262 doutc(cl, "flags differ\n"); 1263 return 0; 1264 } 1265 1266 if (fsc->blocklisted && !ceph_test_mount_opt(fsc, CLEANRECOVER)) { 1267 doutc(cl, "client is blocklisted (and CLEANRECOVER is not set)\n"); 1268 return 0; 1269 } 1270 1271 if (fsc->mount_state == CEPH_MOUNT_SHUTDOWN) { 1272 doutc(cl, "client has been forcibly unmounted\n"); 1273 return 0; 1274 } 1275 1276 return 1; 1277 } 1278 1279 /* 1280 * construct our own bdi so we can control readahead, etc. 1281 */ 1282 static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0); 1283 1284 static int ceph_setup_bdi(struct super_block *sb, struct ceph_fs_client *fsc) 1285 { 1286 int err; 1287 1288 err = super_setup_bdi_name(sb, "ceph-%ld", 1289 atomic_long_inc_return(&bdi_seq)); 1290 if (err) 1291 return err; 1292 1293 /* set ra_pages based on rasize mount option? */ 1294 sb->s_bdi->ra_pages = fsc->mount_options->rasize >> PAGE_SHIFT; 1295 1296 /* set io_pages based on max osd read size */ 1297 sb->s_bdi->io_pages = fsc->mount_options->rsize >> PAGE_SHIFT; 1298 1299 return 0; 1300 } 1301 1302 static int ceph_get_tree(struct fs_context *fc) 1303 { 1304 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 1305 struct ceph_mount_options *fsopt = pctx->opts; 1306 struct super_block *sb; 1307 struct ceph_fs_client *fsc; 1308 struct dentry *res; 1309 int (*compare_super)(struct super_block *, struct fs_context *) = 1310 ceph_compare_super; 1311 int err; 1312 1313 dout("ceph_get_tree\n"); 1314 1315 if (!fc->source) 1316 return invalfc(fc, "No source"); 1317 if (fsopt->new_dev_syntax && !fsopt->mon_addr) 1318 return invalfc(fc, "No monitor address"); 1319 1320 /* create client (which we may/may not use) */ 1321 fsc = create_fs_client(pctx->opts, pctx->copts); 1322 pctx->opts = NULL; 1323 pctx->copts = NULL; 1324 if (IS_ERR(fsc)) { 1325 err = PTR_ERR(fsc); 1326 goto out_final; 1327 } 1328 1329 err = ceph_mdsc_init(fsc); 1330 if (err < 0) 1331 goto out; 1332 1333 if (ceph_test_opt(fsc->client, NOSHARE)) 1334 compare_super = NULL; 1335 1336 fc->s_fs_info = fsc; 1337 sb = sget_fc(fc, compare_super, ceph_set_super); 1338 fc->s_fs_info = NULL; 1339 if (IS_ERR(sb)) { 1340 err = PTR_ERR(sb); 1341 goto out; 1342 } 1343 1344 if (ceph_sb_to_fs_client(sb) != fsc) { 1345 destroy_fs_client(fsc); 1346 fsc = ceph_sb_to_fs_client(sb); 1347 dout("get_sb got existing client %p\n", fsc); 1348 } else { 1349 dout("get_sb using new client %p\n", fsc); 1350 err = ceph_setup_bdi(sb, fsc); 1351 if (err < 0) 1352 goto out_splat; 1353 } 1354 1355 res = ceph_real_mount(fsc, fc); 1356 if (IS_ERR(res)) { 1357 err = PTR_ERR(res); 1358 goto out_splat; 1359 } 1360 1361 doutc(fsc->client, "root %p inode %p ino %llx.%llx\n", res, 1362 d_inode(res), ceph_vinop(d_inode(res))); 1363 fc->root = fsc->sb->s_root; 1364 return 0; 1365 1366 out_splat: 1367 if (!ceph_mdsmap_is_cluster_available(fsc->mdsc->mdsmap)) { 1368 pr_info("No mds server is up or the cluster is laggy\n"); 1369 err = -EHOSTUNREACH; 1370 } 1371 1372 ceph_mdsc_close_sessions(fsc->mdsc); 1373 deactivate_locked_super(sb); 1374 goto out_final; 1375 1376 out: 1377 destroy_fs_client(fsc); 1378 out_final: 1379 dout("ceph_get_tree fail %d\n", err); 1380 return err; 1381 } 1382 1383 static void ceph_free_fc(struct fs_context *fc) 1384 { 1385 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 1386 1387 if (pctx) { 1388 destroy_mount_options(pctx->opts); 1389 ceph_destroy_options(pctx->copts); 1390 kfree(pctx); 1391 } 1392 } 1393 1394 static int ceph_reconfigure_fc(struct fs_context *fc) 1395 { 1396 int err; 1397 struct ceph_parse_opts_ctx *pctx = fc->fs_private; 1398 struct ceph_mount_options *fsopt = pctx->opts; 1399 struct super_block *sb = fc->root->d_sb; 1400 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); 1401 1402 err = ceph_apply_test_dummy_encryption(sb, fc, fsopt); 1403 if (err) 1404 return err; 1405 1406 if (fsopt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS) 1407 ceph_set_mount_opt(fsc, ASYNC_DIROPS); 1408 else 1409 ceph_clear_mount_opt(fsc, ASYNC_DIROPS); 1410 1411 if (fsopt->flags & CEPH_MOUNT_OPT_SPARSEREAD) 1412 ceph_set_mount_opt(fsc, SPARSEREAD); 1413 else 1414 ceph_clear_mount_opt(fsc, SPARSEREAD); 1415 1416 if (strcmp_null(fsc->mount_options->mon_addr, fsopt->mon_addr)) { 1417 kfree(fsc->mount_options->mon_addr); 1418 fsc->mount_options->mon_addr = fsopt->mon_addr; 1419 fsopt->mon_addr = NULL; 1420 pr_notice_client(fsc->client, 1421 "monitor addresses recorded, but not used for reconnection"); 1422 } 1423 1424 sync_filesystem(sb); 1425 return 0; 1426 } 1427 1428 static const struct fs_context_operations ceph_context_ops = { 1429 .free = ceph_free_fc, 1430 .parse_param = ceph_parse_mount_param, 1431 .get_tree = ceph_get_tree, 1432 .reconfigure = ceph_reconfigure_fc, 1433 }; 1434 1435 /* 1436 * Set up the filesystem mount context. 1437 */ 1438 static int ceph_init_fs_context(struct fs_context *fc) 1439 { 1440 struct ceph_parse_opts_ctx *pctx; 1441 struct ceph_mount_options *fsopt; 1442 1443 pctx = kzalloc(sizeof(*pctx), GFP_KERNEL); 1444 if (!pctx) 1445 return -ENOMEM; 1446 1447 pctx->copts = ceph_alloc_options(); 1448 if (!pctx->copts) 1449 goto nomem; 1450 1451 pctx->opts = kzalloc(sizeof(*pctx->opts), GFP_KERNEL); 1452 if (!pctx->opts) 1453 goto nomem; 1454 1455 fsopt = pctx->opts; 1456 fsopt->flags = CEPH_MOUNT_OPT_DEFAULT; 1457 1458 fsopt->wsize = CEPH_MAX_WRITE_SIZE; 1459 fsopt->rsize = CEPH_MAX_READ_SIZE; 1460 fsopt->rasize = CEPH_RASIZE_DEFAULT; 1461 fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL); 1462 if (!fsopt->snapdir_name) 1463 goto nomem; 1464 1465 fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT; 1466 fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT; 1467 fsopt->max_readdir = CEPH_MAX_READDIR_DEFAULT; 1468 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT; 1469 fsopt->congestion_kb = default_congestion_kb(); 1470 1471 #ifdef CONFIG_CEPH_FS_POSIX_ACL 1472 fc->sb_flags |= SB_POSIXACL; 1473 #endif 1474 1475 fc->fs_private = pctx; 1476 fc->ops = &ceph_context_ops; 1477 return 0; 1478 1479 nomem: 1480 destroy_mount_options(pctx->opts); 1481 ceph_destroy_options(pctx->copts); 1482 kfree(pctx); 1483 return -ENOMEM; 1484 } 1485 1486 /* 1487 * Return true if it successfully increases the blocker counter, 1488 * or false if the mdsc is in stopping and flushed state. 1489 */ 1490 static bool __inc_stopping_blocker(struct ceph_mds_client *mdsc) 1491 { 1492 spin_lock(&mdsc->stopping_lock); 1493 if (mdsc->stopping >= CEPH_MDSC_STOPPING_FLUSHING) { 1494 spin_unlock(&mdsc->stopping_lock); 1495 return false; 1496 } 1497 atomic_inc(&mdsc->stopping_blockers); 1498 spin_unlock(&mdsc->stopping_lock); 1499 return true; 1500 } 1501 1502 static void __dec_stopping_blocker(struct ceph_mds_client *mdsc) 1503 { 1504 spin_lock(&mdsc->stopping_lock); 1505 if (!atomic_dec_return(&mdsc->stopping_blockers) && 1506 mdsc->stopping >= CEPH_MDSC_STOPPING_FLUSHING) 1507 complete_all(&mdsc->stopping_waiter); 1508 spin_unlock(&mdsc->stopping_lock); 1509 } 1510 1511 /* For metadata IO requests */ 1512 bool ceph_inc_mds_stopping_blocker(struct ceph_mds_client *mdsc, 1513 struct ceph_mds_session *session) 1514 { 1515 mutex_lock(&session->s_mutex); 1516 inc_session_sequence(session); 1517 mutex_unlock(&session->s_mutex); 1518 1519 return __inc_stopping_blocker(mdsc); 1520 } 1521 1522 void ceph_dec_mds_stopping_blocker(struct ceph_mds_client *mdsc) 1523 { 1524 __dec_stopping_blocker(mdsc); 1525 } 1526 1527 /* For data IO requests */ 1528 bool ceph_inc_osd_stopping_blocker(struct ceph_mds_client *mdsc) 1529 { 1530 return __inc_stopping_blocker(mdsc); 1531 } 1532 1533 void ceph_dec_osd_stopping_blocker(struct ceph_mds_client *mdsc) 1534 { 1535 __dec_stopping_blocker(mdsc); 1536 } 1537 1538 static void ceph_kill_sb(struct super_block *s) 1539 { 1540 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(s); 1541 struct ceph_client *cl = fsc->client; 1542 struct ceph_mds_client *mdsc = fsc->mdsc; 1543 bool wait; 1544 1545 doutc(cl, "%p\n", s); 1546 1547 ceph_mdsc_pre_umount(mdsc); 1548 flush_fs_workqueues(fsc); 1549 1550 /* 1551 * Though the kill_anon_super() will finally trigger the 1552 * sync_filesystem() anyway, we still need to do it here and 1553 * then bump the stage of shutdown. This will allow us to 1554 * drop any further message, which will increase the inodes' 1555 * i_count reference counters but makes no sense any more, 1556 * from MDSs. 1557 * 1558 * Without this when evicting the inodes it may fail in the 1559 * kill_anon_super(), which will trigger a warning when 1560 * destroying the fscrypt keyring and then possibly trigger 1561 * a further crash in ceph module when the iput() tries to 1562 * evict the inodes later. 1563 */ 1564 sync_filesystem(s); 1565 1566 spin_lock(&mdsc->stopping_lock); 1567 mdsc->stopping = CEPH_MDSC_STOPPING_FLUSHING; 1568 wait = !!atomic_read(&mdsc->stopping_blockers); 1569 spin_unlock(&mdsc->stopping_lock); 1570 1571 if (wait && atomic_read(&mdsc->stopping_blockers)) { 1572 long timeleft = wait_for_completion_killable_timeout( 1573 &mdsc->stopping_waiter, 1574 fsc->client->options->mount_timeout); 1575 if (!timeleft) /* timed out */ 1576 pr_warn_client(cl, "umount timed out, %ld\n", timeleft); 1577 else if (timeleft < 0) /* killed */ 1578 pr_warn_client(cl, "umount was killed, %ld\n", timeleft); 1579 } 1580 1581 mdsc->stopping = CEPH_MDSC_STOPPING_FLUSHED; 1582 kill_anon_super(s); 1583 1584 fsc->client->extra_mon_dispatch = NULL; 1585 ceph_fs_debugfs_cleanup(fsc); 1586 1587 ceph_fscache_unregister_fs(fsc); 1588 1589 destroy_fs_client(fsc); 1590 } 1591 1592 static struct file_system_type ceph_fs_type = { 1593 .owner = THIS_MODULE, 1594 .name = "ceph", 1595 .init_fs_context = ceph_init_fs_context, 1596 .kill_sb = ceph_kill_sb, 1597 .fs_flags = FS_RENAME_DOES_D_MOVE | FS_ALLOW_IDMAP, 1598 }; 1599 MODULE_ALIAS_FS("ceph"); 1600 1601 int ceph_force_reconnect(struct super_block *sb) 1602 { 1603 struct ceph_fs_client *fsc = ceph_sb_to_fs_client(sb); 1604 int err = 0; 1605 1606 fsc->mount_state = CEPH_MOUNT_RECOVER; 1607 __ceph_umount_begin(fsc); 1608 1609 /* Make sure all page caches get invalidated. 1610 * see remove_session_caps_cb() */ 1611 flush_workqueue(fsc->inode_wq); 1612 1613 /* In case that we were blocklisted. This also reset 1614 * all mon/osd connections */ 1615 ceph_reset_client_addr(fsc->client); 1616 1617 ceph_osdc_clear_abort_err(&fsc->client->osdc); 1618 1619 fsc->blocklisted = false; 1620 fsc->mount_state = CEPH_MOUNT_MOUNTED; 1621 1622 if (sb->s_root) { 1623 err = __ceph_do_getattr(d_inode(sb->s_root), NULL, 1624 CEPH_STAT_CAP_INODE, true); 1625 } 1626 return err; 1627 } 1628 1629 static int __init init_ceph(void) 1630 { 1631 int ret = init_caches(); 1632 if (ret) 1633 goto out; 1634 1635 ceph_flock_init(); 1636 ret = register_filesystem(&ceph_fs_type); 1637 if (ret) 1638 goto out_caches; 1639 1640 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL); 1641 1642 return 0; 1643 1644 out_caches: 1645 destroy_caches(); 1646 out: 1647 return ret; 1648 } 1649 1650 static void __exit exit_ceph(void) 1651 { 1652 dout("exit_ceph\n"); 1653 unregister_filesystem(&ceph_fs_type); 1654 destroy_caches(); 1655 } 1656 1657 static int param_set_metrics(const char *val, const struct kernel_param *kp) 1658 { 1659 struct ceph_fs_client *fsc; 1660 int ret; 1661 1662 ret = param_set_bool(val, kp); 1663 if (ret) { 1664 pr_err("Failed to parse sending metrics switch value '%s'\n", 1665 val); 1666 return ret; 1667 } else if (!disable_send_metrics) { 1668 // wake up all the mds clients 1669 spin_lock(&ceph_fsc_lock); 1670 list_for_each_entry(fsc, &ceph_fsc_list, metric_wakeup) { 1671 metric_schedule_delayed(&fsc->mdsc->metric); 1672 } 1673 spin_unlock(&ceph_fsc_lock); 1674 } 1675 1676 return 0; 1677 } 1678 1679 static const struct kernel_param_ops param_ops_metrics = { 1680 .set = param_set_metrics, 1681 .get = param_get_bool, 1682 }; 1683 1684 bool disable_send_metrics = false; 1685 module_param_cb(disable_send_metrics, ¶m_ops_metrics, &disable_send_metrics, 0644); 1686 MODULE_PARM_DESC(disable_send_metrics, "Enable sending perf metrics to ceph cluster (default: on)"); 1687 1688 /* for both v1 and v2 syntax */ 1689 static bool mount_support = true; 1690 static const struct kernel_param_ops param_ops_mount_syntax = { 1691 .get = param_get_bool, 1692 }; 1693 module_param_cb(mount_syntax_v1, ¶m_ops_mount_syntax, &mount_support, 0444); 1694 module_param_cb(mount_syntax_v2, ¶m_ops_mount_syntax, &mount_support, 0444); 1695 1696 bool enable_unsafe_idmap = false; 1697 module_param(enable_unsafe_idmap, bool, 0644); 1698 MODULE_PARM_DESC(enable_unsafe_idmap, 1699 "Allow to use idmapped mounts with MDS without CEPHFS_FEATURE_HAS_OWNER_UIDGID"); 1700 1701 module_init(init_ceph); 1702 module_exit(exit_ceph); 1703 1704 MODULE_AUTHOR("Sage Weil <sage@newdream.net>"); 1705 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>"); 1706 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>"); 1707 MODULE_DESCRIPTION("Ceph filesystem for Linux"); 1708 MODULE_LICENSE("GPL"); 1709