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