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_monmap
*monmap
= fsc
->client
->monc
.monmap
;
49 struct ceph_statfs st
;
54 err
= ceph_monc_do_statfs(&fsc
->client
->monc
, &st
);
59 buf
->f_type
= CEPH_SUPER_MAGIC
; /* ?? */
62 * express utilization in terms of large blocks to avoid
63 * overflow on 32-bit machines.
65 * NOTE: for the time being, we make bsize == frsize to humor
66 * not-yet-ancient versions of glibc that are broken.
67 * Someday, we will probably want to report a real block
68 * size... whatever that may mean for a network file system!
70 buf
->f_bsize
= 1 << CEPH_BLOCK_SHIFT
;
71 buf
->f_frsize
= 1 << CEPH_BLOCK_SHIFT
;
72 buf
->f_blocks
= le64_to_cpu(st
.kb
) >> (CEPH_BLOCK_SHIFT
-10);
73 buf
->f_bfree
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
74 buf
->f_bavail
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
76 buf
->f_files
= le64_to_cpu(st
.num_objects
);
78 buf
->f_namelen
= NAME_MAX
;
80 /* leave fsid little-endian, regardless of host endianness */
81 fsid
= *(u64
*)(&monmap
->fsid
) ^ *((u64
*)&monmap
->fsid
+ 1);
82 buf
->f_fsid
.val
[0] = fsid
& 0xffffffff;
83 buf
->f_fsid
.val
[1] = fsid
>> 32;
89 static int ceph_sync_fs(struct super_block
*sb
, int wait
)
91 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
94 dout("sync_fs (non-blocking)\n");
95 ceph_flush_dirty_caps(fsc
->mdsc
);
96 dout("sync_fs (non-blocking) done\n");
100 dout("sync_fs (blocking)\n");
101 ceph_osdc_sync(&fsc
->client
->osdc
);
102 ceph_mdsc_sync(fsc
->mdsc
);
103 dout("sync_fs (blocking) done\n");
115 Opt_caps_wanted_delay_min
,
116 Opt_caps_wanted_delay_max
,
117 Opt_cap_release_safety
,
118 Opt_readdir_max_entries
,
119 Opt_readdir_max_bytes
,
125 /* string args above */
140 #ifdef CONFIG_CEPH_FS_POSIX_ACL
146 static match_table_t fsopt_tokens
= {
147 {Opt_mds_namespace
, "mds_namespace=%d"},
148 {Opt_wsize
, "wsize=%d"},
149 {Opt_rsize
, "rsize=%d"},
150 {Opt_rasize
, "rasize=%d"},
151 {Opt_caps_wanted_delay_min
, "caps_wanted_delay_min=%d"},
152 {Opt_caps_wanted_delay_max
, "caps_wanted_delay_max=%d"},
153 {Opt_cap_release_safety
, "cap_release_safety=%d"},
154 {Opt_readdir_max_entries
, "readdir_max_entries=%d"},
155 {Opt_readdir_max_bytes
, "readdir_max_bytes=%d"},
156 {Opt_congestion_kb
, "write_congestion_kb=%d"},
158 {Opt_snapdirname
, "snapdirname=%s"},
159 /* string args above */
160 {Opt_dirstat
, "dirstat"},
161 {Opt_nodirstat
, "nodirstat"},
162 {Opt_rbytes
, "rbytes"},
163 {Opt_norbytes
, "norbytes"},
164 {Opt_asyncreaddir
, "asyncreaddir"},
165 {Opt_noasyncreaddir
, "noasyncreaddir"},
166 {Opt_dcache
, "dcache"},
167 {Opt_nodcache
, "nodcache"},
168 {Opt_ino32
, "ino32"},
169 {Opt_noino32
, "noino32"},
170 {Opt_fscache
, "fsc"},
171 {Opt_nofscache
, "nofsc"},
172 {Opt_poolperm
, "poolperm"},
173 {Opt_nopoolperm
, "nopoolperm"},
174 #ifdef CONFIG_CEPH_FS_POSIX_ACL
177 {Opt_noacl
, "noacl"},
181 static int parse_fsopt_token(char *c
, void *private)
183 struct ceph_mount_options
*fsopt
= private;
184 substring_t argstr
[MAX_OPT_ARGS
];
185 int token
, intval
, ret
;
187 token
= match_token((char *)c
, fsopt_tokens
, argstr
);
191 if (token
< Opt_last_int
) {
192 ret
= match_int(&argstr
[0], &intval
);
194 pr_err("bad mount option arg (not int) "
198 dout("got int token %d val %d\n", token
, intval
);
199 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
200 dout("got string token %d val %s\n", token
,
203 dout("got token %d\n", token
);
207 case Opt_snapdirname
:
208 kfree(fsopt
->snapdir_name
);
209 fsopt
->snapdir_name
= kstrndup(argstr
[0].from
,
210 argstr
[0].to
-argstr
[0].from
,
212 if (!fsopt
->snapdir_name
)
217 case Opt_mds_namespace
:
218 fsopt
->mds_namespace
= intval
;
221 fsopt
->wsize
= intval
;
224 fsopt
->rsize
= intval
;
227 fsopt
->rasize
= intval
;
229 case Opt_caps_wanted_delay_min
:
230 fsopt
->caps_wanted_delay_min
= intval
;
232 case Opt_caps_wanted_delay_max
:
233 fsopt
->caps_wanted_delay_max
= intval
;
235 case Opt_readdir_max_entries
:
236 fsopt
->max_readdir
= intval
;
238 case Opt_readdir_max_bytes
:
239 fsopt
->max_readdir_bytes
= intval
;
241 case Opt_congestion_kb
:
242 fsopt
->congestion_kb
= intval
;
245 fsopt
->flags
|= CEPH_MOUNT_OPT_DIRSTAT
;
248 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DIRSTAT
;
251 fsopt
->flags
|= CEPH_MOUNT_OPT_RBYTES
;
254 fsopt
->flags
&= ~CEPH_MOUNT_OPT_RBYTES
;
256 case Opt_asyncreaddir
:
257 fsopt
->flags
&= ~CEPH_MOUNT_OPT_NOASYNCREADDIR
;
259 case Opt_noasyncreaddir
:
260 fsopt
->flags
|= CEPH_MOUNT_OPT_NOASYNCREADDIR
;
263 fsopt
->flags
|= CEPH_MOUNT_OPT_DCACHE
;
266 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DCACHE
;
269 fsopt
->flags
|= CEPH_MOUNT_OPT_INO32
;
272 fsopt
->flags
&= ~CEPH_MOUNT_OPT_INO32
;
275 fsopt
->flags
|= CEPH_MOUNT_OPT_FSCACHE
;
278 fsopt
->flags
&= ~CEPH_MOUNT_OPT_FSCACHE
;
281 fsopt
->flags
&= ~CEPH_MOUNT_OPT_NOPOOLPERM
;
282 printk ("pool perm");
285 fsopt
->flags
|= CEPH_MOUNT_OPT_NOPOOLPERM
;
287 #ifdef CONFIG_CEPH_FS_POSIX_ACL
289 fsopt
->sb_flags
|= MS_POSIXACL
;
293 fsopt
->sb_flags
&= ~MS_POSIXACL
;
301 static void destroy_mount_options(struct ceph_mount_options
*args
)
303 dout("destroy_mount_options %p\n", args
);
304 kfree(args
->snapdir_name
);
305 kfree(args
->server_path
);
309 static int strcmp_null(const char *s1
, const char *s2
)
317 return strcmp(s1
, s2
);
320 static int compare_mount_options(struct ceph_mount_options
*new_fsopt
,
321 struct ceph_options
*new_opt
,
322 struct ceph_fs_client
*fsc
)
324 struct ceph_mount_options
*fsopt1
= new_fsopt
;
325 struct ceph_mount_options
*fsopt2
= fsc
->mount_options
;
326 int ofs
= offsetof(struct ceph_mount_options
, snapdir_name
);
329 ret
= memcmp(fsopt1
, fsopt2
, ofs
);
333 ret
= strcmp_null(fsopt1
->snapdir_name
, fsopt2
->snapdir_name
);
337 ret
= strcmp_null(fsopt1
->server_path
, fsopt2
->server_path
);
341 return ceph_compare_options(new_opt
, fsc
->client
);
344 static int parse_mount_options(struct ceph_mount_options
**pfsopt
,
345 struct ceph_options
**popt
,
346 int flags
, char *options
,
347 const char *dev_name
)
349 struct ceph_mount_options
*fsopt
;
350 const char *dev_name_end
;
353 if (!dev_name
|| !*dev_name
)
356 fsopt
= kzalloc(sizeof(*fsopt
), GFP_KERNEL
);
360 dout("parse_mount_options %p, dev_name '%s'\n", fsopt
, dev_name
);
362 fsopt
->sb_flags
= flags
;
363 fsopt
->flags
= CEPH_MOUNT_OPT_DEFAULT
;
365 fsopt
->rsize
= CEPH_RSIZE_DEFAULT
;
366 fsopt
->rasize
= CEPH_RASIZE_DEFAULT
;
367 fsopt
->snapdir_name
= kstrdup(CEPH_SNAPDIRNAME_DEFAULT
, GFP_KERNEL
);
368 if (!fsopt
->snapdir_name
) {
373 fsopt
->caps_wanted_delay_min
= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
;
374 fsopt
->caps_wanted_delay_max
= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
;
375 fsopt
->cap_release_safety
= CEPH_CAP_RELEASE_SAFETY_DEFAULT
;
376 fsopt
->max_readdir
= CEPH_MAX_READDIR_DEFAULT
;
377 fsopt
->max_readdir_bytes
= CEPH_MAX_READDIR_BYTES_DEFAULT
;
378 fsopt
->congestion_kb
= default_congestion_kb();
379 fsopt
->mds_namespace
= CEPH_FS_CLUSTER_ID_NONE
;
382 * Distinguish the server list from the path in "dev_name".
383 * Internally we do not include the leading '/' in the path.
385 * "dev_name" will look like:
386 * <server_spec>[,<server_spec>...]:[<path>]
388 * <server_spec> is <ip>[:<port>]
389 * <path> is optional, but if present must begin with '/'
391 dev_name_end
= strchr(dev_name
, '/');
393 fsopt
->server_path
= kstrdup(dev_name_end
, GFP_KERNEL
);
394 if (!fsopt
->server_path
) {
399 dev_name_end
= dev_name
+ strlen(dev_name
);
402 dev_name_end
--; /* back up to ':' separator */
403 if (dev_name_end
< dev_name
|| *dev_name_end
!= ':') {
404 pr_err("device name is missing path (no : separator in %s)\n",
408 dout("device name '%.*s'\n", (int)(dev_name_end
- dev_name
), dev_name
);
409 if (fsopt
->server_path
)
410 dout("server path '%s'\n", fsopt
->server_path
);
412 *popt
= ceph_parse_options(options
, dev_name
, dev_name_end
,
413 parse_fsopt_token
, (void *)fsopt
);
415 err
= PTR_ERR(*popt
);
424 destroy_mount_options(fsopt
);
429 * ceph_show_options - Show mount options in /proc/mounts
430 * @m: seq_file to write to
431 * @root: root of that (sub)tree
433 static int ceph_show_options(struct seq_file
*m
, struct dentry
*root
)
435 struct ceph_fs_client
*fsc
= ceph_sb_to_client(root
->d_sb
);
436 struct ceph_mount_options
*fsopt
= fsc
->mount_options
;
440 /* a comma between MNT/MS and client options */
444 ret
= ceph_print_client_options(m
, fsc
->client
);
448 /* retract our comma if no client options */
452 if (fsopt
->flags
& CEPH_MOUNT_OPT_DIRSTAT
)
453 seq_puts(m
, ",dirstat");
454 if ((fsopt
->flags
& CEPH_MOUNT_OPT_RBYTES
))
455 seq_puts(m
, ",rbytes");
456 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOASYNCREADDIR
)
457 seq_puts(m
, ",noasyncreaddir");
458 if ((fsopt
->flags
& CEPH_MOUNT_OPT_DCACHE
) == 0)
459 seq_puts(m
, ",nodcache");
460 if (fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
)
462 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOPOOLPERM
)
463 seq_puts(m
, ",nopoolperm");
465 #ifdef CONFIG_CEPH_FS_POSIX_ACL
466 if (fsopt
->sb_flags
& MS_POSIXACL
)
469 seq_puts(m
, ",noacl");
472 if (fsopt
->mds_namespace
!= CEPH_FS_CLUSTER_ID_NONE
)
473 seq_printf(m
, ",mds_namespace=%d", fsopt
->mds_namespace
);
475 seq_printf(m
, ",wsize=%d", fsopt
->wsize
);
476 if (fsopt
->rsize
!= CEPH_RSIZE_DEFAULT
)
477 seq_printf(m
, ",rsize=%d", fsopt
->rsize
);
478 if (fsopt
->rasize
!= CEPH_RASIZE_DEFAULT
)
479 seq_printf(m
, ",rasize=%d", fsopt
->rasize
);
480 if (fsopt
->congestion_kb
!= default_congestion_kb())
481 seq_printf(m
, ",write_congestion_kb=%d", fsopt
->congestion_kb
);
482 if (fsopt
->caps_wanted_delay_min
!= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
)
483 seq_printf(m
, ",caps_wanted_delay_min=%d",
484 fsopt
->caps_wanted_delay_min
);
485 if (fsopt
->caps_wanted_delay_max
!= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
)
486 seq_printf(m
, ",caps_wanted_delay_max=%d",
487 fsopt
->caps_wanted_delay_max
);
488 if (fsopt
->cap_release_safety
!= CEPH_CAP_RELEASE_SAFETY_DEFAULT
)
489 seq_printf(m
, ",cap_release_safety=%d",
490 fsopt
->cap_release_safety
);
491 if (fsopt
->max_readdir
!= CEPH_MAX_READDIR_DEFAULT
)
492 seq_printf(m
, ",readdir_max_entries=%d", fsopt
->max_readdir
);
493 if (fsopt
->max_readdir_bytes
!= CEPH_MAX_READDIR_BYTES_DEFAULT
)
494 seq_printf(m
, ",readdir_max_bytes=%d", fsopt
->max_readdir_bytes
);
495 if (strcmp(fsopt
->snapdir_name
, CEPH_SNAPDIRNAME_DEFAULT
))
496 seq_show_option(m
, "snapdirname", fsopt
->snapdir_name
);
502 * handle any mon messages the standard library doesn't understand.
503 * return error if we don't either.
505 static int extra_mon_dispatch(struct ceph_client
*client
, struct ceph_msg
*msg
)
507 struct ceph_fs_client
*fsc
= client
->private;
508 int type
= le16_to_cpu(msg
->hdr
.type
);
511 case CEPH_MSG_MDS_MAP
:
512 ceph_mdsc_handle_map(fsc
->mdsc
, msg
);
521 * create a new fs client
523 static struct ceph_fs_client
*create_fs_client(struct ceph_mount_options
*fsopt
,
524 struct ceph_options
*opt
)
526 struct ceph_fs_client
*fsc
;
527 const u64 supported_features
=
528 CEPH_FEATURE_FLOCK
| CEPH_FEATURE_DIRLAYOUTHASH
|
529 CEPH_FEATURE_MDSENC
| CEPH_FEATURE_MDS_INLINE_DATA
;
530 const u64 required_features
= 0;
535 fsc
= kzalloc(sizeof(*fsc
), GFP_KERNEL
);
537 return ERR_PTR(-ENOMEM
);
539 fsc
->client
= ceph_create_client(opt
, fsc
, supported_features
,
541 if (IS_ERR(fsc
->client
)) {
542 err
= PTR_ERR(fsc
->client
);
545 fsc
->client
->extra_mon_dispatch
= extra_mon_dispatch
;
546 fsc
->client
->monc
.fs_cluster_id
= fsopt
->mds_namespace
;
547 ceph_monc_want_map(&fsc
->client
->monc
, CEPH_SUB_MDSMAP
, 0, true);
549 fsc
->mount_options
= fsopt
;
552 fsc
->mount_state
= CEPH_MOUNT_MOUNTING
;
554 atomic_long_set(&fsc
->writeback_count
, 0);
556 err
= bdi_init(&fsc
->backing_dev_info
);
562 * The number of concurrent works can be high but they don't need
563 * to be processed in parallel, limit concurrency.
565 fsc
->wb_wq
= alloc_workqueue("ceph-writeback", 0, 1);
566 if (fsc
->wb_wq
== NULL
)
568 fsc
->pg_inv_wq
= alloc_workqueue("ceph-pg-invalid", 0, 1);
569 if (fsc
->pg_inv_wq
== NULL
)
571 fsc
->trunc_wq
= alloc_workqueue("ceph-trunc", 0, 1);
572 if (fsc
->trunc_wq
== NULL
)
575 /* set up mempools */
577 page_count
= fsc
->mount_options
->wsize
>> PAGE_SHIFT
;
578 size
= sizeof (struct page
*) * (page_count
? page_count
: 1);
579 fsc
->wb_pagevec_pool
= mempool_create_kmalloc_pool(10, size
);
580 if (!fsc
->wb_pagevec_pool
)
584 if ((fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
) &&
585 (ceph_fscache_register_fs(fsc
) != 0))
589 fsc
->min_caps
= fsopt
->max_readdir
;
594 ceph_fscache_unregister_fs(fsc
);
596 destroy_workqueue(fsc
->trunc_wq
);
598 destroy_workqueue(fsc
->pg_inv_wq
);
600 destroy_workqueue(fsc
->wb_wq
);
602 bdi_destroy(&fsc
->backing_dev_info
);
604 ceph_destroy_client(fsc
->client
);
610 static void destroy_fs_client(struct ceph_fs_client
*fsc
)
612 dout("destroy_fs_client %p\n", fsc
);
614 ceph_fscache_unregister_fs(fsc
);
616 destroy_workqueue(fsc
->wb_wq
);
617 destroy_workqueue(fsc
->pg_inv_wq
);
618 destroy_workqueue(fsc
->trunc_wq
);
620 bdi_destroy(&fsc
->backing_dev_info
);
622 mempool_destroy(fsc
->wb_pagevec_pool
);
624 destroy_mount_options(fsc
->mount_options
);
626 ceph_fs_debugfs_cleanup(fsc
);
628 ceph_destroy_client(fsc
->client
);
631 dout("destroy_fs_client %p done\n", fsc
);
637 struct kmem_cache
*ceph_inode_cachep
;
638 struct kmem_cache
*ceph_cap_cachep
;
639 struct kmem_cache
*ceph_cap_flush_cachep
;
640 struct kmem_cache
*ceph_dentry_cachep
;
641 struct kmem_cache
*ceph_file_cachep
;
643 static void ceph_inode_init_once(void *foo
)
645 struct ceph_inode_info
*ci
= foo
;
646 inode_init_once(&ci
->vfs_inode
);
649 static int __init
init_caches(void)
653 ceph_inode_cachep
= kmem_cache_create("ceph_inode_info",
654 sizeof(struct ceph_inode_info
),
655 __alignof__(struct ceph_inode_info
),
656 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
|
657 SLAB_ACCOUNT
, ceph_inode_init_once
);
658 if (ceph_inode_cachep
== NULL
)
661 ceph_cap_cachep
= KMEM_CACHE(ceph_cap
,
662 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
663 if (ceph_cap_cachep
== NULL
)
665 ceph_cap_flush_cachep
= KMEM_CACHE(ceph_cap_flush
,
666 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
667 if (ceph_cap_flush_cachep
== NULL
)
670 ceph_dentry_cachep
= KMEM_CACHE(ceph_dentry_info
,
671 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
672 if (ceph_dentry_cachep
== NULL
)
675 ceph_file_cachep
= KMEM_CACHE(ceph_file_info
,
676 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
677 if (ceph_file_cachep
== NULL
)
680 if ((error
= ceph_fscache_register()))
685 kmem_cache_destroy(ceph_dentry_cachep
);
687 kmem_cache_destroy(ceph_cap_flush_cachep
);
689 kmem_cache_destroy(ceph_cap_cachep
);
691 kmem_cache_destroy(ceph_inode_cachep
);
695 static void destroy_caches(void)
698 * Make sure all delayed rcu free inodes are flushed before we
703 kmem_cache_destroy(ceph_inode_cachep
);
704 kmem_cache_destroy(ceph_cap_cachep
);
705 kmem_cache_destroy(ceph_cap_flush_cachep
);
706 kmem_cache_destroy(ceph_dentry_cachep
);
707 kmem_cache_destroy(ceph_file_cachep
);
709 ceph_fscache_unregister();
714 * ceph_umount_begin - initiate forced umount. Tear down down the
715 * mount, skipping steps that may hang while waiting for server(s).
717 static void ceph_umount_begin(struct super_block
*sb
)
719 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
721 dout("ceph_umount_begin - starting forced umount\n");
724 fsc
->mount_state
= CEPH_MOUNT_SHUTDOWN
;
725 ceph_mdsc_force_umount(fsc
->mdsc
);
729 static const struct super_operations ceph_super_ops
= {
730 .alloc_inode
= ceph_alloc_inode
,
731 .destroy_inode
= ceph_destroy_inode
,
732 .write_inode
= ceph_write_inode
,
733 .drop_inode
= ceph_drop_inode
,
734 .sync_fs
= ceph_sync_fs
,
735 .put_super
= ceph_put_super
,
736 .show_options
= ceph_show_options
,
737 .statfs
= ceph_statfs
,
738 .umount_begin
= ceph_umount_begin
,
742 * Bootstrap mount by opening the root directory. Note the mount
743 * @started time from caller, and time out if this takes too long.
745 static struct dentry
*open_root_dentry(struct ceph_fs_client
*fsc
,
747 unsigned long started
)
749 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
750 struct ceph_mds_request
*req
= NULL
;
755 dout("open_root_inode opening '%s'\n", path
);
756 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_GETATTR
, USE_ANY_MDS
);
758 return ERR_CAST(req
);
759 req
->r_path1
= kstrdup(path
, GFP_NOFS
);
761 root
= ERR_PTR(-ENOMEM
);
765 req
->r_ino1
.ino
= CEPH_INO_ROOT
;
766 req
->r_ino1
.snap
= CEPH_NOSNAP
;
767 req
->r_started
= started
;
768 req
->r_timeout
= fsc
->client
->options
->mount_timeout
;
769 req
->r_args
.getattr
.mask
= cpu_to_le32(CEPH_STAT_CAP_INODE
);
771 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
773 struct inode
*inode
= req
->r_target_inode
;
774 req
->r_target_inode
= NULL
;
775 dout("open_root_inode success\n");
776 if (ceph_ino(inode
) == CEPH_INO_ROOT
&&
777 fsc
->sb
->s_root
== NULL
) {
778 root
= d_make_root(inode
);
780 root
= ERR_PTR(-ENOMEM
);
784 root
= d_obtain_root(inode
);
786 ceph_init_dentry(root
);
787 dout("open_root_inode success, root dentry is %p\n", root
);
792 ceph_mdsc_put_request(req
);
800 * mount: join the ceph cluster, and open root directory.
802 static struct dentry
*ceph_real_mount(struct ceph_fs_client
*fsc
)
805 unsigned long started
= jiffies
; /* note the start time */
807 int first
= 0; /* first vfsmount for this super_block */
809 dout("mount start %p\n", fsc
);
810 mutex_lock(&fsc
->client
->mount_mutex
);
812 if (!fsc
->sb
->s_root
) {
813 err
= __ceph_open_session(fsc
->client
, started
);
817 dout("mount opening root\n");
818 root
= open_root_dentry(fsc
, "", started
);
823 fsc
->sb
->s_root
= root
;
826 err
= ceph_fs_debugfs_init(fsc
);
831 if (!fsc
->mount_options
->server_path
) {
832 root
= fsc
->sb
->s_root
;
835 const char *path
= fsc
->mount_options
->server_path
+ 1;
836 dout("mount opening path %s\n", path
);
837 root
= open_root_dentry(fsc
, path
, started
);
844 fsc
->mount_state
= CEPH_MOUNT_MOUNTED
;
845 dout("mount success\n");
846 mutex_unlock(&fsc
->client
->mount_mutex
);
851 dput(fsc
->sb
->s_root
);
852 fsc
->sb
->s_root
= NULL
;
855 mutex_unlock(&fsc
->client
->mount_mutex
);
859 static int ceph_set_super(struct super_block
*s
, void *data
)
861 struct ceph_fs_client
*fsc
= data
;
864 dout("set_super %p data %p\n", s
, data
);
866 s
->s_flags
= fsc
->mount_options
->sb_flags
;
867 s
->s_maxbytes
= 1ULL << 40; /* temp value until we get mdsmap */
869 s
->s_xattr
= ceph_xattr_handlers
;
873 s
->s_op
= &ceph_super_ops
;
874 s
->s_export_op
= &ceph_export_ops
;
876 s
->s_time_gran
= 1000; /* 1000 ns == 1 us */
878 ret
= set_anon_super(s
, NULL
); /* what is that second arg for? */
891 * share superblock if same fs AND options
893 static int ceph_compare_super(struct super_block
*sb
, void *data
)
895 struct ceph_fs_client
*new = data
;
896 struct ceph_mount_options
*fsopt
= new->mount_options
;
897 struct ceph_options
*opt
= new->client
->options
;
898 struct ceph_fs_client
*other
= ceph_sb_to_client(sb
);
900 dout("ceph_compare_super %p\n", sb
);
902 if (compare_mount_options(fsopt
, opt
, other
)) {
903 dout("monitor(s)/mount options don't match\n");
906 if ((opt
->flags
& CEPH_OPT_FSID
) &&
907 ceph_fsid_compare(&opt
->fsid
, &other
->client
->fsid
)) {
908 dout("fsid doesn't match\n");
911 if (fsopt
->sb_flags
!= other
->mount_options
->sb_flags
) {
912 dout("flags differ\n");
919 * construct our own bdi so we can control readahead, etc.
921 static atomic_long_t bdi_seq
= ATOMIC_LONG_INIT(0);
923 static int ceph_register_bdi(struct super_block
*sb
,
924 struct ceph_fs_client
*fsc
)
928 /* set ra_pages based on rasize mount option? */
929 if (fsc
->mount_options
->rasize
>= PAGE_SIZE
)
930 fsc
->backing_dev_info
.ra_pages
=
931 (fsc
->mount_options
->rasize
+ PAGE_SIZE
- 1)
934 fsc
->backing_dev_info
.ra_pages
=
935 VM_MAX_READAHEAD
* 1024 / PAGE_SIZE
;
937 err
= bdi_register(&fsc
->backing_dev_info
, NULL
, "ceph-%ld",
938 atomic_long_inc_return(&bdi_seq
));
940 sb
->s_bdi
= &fsc
->backing_dev_info
;
944 static struct dentry
*ceph_mount(struct file_system_type
*fs_type
,
945 int flags
, const char *dev_name
, void *data
)
947 struct super_block
*sb
;
948 struct ceph_fs_client
*fsc
;
951 int (*compare_super
)(struct super_block
*, void *) = ceph_compare_super
;
952 struct ceph_mount_options
*fsopt
= NULL
;
953 struct ceph_options
*opt
= NULL
;
955 dout("ceph_mount\n");
957 #ifdef CONFIG_CEPH_FS_POSIX_ACL
958 flags
|= MS_POSIXACL
;
960 err
= parse_mount_options(&fsopt
, &opt
, flags
, data
, dev_name
);
966 /* create client (which we may/may not use) */
967 fsc
= create_fs_client(fsopt
, opt
);
970 destroy_mount_options(fsopt
);
971 ceph_destroy_options(opt
);
975 err
= ceph_mdsc_init(fsc
);
981 if (ceph_test_opt(fsc
->client
, NOSHARE
))
982 compare_super
= NULL
;
983 sb
= sget(fs_type
, compare_super
, ceph_set_super
, flags
, fsc
);
989 if (ceph_sb_to_client(sb
) != fsc
) {
990 ceph_mdsc_destroy(fsc
);
991 destroy_fs_client(fsc
);
992 fsc
= ceph_sb_to_client(sb
);
993 dout("get_sb got existing client %p\n", fsc
);
995 dout("get_sb using new client %p\n", fsc
);
996 err
= ceph_register_bdi(sb
, fsc
);
1003 res
= ceph_real_mount(fsc
);
1006 dout("root %p inode %p ino %llx.%llx\n", res
,
1007 d_inode(res
), ceph_vinop(d_inode(res
)));
1011 ceph_mdsc_close_sessions(fsc
->mdsc
);
1012 deactivate_locked_super(sb
);
1016 ceph_mdsc_destroy(fsc
);
1017 destroy_fs_client(fsc
);
1019 dout("ceph_mount fail %ld\n", PTR_ERR(res
));
1023 static void ceph_kill_sb(struct super_block
*s
)
1025 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
1026 dev_t dev
= s
->s_dev
;
1028 dout("kill_sb %p\n", s
);
1030 ceph_mdsc_pre_umount(fsc
->mdsc
);
1031 generic_shutdown_super(s
);
1032 ceph_mdsc_destroy(fsc
);
1034 destroy_fs_client(fsc
);
1035 free_anon_bdev(dev
);
1038 static struct file_system_type ceph_fs_type
= {
1039 .owner
= THIS_MODULE
,
1041 .mount
= ceph_mount
,
1042 .kill_sb
= ceph_kill_sb
,
1043 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
1045 MODULE_ALIAS_FS("ceph");
1047 static int __init
init_ceph(void)
1049 int ret
= init_caches();
1055 ret
= register_filesystem(&ceph_fs_type
);
1059 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL
);
1070 static void __exit
exit_ceph(void)
1072 dout("exit_ceph\n");
1073 unregister_filesystem(&ceph_fs_type
);
1078 module_init(init_ceph
);
1079 module_exit(exit_ceph
);
1081 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1082 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1083 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1084 MODULE_DESCRIPTION("Ceph filesystem for Linux");
1085 MODULE_LICENSE("GPL");