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