2 #include <linux/ceph/ceph_debug.h>
4 #include <linux/backing-dev.h>
5 #include <linux/ctype.h>
7 #include <linux/inet.h>
9 #include <linux/module.h>
10 #include <linux/mount.h>
11 #include <linux/parser.h>
12 #include <linux/sched.h>
13 #include <linux/seq_file.h>
14 #include <linux/slab.h>
15 #include <linux/statfs.h>
16 #include <linux/string.h>
19 #include "mds_client.h"
22 #include <linux/ceph/ceph_features.h>
23 #include <linux/ceph/decode.h>
24 #include <linux/ceph/mon_client.h>
25 #include <linux/ceph/auth.h>
26 #include <linux/ceph/debugfs.h>
29 * Ceph superblock operations
31 * Handle the basics of mounting, unmounting.
37 static void ceph_put_super(struct super_block *s)
39 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
42 ceph_mdsc_close_sessions(fsc->mdsc);
45 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
47 struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
48 struct ceph_mon_client *monc = &fsc->client->monc;
49 struct ceph_statfs st;
54 if (fsc->mdsc->mdsmap->m_num_data_pg_pools == 1) {
55 data_pool = fsc->mdsc->mdsmap->m_data_pg_pools[0];
57 data_pool = CEPH_NOPOOL;
61 err = ceph_monc_do_statfs(monc, data_pool, &st);
66 buf->f_type = CEPH_SUPER_MAGIC; /* ?? */
69 * express utilization in terms of large blocks to avoid
70 * overflow on 32-bit machines.
72 * NOTE: for the time being, we make bsize == frsize to humor
73 * not-yet-ancient versions of glibc that are broken.
74 * Someday, we will probably want to report a real block
75 * size... whatever that may mean for a network file system!
77 buf->f_bsize = 1 << CEPH_BLOCK_SHIFT;
78 buf->f_frsize = 1 << CEPH_BLOCK_SHIFT;
81 * By default use root quota for stats; fallback to overall filesystem
82 * usage if using 'noquotadf' mount option or if the root dir doesn't
83 * have max_bytes quota set.
85 if (ceph_test_mount_opt(fsc, NOQUOTADF) ||
86 !ceph_quota_update_statfs(fsc, buf)) {
87 buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
88 buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
89 buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
92 buf->f_files = le64_to_cpu(st.num_objects);
94 buf->f_namelen = NAME_MAX;
96 /* Must convert the fsid, for consistent values across arches */
97 mutex_lock(&monc->mutex);
98 fsid = le64_to_cpu(*(__le64 *)(&monc->monmap->fsid)) ^
99 le64_to_cpu(*((__le64 *)&monc->monmap->fsid + 1));
100 mutex_unlock(&monc->mutex);
102 buf->f_fsid.val[0] = fsid & 0xffffffff;
103 buf->f_fsid.val[1] = fsid >> 32;
108 static int ceph_sync_fs(struct super_block *sb, int wait)
110 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
113 dout("sync_fs (non-blocking)\n");
114 ceph_flush_dirty_caps(fsc->mdsc);
115 dout("sync_fs (non-blocking) done\n");
119 dout("sync_fs (blocking)\n");
120 ceph_osdc_sync(&fsc->client->osdc);
121 ceph_mdsc_sync(fsc->mdsc);
122 dout("sync_fs (blocking) done\n");
133 Opt_caps_wanted_delay_min,
134 Opt_caps_wanted_delay_max,
135 Opt_readdir_max_entries,
136 Opt_readdir_max_bytes,
144 /* string args above */
159 Opt_require_active_mds,
160 Opt_norequire_active_mds,
161 #ifdef CONFIG_CEPH_FS_POSIX_ACL
169 static match_table_t fsopt_tokens = {
170 {Opt_wsize, "wsize=%d"},
171 {Opt_rsize, "rsize=%d"},
172 {Opt_rasize, "rasize=%d"},
173 {Opt_caps_wanted_delay_min, "caps_wanted_delay_min=%d"},
174 {Opt_caps_wanted_delay_max, "caps_wanted_delay_max=%d"},
175 {Opt_readdir_max_entries, "readdir_max_entries=%d"},
176 {Opt_readdir_max_bytes, "readdir_max_bytes=%d"},
177 {Opt_congestion_kb, "write_congestion_kb=%d"},
179 {Opt_snapdirname, "snapdirname=%s"},
180 {Opt_mds_namespace, "mds_namespace=%s"},
181 {Opt_fscache_uniq, "fsc=%s"},
182 /* string args above */
183 {Opt_dirstat, "dirstat"},
184 {Opt_nodirstat, "nodirstat"},
185 {Opt_rbytes, "rbytes"},
186 {Opt_norbytes, "norbytes"},
187 {Opt_asyncreaddir, "asyncreaddir"},
188 {Opt_noasyncreaddir, "noasyncreaddir"},
189 {Opt_dcache, "dcache"},
190 {Opt_nodcache, "nodcache"},
191 {Opt_ino32, "ino32"},
192 {Opt_noino32, "noino32"},
193 {Opt_fscache, "fsc"},
194 {Opt_nofscache, "nofsc"},
195 {Opt_poolperm, "poolperm"},
196 {Opt_nopoolperm, "nopoolperm"},
197 {Opt_require_active_mds, "require_active_mds"},
198 {Opt_norequire_active_mds, "norequire_active_mds"},
199 #ifdef CONFIG_CEPH_FS_POSIX_ACL
202 {Opt_noacl, "noacl"},
203 {Opt_quotadf, "quotadf"},
204 {Opt_noquotadf, "noquotadf"},
209 * Remove adjacent slashes and then the trailing slash, unless it is
210 * the only remaining character.
212 * E.g. "//dir1////dir2///" --> "/dir1/dir2", "///" --> "/".
214 static void canonicalize_path(char *path)
218 for (i = 0; path[i] != '\0'; i++) {
219 if (path[i] != '/' || j < 1 || path[j - 1] != '/')
223 if (j > 1 && path[j - 1] == '/')
228 static int parse_fsopt_token(char *c, void *private)
230 struct ceph_mount_options *fsopt = private;
231 substring_t argstr[MAX_OPT_ARGS];
232 int token, intval, ret;
234 token = match_token((char *)c, fsopt_tokens, argstr);
238 if (token < Opt_last_int) {
239 ret = match_int(&argstr[0], &intval);
241 pr_err("bad option arg (not int) at '%s'\n", c);
244 dout("got int token %d val %d\n", token, intval);
245 } else if (token > Opt_last_int && token < Opt_last_string) {
246 dout("got string token %d val %s\n", token,
249 dout("got token %d\n", token);
253 case Opt_snapdirname:
254 kfree(fsopt->snapdir_name);
255 fsopt->snapdir_name = kstrndup(argstr[0].from,
256 argstr[0].to-argstr[0].from,
258 if (!fsopt->snapdir_name)
261 case Opt_mds_namespace:
262 kfree(fsopt->mds_namespace);
263 fsopt->mds_namespace = kstrndup(argstr[0].from,
264 argstr[0].to-argstr[0].from,
266 if (!fsopt->mds_namespace)
269 case Opt_fscache_uniq:
270 #ifdef CONFIG_CEPH_FSCACHE
271 kfree(fsopt->fscache_uniq);
272 fsopt->fscache_uniq = kstrndup(argstr[0].from,
273 argstr[0].to-argstr[0].from,
275 if (!fsopt->fscache_uniq)
277 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE;
280 pr_err("fscache support is disabled\n");
284 if (intval < (int)PAGE_SIZE || intval > CEPH_MAX_WRITE_SIZE)
286 fsopt->wsize = ALIGN(intval, PAGE_SIZE);
289 if (intval < (int)PAGE_SIZE || intval > CEPH_MAX_READ_SIZE)
291 fsopt->rsize = ALIGN(intval, PAGE_SIZE);
296 fsopt->rasize = ALIGN(intval, PAGE_SIZE);
298 case Opt_caps_wanted_delay_min:
301 fsopt->caps_wanted_delay_min = intval;
303 case Opt_caps_wanted_delay_max:
306 fsopt->caps_wanted_delay_max = intval;
308 case Opt_readdir_max_entries:
311 fsopt->max_readdir = intval;
313 case Opt_readdir_max_bytes:
314 if (intval < (int)PAGE_SIZE && intval != 0)
316 fsopt->max_readdir_bytes = intval;
318 case Opt_congestion_kb:
319 if (intval < 1024) /* at least 1M */
321 fsopt->congestion_kb = intval;
324 fsopt->flags |= CEPH_MOUNT_OPT_DIRSTAT;
327 fsopt->flags &= ~CEPH_MOUNT_OPT_DIRSTAT;
330 fsopt->flags |= CEPH_MOUNT_OPT_RBYTES;
333 fsopt->flags &= ~CEPH_MOUNT_OPT_RBYTES;
335 case Opt_asyncreaddir:
336 fsopt->flags &= ~CEPH_MOUNT_OPT_NOASYNCREADDIR;
338 case Opt_noasyncreaddir:
339 fsopt->flags |= CEPH_MOUNT_OPT_NOASYNCREADDIR;
342 fsopt->flags |= CEPH_MOUNT_OPT_DCACHE;
345 fsopt->flags &= ~CEPH_MOUNT_OPT_DCACHE;
348 fsopt->flags |= CEPH_MOUNT_OPT_INO32;
351 fsopt->flags &= ~CEPH_MOUNT_OPT_INO32;
354 #ifdef CONFIG_CEPH_FSCACHE
355 fsopt->flags |= CEPH_MOUNT_OPT_FSCACHE;
356 kfree(fsopt->fscache_uniq);
357 fsopt->fscache_uniq = NULL;
360 pr_err("fscache support is disabled\n");
364 fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE;
365 kfree(fsopt->fscache_uniq);
366 fsopt->fscache_uniq = NULL;
369 fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM;
372 fsopt->flags |= CEPH_MOUNT_OPT_NOPOOLPERM;
374 case Opt_require_active_mds:
375 fsopt->flags &= ~CEPH_MOUNT_OPT_MOUNTWAIT;
377 case Opt_norequire_active_mds:
378 fsopt->flags |= CEPH_MOUNT_OPT_MOUNTWAIT;
381 fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF;
384 fsopt->flags |= CEPH_MOUNT_OPT_NOQUOTADF;
386 #ifdef CONFIG_CEPH_FS_POSIX_ACL
388 fsopt->sb_flags |= SB_POSIXACL;
392 fsopt->sb_flags &= ~SB_POSIXACL;
400 static void destroy_mount_options(struct ceph_mount_options *args)
402 dout("destroy_mount_options %p\n", args);
403 kfree(args->snapdir_name);
404 kfree(args->mds_namespace);
405 kfree(args->server_path);
406 kfree(args->fscache_uniq);
410 static int strcmp_null(const char *s1, const char *s2)
418 return strcmp(s1, s2);
421 static int compare_mount_options(struct ceph_mount_options *new_fsopt,
422 struct ceph_options *new_opt,
423 struct ceph_fs_client *fsc)
425 struct ceph_mount_options *fsopt1 = new_fsopt;
426 struct ceph_mount_options *fsopt2 = fsc->mount_options;
427 int ofs = offsetof(struct ceph_mount_options, snapdir_name);
430 ret = memcmp(fsopt1, fsopt2, ofs);
434 ret = strcmp_null(fsopt1->snapdir_name, fsopt2->snapdir_name);
438 ret = strcmp_null(fsopt1->mds_namespace, fsopt2->mds_namespace);
442 ret = strcmp_null(fsopt1->server_path, fsopt2->server_path);
446 ret = strcmp_null(fsopt1->fscache_uniq, fsopt2->fscache_uniq);
450 return ceph_compare_options(new_opt, fsc->client);
453 static int parse_mount_options(struct ceph_mount_options **pfsopt,
454 struct ceph_options **popt,
455 int flags, char *options,
456 const char *dev_name)
458 struct ceph_mount_options *fsopt;
459 const char *dev_name_end;
462 if (!dev_name || !*dev_name)
465 fsopt = kzalloc(sizeof(*fsopt), GFP_KERNEL);
469 dout("parse_mount_options %p, dev_name '%s'\n", fsopt, dev_name);
471 fsopt->sb_flags = flags;
472 fsopt->flags = CEPH_MOUNT_OPT_DEFAULT;
474 fsopt->wsize = CEPH_MAX_WRITE_SIZE;
475 fsopt->rsize = CEPH_MAX_READ_SIZE;
476 fsopt->rasize = CEPH_RASIZE_DEFAULT;
477 fsopt->snapdir_name = kstrdup(CEPH_SNAPDIRNAME_DEFAULT, GFP_KERNEL);
478 if (!fsopt->snapdir_name) {
483 fsopt->caps_wanted_delay_min = CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT;
484 fsopt->caps_wanted_delay_max = CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT;
485 fsopt->max_readdir = CEPH_MAX_READDIR_DEFAULT;
486 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT;
487 fsopt->congestion_kb = default_congestion_kb();
490 * Distinguish the server list from the path in "dev_name".
491 * Internally we do not include the leading '/' in the path.
493 * "dev_name" will look like:
494 * <server_spec>[,<server_spec>...]:[<path>]
496 * <server_spec> is <ip>[:<port>]
497 * <path> is optional, but if present must begin with '/'
499 dev_name_end = strchr(dev_name, '/');
502 * The server_path will include the whole chars from userland
503 * including the leading '/'.
505 fsopt->server_path = kstrdup(dev_name_end, GFP_KERNEL);
506 if (!fsopt->server_path) {
511 canonicalize_path(fsopt->server_path);
513 dev_name_end = dev_name + strlen(dev_name);
516 dev_name_end--; /* back up to ':' separator */
517 if (dev_name_end < dev_name || *dev_name_end != ':') {
518 pr_err("device name is missing path (no : separator in %s)\n",
522 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name);
523 if (fsopt->server_path)
524 dout("server path '%s'\n", fsopt->server_path);
526 *popt = ceph_parse_options(options, dev_name, dev_name_end,
527 parse_fsopt_token, (void *)fsopt);
529 err = PTR_ERR(*popt);
538 destroy_mount_options(fsopt);
543 * ceph_show_options - Show mount options in /proc/mounts
544 * @m: seq_file to write to
545 * @root: root of that (sub)tree
547 static int ceph_show_options(struct seq_file *m, struct dentry *root)
549 struct ceph_fs_client *fsc = ceph_sb_to_client(root->d_sb);
550 struct ceph_mount_options *fsopt = fsc->mount_options;
554 /* a comma between MNT/MS and client options */
558 ret = ceph_print_client_options(m, fsc->client);
562 /* retract our comma if no client options */
566 if (fsopt->flags & CEPH_MOUNT_OPT_DIRSTAT)
567 seq_puts(m, ",dirstat");
568 if ((fsopt->flags & CEPH_MOUNT_OPT_RBYTES))
569 seq_puts(m, ",rbytes");
570 if (fsopt->flags & CEPH_MOUNT_OPT_NOASYNCREADDIR)
571 seq_puts(m, ",noasyncreaddir");
572 if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0)
573 seq_puts(m, ",nodcache");
574 if (fsopt->flags & CEPH_MOUNT_OPT_INO32)
575 seq_puts(m, ",ino32");
576 if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) {
577 seq_show_option(m, "fsc", fsopt->fscache_uniq);
579 if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM)
580 seq_puts(m, ",nopoolperm");
581 if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF)
582 seq_puts(m, ",noquotadf");
584 #ifdef CONFIG_CEPH_FS_POSIX_ACL
585 if (fsopt->sb_flags & SB_POSIXACL)
588 seq_puts(m, ",noacl");
591 if (fsopt->mds_namespace)
592 seq_show_option(m, "mds_namespace", fsopt->mds_namespace);
593 if (fsopt->wsize != CEPH_MAX_WRITE_SIZE)
594 seq_printf(m, ",wsize=%d", fsopt->wsize);
595 if (fsopt->rsize != CEPH_MAX_READ_SIZE)
596 seq_printf(m, ",rsize=%d", fsopt->rsize);
597 if (fsopt->rasize != CEPH_RASIZE_DEFAULT)
598 seq_printf(m, ",rasize=%d", fsopt->rasize);
599 if (fsopt->congestion_kb != default_congestion_kb())
600 seq_printf(m, ",write_congestion_kb=%d", fsopt->congestion_kb);
601 if (fsopt->caps_wanted_delay_min != CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT)
602 seq_printf(m, ",caps_wanted_delay_min=%d",
603 fsopt->caps_wanted_delay_min);
604 if (fsopt->caps_wanted_delay_max != CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT)
605 seq_printf(m, ",caps_wanted_delay_max=%d",
606 fsopt->caps_wanted_delay_max);
607 if (fsopt->max_readdir != CEPH_MAX_READDIR_DEFAULT)
608 seq_printf(m, ",readdir_max_entries=%d", fsopt->max_readdir);
609 if (fsopt->max_readdir_bytes != CEPH_MAX_READDIR_BYTES_DEFAULT)
610 seq_printf(m, ",readdir_max_bytes=%d", fsopt->max_readdir_bytes);
611 if (strcmp(fsopt->snapdir_name, CEPH_SNAPDIRNAME_DEFAULT))
612 seq_show_option(m, "snapdirname", fsopt->snapdir_name);
618 * handle any mon messages the standard library doesn't understand.
619 * return error if we don't either.
621 static int extra_mon_dispatch(struct ceph_client *client, struct ceph_msg *msg)
623 struct ceph_fs_client *fsc = client->private;
624 int type = le16_to_cpu(msg->hdr.type);
627 case CEPH_MSG_MDS_MAP:
628 ceph_mdsc_handle_mdsmap(fsc->mdsc, msg);
630 case CEPH_MSG_FS_MAP_USER:
631 ceph_mdsc_handle_fsmap(fsc->mdsc, msg);
639 * create a new fs client
641 * Success or not, this function consumes @fsopt and @opt.
643 static struct ceph_fs_client *create_fs_client(struct ceph_mount_options *fsopt,
644 struct ceph_options *opt)
646 struct ceph_fs_client *fsc;
651 fsc = kzalloc(sizeof(*fsc), GFP_KERNEL);
657 fsc->client = ceph_create_client(opt, fsc);
658 if (IS_ERR(fsc->client)) {
659 err = PTR_ERR(fsc->client);
662 opt = NULL; /* fsc->client now owns this */
664 fsc->client->extra_mon_dispatch = extra_mon_dispatch;
665 fsc->client->osdc.abort_on_full = true;
667 if (!fsopt->mds_namespace) {
668 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_MDSMAP,
671 ceph_monc_want_map(&fsc->client->monc, CEPH_SUB_FSMAP,
675 fsc->mount_options = fsopt;
678 fsc->mount_state = CEPH_MOUNT_MOUNTING;
680 atomic_long_set(&fsc->writeback_count, 0);
684 * The number of concurrent works can be high but they don't need
685 * to be processed in parallel, limit concurrency.
687 fsc->wb_wq = alloc_workqueue("ceph-writeback", 0, 1);
690 fsc->pg_inv_wq = alloc_workqueue("ceph-pg-invalid", 0, 1);
693 fsc->trunc_wq = alloc_workqueue("ceph-trunc", 0, 1);
697 /* set up mempools */
699 page_count = fsc->mount_options->wsize >> PAGE_SHIFT;
700 size = sizeof (struct page *) * (page_count ? page_count : 1);
701 fsc->wb_pagevec_pool = mempool_create_kmalloc_pool(10, size);
702 if (!fsc->wb_pagevec_pool)
706 fsc->min_caps = fsopt->max_readdir;
711 destroy_workqueue(fsc->trunc_wq);
713 destroy_workqueue(fsc->pg_inv_wq);
715 destroy_workqueue(fsc->wb_wq);
717 ceph_destroy_client(fsc->client);
721 ceph_destroy_options(opt);
722 destroy_mount_options(fsopt);
726 static void flush_fs_workqueues(struct ceph_fs_client *fsc)
728 flush_workqueue(fsc->wb_wq);
729 flush_workqueue(fsc->pg_inv_wq);
730 flush_workqueue(fsc->trunc_wq);
733 static void destroy_fs_client(struct ceph_fs_client *fsc)
735 dout("destroy_fs_client %p\n", fsc);
737 destroy_workqueue(fsc->wb_wq);
738 destroy_workqueue(fsc->pg_inv_wq);
739 destroy_workqueue(fsc->trunc_wq);
741 mempool_destroy(fsc->wb_pagevec_pool);
743 destroy_mount_options(fsc->mount_options);
745 ceph_destroy_client(fsc->client);
748 dout("destroy_fs_client %p done\n", fsc);
754 struct kmem_cache *ceph_inode_cachep;
755 struct kmem_cache *ceph_cap_cachep;
756 struct kmem_cache *ceph_cap_flush_cachep;
757 struct kmem_cache *ceph_dentry_cachep;
758 struct kmem_cache *ceph_file_cachep;
759 struct kmem_cache *ceph_dir_file_cachep;
761 static void ceph_inode_init_once(void *foo)
763 struct ceph_inode_info *ci = foo;
764 inode_init_once(&ci->vfs_inode);
767 static int __init init_caches(void)
771 ceph_inode_cachep = kmem_cache_create("ceph_inode_info",
772 sizeof(struct ceph_inode_info),
773 __alignof__(struct ceph_inode_info),
774 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
775 SLAB_ACCOUNT, ceph_inode_init_once);
776 if (!ceph_inode_cachep)
779 ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD);
780 if (!ceph_cap_cachep)
782 ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush,
783 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
784 if (!ceph_cap_flush_cachep)
787 ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info,
788 SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
789 if (!ceph_dentry_cachep)
792 ceph_file_cachep = KMEM_CACHE(ceph_file_info, SLAB_MEM_SPREAD);
793 if (!ceph_file_cachep)
796 ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD);
797 if (!ceph_dir_file_cachep)
800 error = ceph_fscache_register();
807 kmem_cache_destroy(ceph_dir_file_cachep);
809 kmem_cache_destroy(ceph_file_cachep);
811 kmem_cache_destroy(ceph_dentry_cachep);
813 kmem_cache_destroy(ceph_cap_flush_cachep);
815 kmem_cache_destroy(ceph_cap_cachep);
817 kmem_cache_destroy(ceph_inode_cachep);
821 static void destroy_caches(void)
824 * Make sure all delayed rcu free inodes are flushed before we
829 kmem_cache_destroy(ceph_inode_cachep);
830 kmem_cache_destroy(ceph_cap_cachep);
831 kmem_cache_destroy(ceph_cap_flush_cachep);
832 kmem_cache_destroy(ceph_dentry_cachep);
833 kmem_cache_destroy(ceph_file_cachep);
834 kmem_cache_destroy(ceph_dir_file_cachep);
836 ceph_fscache_unregister();
840 * ceph_umount_begin - initiate forced umount. Tear down down the
841 * mount, skipping steps that may hang while waiting for server(s).
843 static void ceph_umount_begin(struct super_block *sb)
845 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
847 dout("ceph_umount_begin - starting forced umount\n");
850 fsc->mount_state = CEPH_MOUNT_SHUTDOWN;
851 ceph_osdc_abort_requests(&fsc->client->osdc, -EIO);
852 ceph_mdsc_force_umount(fsc->mdsc);
856 static int ceph_remount(struct super_block *sb, int *flags, char *data)
862 static const struct super_operations ceph_super_ops = {
863 .alloc_inode = ceph_alloc_inode,
864 .destroy_inode = ceph_destroy_inode,
865 .write_inode = ceph_write_inode,
866 .drop_inode = ceph_drop_inode,
867 .evict_inode = ceph_evict_inode,
868 .sync_fs = ceph_sync_fs,
869 .put_super = ceph_put_super,
870 .remount_fs = ceph_remount,
871 .show_options = ceph_show_options,
872 .statfs = ceph_statfs,
873 .umount_begin = ceph_umount_begin,
877 * Bootstrap mount by opening the root directory. Note the mount
878 * @started time from caller, and time out if this takes too long.
880 static struct dentry *open_root_dentry(struct ceph_fs_client *fsc,
882 unsigned long started)
884 struct ceph_mds_client *mdsc = fsc->mdsc;
885 struct ceph_mds_request *req = NULL;
890 dout("open_root_inode opening '%s'\n", path);
891 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS);
893 return ERR_CAST(req);
894 req->r_path1 = kstrdup(path, GFP_NOFS);
896 root = ERR_PTR(-ENOMEM);
900 req->r_ino1.ino = CEPH_INO_ROOT;
901 req->r_ino1.snap = CEPH_NOSNAP;
902 req->r_started = started;
903 req->r_timeout = fsc->client->options->mount_timeout;
904 req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE);
906 err = ceph_mdsc_do_request(mdsc, NULL, req);
908 struct inode *inode = req->r_target_inode;
909 req->r_target_inode = NULL;
910 dout("open_root_inode success\n");
911 root = d_make_root(inode);
913 root = ERR_PTR(-ENOMEM);
916 dout("open_root_inode success, root dentry is %p\n", root);
921 ceph_mdsc_put_request(req);
926 * mount: join the ceph cluster, and open root directory.
928 static struct dentry *ceph_real_mount(struct ceph_fs_client *fsc)
931 unsigned long started = jiffies; /* note the start time */
934 dout("mount start %p\n", fsc);
935 mutex_lock(&fsc->client->mount_mutex);
937 if (!fsc->sb->s_root) {
938 const char *path = fsc->mount_options->server_path ?
939 fsc->mount_options->server_path + 1 : "";
941 err = __ceph_open_session(fsc->client, started);
946 if (fsc->mount_options->flags & CEPH_MOUNT_OPT_FSCACHE) {
947 err = ceph_fscache_register_fs(fsc);
952 dout("mount opening path '%s'\n", path);
954 err = ceph_fs_debugfs_init(fsc);
958 root = open_root_dentry(fsc, path, started);
963 fsc->sb->s_root = dget(root);
965 root = dget(fsc->sb->s_root);
968 fsc->mount_state = CEPH_MOUNT_MOUNTED;
969 dout("mount success\n");
970 mutex_unlock(&fsc->client->mount_mutex);
974 mutex_unlock(&fsc->client->mount_mutex);
978 static int ceph_set_super(struct super_block *s, void *data)
980 struct ceph_fs_client *fsc = data;
983 dout("set_super %p data %p\n", s, data);
985 s->s_flags = fsc->mount_options->sb_flags;
986 s->s_maxbytes = MAX_LFS_FILESIZE;
988 s->s_xattr = ceph_xattr_handlers;
991 fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
993 s->s_op = &ceph_super_ops;
994 s->s_d_op = &ceph_dentry_ops;
995 s->s_export_op = &ceph_export_ops;
997 s->s_time_gran = 1000; /* 1000 ns == 1 us */
999 ret = set_anon_super(s, NULL); /* what is that second arg for? */
1006 s->s_fs_info = NULL;
1012 * share superblock if same fs AND options
1014 static int ceph_compare_super(struct super_block *sb, void *data)
1016 struct ceph_fs_client *new = data;
1017 struct ceph_mount_options *fsopt = new->mount_options;
1018 struct ceph_options *opt = new->client->options;
1019 struct ceph_fs_client *other = ceph_sb_to_client(sb);
1021 dout("ceph_compare_super %p\n", sb);
1023 if (compare_mount_options(fsopt, opt, other)) {
1024 dout("monitor(s)/mount options don't match\n");
1027 if ((opt->flags & CEPH_OPT_FSID) &&
1028 ceph_fsid_compare(&opt->fsid, &other->client->fsid)) {
1029 dout("fsid doesn't match\n");
1032 if (fsopt->sb_flags != other->mount_options->sb_flags) {
1033 dout("flags differ\n");
1040 * construct our own bdi so we can control readahead, etc.
1042 static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
1044 static int ceph_setup_bdi(struct super_block *sb, struct ceph_fs_client *fsc)
1048 err = super_setup_bdi_name(sb, "ceph-%ld",
1049 atomic_long_inc_return(&bdi_seq));
1053 /* set ra_pages based on rasize mount option? */
1054 sb->s_bdi->ra_pages = fsc->mount_options->rasize >> PAGE_SHIFT;
1056 /* set io_pages based on max osd read size */
1057 sb->s_bdi->io_pages = fsc->mount_options->rsize >> PAGE_SHIFT;
1062 static struct dentry *ceph_mount(struct file_system_type *fs_type,
1063 int flags, const char *dev_name, void *data)
1065 struct super_block *sb;
1066 struct ceph_fs_client *fsc;
1069 int (*compare_super)(struct super_block *, void *) = ceph_compare_super;
1070 struct ceph_mount_options *fsopt = NULL;
1071 struct ceph_options *opt = NULL;
1073 dout("ceph_mount\n");
1075 #ifdef CONFIG_CEPH_FS_POSIX_ACL
1076 flags |= SB_POSIXACL;
1078 err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);
1084 /* create client (which we may/may not use) */
1085 fsc = create_fs_client(fsopt, opt);
1087 res = ERR_CAST(fsc);
1091 err = ceph_mdsc_init(fsc);
1097 if (ceph_test_opt(fsc->client, NOSHARE))
1098 compare_super = NULL;
1099 sb = sget(fs_type, compare_super, ceph_set_super, flags, fsc);
1105 if (ceph_sb_to_client(sb) != fsc) {
1106 ceph_mdsc_destroy(fsc);
1107 destroy_fs_client(fsc);
1108 fsc = ceph_sb_to_client(sb);
1109 dout("get_sb got existing client %p\n", fsc);
1111 dout("get_sb using new client %p\n", fsc);
1112 err = ceph_setup_bdi(sb, fsc);
1119 res = ceph_real_mount(fsc);
1122 dout("root %p inode %p ino %llx.%llx\n", res,
1123 d_inode(res), ceph_vinop(d_inode(res)));
1127 if (!ceph_mdsmap_is_cluster_available(fsc->mdsc->mdsmap)) {
1128 pr_info("No mds server is up or the cluster is laggy\n");
1129 err = -EHOSTUNREACH;
1132 ceph_mdsc_close_sessions(fsc->mdsc);
1133 deactivate_locked_super(sb);
1137 ceph_mdsc_destroy(fsc);
1138 destroy_fs_client(fsc);
1140 dout("ceph_mount fail %ld\n", PTR_ERR(res));
1144 static void ceph_kill_sb(struct super_block *s)
1146 struct ceph_fs_client *fsc = ceph_sb_to_client(s);
1147 dev_t dev = s->s_dev;
1149 dout("kill_sb %p\n", s);
1151 ceph_mdsc_pre_umount(fsc->mdsc);
1152 flush_fs_workqueues(fsc);
1154 generic_shutdown_super(s);
1156 fsc->client->extra_mon_dispatch = NULL;
1157 ceph_fs_debugfs_cleanup(fsc);
1159 ceph_fscache_unregister_fs(fsc);
1161 ceph_mdsc_destroy(fsc);
1163 destroy_fs_client(fsc);
1164 free_anon_bdev(dev);
1167 static struct file_system_type ceph_fs_type = {
1168 .owner = THIS_MODULE,
1170 .mount = ceph_mount,
1171 .kill_sb = ceph_kill_sb,
1172 .fs_flags = FS_RENAME_DOES_D_MOVE,
1174 MODULE_ALIAS_FS("ceph");
1176 static int __init init_ceph(void)
1178 int ret = init_caches();
1184 ret = register_filesystem(&ceph_fs_type);
1188 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL);
1199 static void __exit exit_ceph(void)
1201 dout("exit_ceph\n");
1202 unregister_filesystem(&ceph_fs_type);
1207 module_init(init_ceph);
1208 module_exit(exit_ceph);
1210 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1211 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1212 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1213 MODULE_DESCRIPTION("Ceph filesystem for Linux");
1214 MODULE_LICENSE("GPL");