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 * ensure we release the bdi before put_anon_super releases
48 if (s
->s_bdi
== &fsc
->backing_dev_info
) {
49 bdi_unregister(&fsc
->backing_dev_info
);
56 static int ceph_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
58 struct ceph_fs_client
*fsc
= ceph_inode_to_client(dentry
->d_inode
);
59 struct ceph_monmap
*monmap
= fsc
->client
->monc
.monmap
;
60 struct ceph_statfs st
;
65 err
= ceph_monc_do_statfs(&fsc
->client
->monc
, &st
);
70 buf
->f_type
= CEPH_SUPER_MAGIC
; /* ?? */
73 * express utilization in terms of large blocks to avoid
74 * overflow on 32-bit machines.
76 * NOTE: for the time being, we make bsize == frsize to humor
77 * not-yet-ancient versions of glibc that are broken.
78 * Someday, we will probably want to report a real block
79 * size... whatever that may mean for a network file system!
81 buf
->f_bsize
= 1 << CEPH_BLOCK_SHIFT
;
82 buf
->f_frsize
= 1 << CEPH_BLOCK_SHIFT
;
83 buf
->f_blocks
= le64_to_cpu(st
.kb
) >> (CEPH_BLOCK_SHIFT
-10);
84 buf
->f_bfree
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
85 buf
->f_bavail
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
87 buf
->f_files
= le64_to_cpu(st
.num_objects
);
89 buf
->f_namelen
= NAME_MAX
;
91 /* leave fsid little-endian, regardless of host endianness */
92 fsid
= *(u64
*)(&monmap
->fsid
) ^ *((u64
*)&monmap
->fsid
+ 1);
93 buf
->f_fsid
.val
[0] = fsid
& 0xffffffff;
94 buf
->f_fsid
.val
[1] = fsid
>> 32;
100 static int ceph_sync_fs(struct super_block
*sb
, int wait
)
102 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
105 dout("sync_fs (non-blocking)\n");
106 ceph_flush_dirty_caps(fsc
->mdsc
);
107 dout("sync_fs (non-blocking) done\n");
111 dout("sync_fs (blocking)\n");
112 ceph_osdc_sync(&fsc
->client
->osdc
);
113 ceph_mdsc_sync(fsc
->mdsc
);
114 dout("sync_fs (blocking) done\n");
125 Opt_caps_wanted_delay_min
,
126 Opt_caps_wanted_delay_max
,
127 Opt_cap_release_safety
,
128 Opt_readdir_max_entries
,
129 Opt_readdir_max_bytes
,
135 /* string args above */
150 static match_table_t fsopt_tokens
= {
151 {Opt_wsize
, "wsize=%d"},
152 {Opt_rsize
, "rsize=%d"},
153 {Opt_rasize
, "rasize=%d"},
154 {Opt_caps_wanted_delay_min
, "caps_wanted_delay_min=%d"},
155 {Opt_caps_wanted_delay_max
, "caps_wanted_delay_max=%d"},
156 {Opt_cap_release_safety
, "cap_release_safety=%d"},
157 {Opt_readdir_max_entries
, "readdir_max_entries=%d"},
158 {Opt_readdir_max_bytes
, "readdir_max_bytes=%d"},
159 {Opt_congestion_kb
, "write_congestion_kb=%d"},
161 {Opt_snapdirname
, "snapdirname=%s"},
162 /* string args above */
163 {Opt_dirstat
, "dirstat"},
164 {Opt_nodirstat
, "nodirstat"},
165 {Opt_rbytes
, "rbytes"},
166 {Opt_norbytes
, "norbytes"},
167 {Opt_asyncreaddir
, "asyncreaddir"},
168 {Opt_noasyncreaddir
, "noasyncreaddir"},
169 {Opt_dcache
, "dcache"},
170 {Opt_nodcache
, "nodcache"},
171 {Opt_ino32
, "ino32"},
172 {Opt_noino32
, "noino32"},
173 {Opt_fscache
, "fsc"},
174 {Opt_nofscache
, "nofsc"},
178 static int parse_fsopt_token(char *c
, void *private)
180 struct ceph_mount_options
*fsopt
= private;
181 substring_t argstr
[MAX_OPT_ARGS
];
182 int token
, intval
, ret
;
184 token
= match_token((char *)c
, fsopt_tokens
, argstr
);
188 if (token
< Opt_last_int
) {
189 ret
= match_int(&argstr
[0], &intval
);
191 pr_err("bad mount option arg (not int) "
195 dout("got int token %d val %d\n", token
, intval
);
196 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
197 dout("got string token %d val %s\n", token
,
200 dout("got token %d\n", token
);
204 case Opt_snapdirname
:
205 kfree(fsopt
->snapdir_name
);
206 fsopt
->snapdir_name
= kstrndup(argstr
[0].from
,
207 argstr
[0].to
-argstr
[0].from
,
209 if (!fsopt
->snapdir_name
)
215 fsopt
->wsize
= intval
;
218 fsopt
->rsize
= intval
;
221 fsopt
->rasize
= intval
;
223 case Opt_caps_wanted_delay_min
:
224 fsopt
->caps_wanted_delay_min
= intval
;
226 case Opt_caps_wanted_delay_max
:
227 fsopt
->caps_wanted_delay_max
= intval
;
229 case Opt_readdir_max_entries
:
230 fsopt
->max_readdir
= intval
;
232 case Opt_readdir_max_bytes
:
233 fsopt
->max_readdir_bytes
= intval
;
235 case Opt_congestion_kb
:
236 fsopt
->congestion_kb
= intval
;
239 fsopt
->flags
|= CEPH_MOUNT_OPT_DIRSTAT
;
242 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DIRSTAT
;
245 fsopt
->flags
|= CEPH_MOUNT_OPT_RBYTES
;
248 fsopt
->flags
&= ~CEPH_MOUNT_OPT_RBYTES
;
250 case Opt_asyncreaddir
:
251 fsopt
->flags
&= ~CEPH_MOUNT_OPT_NOASYNCREADDIR
;
253 case Opt_noasyncreaddir
:
254 fsopt
->flags
|= CEPH_MOUNT_OPT_NOASYNCREADDIR
;
257 fsopt
->flags
|= CEPH_MOUNT_OPT_DCACHE
;
260 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DCACHE
;
263 fsopt
->flags
|= CEPH_MOUNT_OPT_INO32
;
266 fsopt
->flags
&= ~CEPH_MOUNT_OPT_INO32
;
269 fsopt
->flags
|= CEPH_MOUNT_OPT_FSCACHE
;
272 fsopt
->flags
&= ~CEPH_MOUNT_OPT_FSCACHE
;
280 static void destroy_mount_options(struct ceph_mount_options
*args
)
282 dout("destroy_mount_options %p\n", args
);
283 kfree(args
->snapdir_name
);
287 static int strcmp_null(const char *s1
, const char *s2
)
295 return strcmp(s1
, s2
);
298 static int compare_mount_options(struct ceph_mount_options
*new_fsopt
,
299 struct ceph_options
*new_opt
,
300 struct ceph_fs_client
*fsc
)
302 struct ceph_mount_options
*fsopt1
= new_fsopt
;
303 struct ceph_mount_options
*fsopt2
= fsc
->mount_options
;
304 int ofs
= offsetof(struct ceph_mount_options
, snapdir_name
);
307 ret
= memcmp(fsopt1
, fsopt2
, ofs
);
311 ret
= strcmp_null(fsopt1
->snapdir_name
, fsopt2
->snapdir_name
);
315 return ceph_compare_options(new_opt
, fsc
->client
);
318 static int parse_mount_options(struct ceph_mount_options
**pfsopt
,
319 struct ceph_options
**popt
,
320 int flags
, char *options
,
321 const char *dev_name
,
324 struct ceph_mount_options
*fsopt
;
325 const char *dev_name_end
;
328 if (!dev_name
|| !*dev_name
)
331 fsopt
= kzalloc(sizeof(*fsopt
), GFP_KERNEL
);
335 dout("parse_mount_options %p, dev_name '%s'\n", fsopt
, dev_name
);
337 fsopt
->sb_flags
= flags
;
338 fsopt
->flags
= CEPH_MOUNT_OPT_DEFAULT
;
340 fsopt
->rsize
= CEPH_RSIZE_DEFAULT
;
341 fsopt
->rasize
= CEPH_RASIZE_DEFAULT
;
342 fsopt
->snapdir_name
= kstrdup(CEPH_SNAPDIRNAME_DEFAULT
, GFP_KERNEL
);
343 fsopt
->caps_wanted_delay_min
= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
;
344 fsopt
->caps_wanted_delay_max
= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
;
345 fsopt
->cap_release_safety
= CEPH_CAP_RELEASE_SAFETY_DEFAULT
;
346 fsopt
->max_readdir
= CEPH_MAX_READDIR_DEFAULT
;
347 fsopt
->max_readdir_bytes
= CEPH_MAX_READDIR_BYTES_DEFAULT
;
348 fsopt
->congestion_kb
= default_congestion_kb();
351 * Distinguish the server list from the path in "dev_name".
352 * Internally we do not include the leading '/' in the path.
354 * "dev_name" will look like:
355 * <server_spec>[,<server_spec>...]:[<path>]
357 * <server_spec> is <ip>[:<port>]
358 * <path> is optional, but if present must begin with '/'
360 dev_name_end
= strchr(dev_name
, '/');
362 /* skip over leading '/' for path */
363 *path
= dev_name_end
+ 1;
366 dev_name_end
= dev_name
+ strlen(dev_name
);
367 *path
= dev_name_end
;
370 dev_name_end
--; /* back up to ':' separator */
371 if (dev_name_end
< dev_name
|| *dev_name_end
!= ':') {
372 pr_err("device name is missing path (no : separator in %s)\n",
376 dout("device name '%.*s'\n", (int)(dev_name_end
- dev_name
), dev_name
);
377 dout("server path '%s'\n", *path
);
379 *popt
= ceph_parse_options(options
, dev_name
, dev_name_end
,
380 parse_fsopt_token
, (void *)fsopt
);
382 err
= PTR_ERR(*popt
);
391 destroy_mount_options(fsopt
);
396 * ceph_show_options - Show mount options in /proc/mounts
397 * @m: seq_file to write to
398 * @root: root of that (sub)tree
400 static int ceph_show_options(struct seq_file
*m
, struct dentry
*root
)
402 struct ceph_fs_client
*fsc
= ceph_sb_to_client(root
->d_sb
);
403 struct ceph_mount_options
*fsopt
= fsc
->mount_options
;
404 struct ceph_options
*opt
= fsc
->client
->options
;
406 if (opt
->flags
& CEPH_OPT_FSID
)
407 seq_printf(m
, ",fsid=%pU", &opt
->fsid
);
408 if (opt
->flags
& CEPH_OPT_NOSHARE
)
409 seq_puts(m
, ",noshare");
410 if (opt
->flags
& CEPH_OPT_NOCRC
)
411 seq_puts(m
, ",nocrc");
414 seq_printf(m
, ",name=%s", opt
->name
);
416 seq_puts(m
, ",secret=<hidden>");
418 if (opt
->mount_timeout
!= CEPH_MOUNT_TIMEOUT_DEFAULT
)
419 seq_printf(m
, ",mount_timeout=%d", opt
->mount_timeout
);
420 if (opt
->osd_idle_ttl
!= CEPH_OSD_IDLE_TTL_DEFAULT
)
421 seq_printf(m
, ",osd_idle_ttl=%d", opt
->osd_idle_ttl
);
422 if (opt
->osd_keepalive_timeout
!= CEPH_OSD_KEEPALIVE_DEFAULT
)
423 seq_printf(m
, ",osdkeepalivetimeout=%d",
424 opt
->osd_keepalive_timeout
);
426 if (fsopt
->flags
& CEPH_MOUNT_OPT_DIRSTAT
)
427 seq_puts(m
, ",dirstat");
428 if ((fsopt
->flags
& CEPH_MOUNT_OPT_RBYTES
) == 0)
429 seq_puts(m
, ",norbytes");
430 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOASYNCREADDIR
)
431 seq_puts(m
, ",noasyncreaddir");
432 if (fsopt
->flags
& CEPH_MOUNT_OPT_DCACHE
)
433 seq_puts(m
, ",dcache");
435 seq_puts(m
, ",nodcache");
436 if (fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
)
439 seq_puts(m
, ",nofsc");
442 seq_printf(m
, ",wsize=%d", fsopt
->wsize
);
443 if (fsopt
->rsize
!= CEPH_RSIZE_DEFAULT
)
444 seq_printf(m
, ",rsize=%d", fsopt
->rsize
);
445 if (fsopt
->rasize
!= CEPH_RASIZE_DEFAULT
)
446 seq_printf(m
, ",rasize=%d", fsopt
->rasize
);
447 if (fsopt
->congestion_kb
!= default_congestion_kb())
448 seq_printf(m
, ",write_congestion_kb=%d", fsopt
->congestion_kb
);
449 if (fsopt
->caps_wanted_delay_min
!= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
)
450 seq_printf(m
, ",caps_wanted_delay_min=%d",
451 fsopt
->caps_wanted_delay_min
);
452 if (fsopt
->caps_wanted_delay_max
!= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
)
453 seq_printf(m
, ",caps_wanted_delay_max=%d",
454 fsopt
->caps_wanted_delay_max
);
455 if (fsopt
->cap_release_safety
!= CEPH_CAP_RELEASE_SAFETY_DEFAULT
)
456 seq_printf(m
, ",cap_release_safety=%d",
457 fsopt
->cap_release_safety
);
458 if (fsopt
->max_readdir
!= CEPH_MAX_READDIR_DEFAULT
)
459 seq_printf(m
, ",readdir_max_entries=%d", fsopt
->max_readdir
);
460 if (fsopt
->max_readdir_bytes
!= CEPH_MAX_READDIR_BYTES_DEFAULT
)
461 seq_printf(m
, ",readdir_max_bytes=%d", fsopt
->max_readdir_bytes
);
462 if (strcmp(fsopt
->snapdir_name
, CEPH_SNAPDIRNAME_DEFAULT
))
463 seq_printf(m
, ",snapdirname=%s", fsopt
->snapdir_name
);
468 * handle any mon messages the standard library doesn't understand.
469 * return error if we don't either.
471 static int extra_mon_dispatch(struct ceph_client
*client
, struct ceph_msg
*msg
)
473 struct ceph_fs_client
*fsc
= client
->private;
474 int type
= le16_to_cpu(msg
->hdr
.type
);
477 case CEPH_MSG_MDS_MAP
:
478 ceph_mdsc_handle_map(fsc
->mdsc
, msg
);
487 * create a new fs client
489 static struct ceph_fs_client
*create_fs_client(struct ceph_mount_options
*fsopt
,
490 struct ceph_options
*opt
)
492 struct ceph_fs_client
*fsc
;
493 const unsigned supported_features
=
495 CEPH_FEATURE_DIRLAYOUTHASH
;
496 const unsigned required_features
= 0;
501 fsc
= kzalloc(sizeof(*fsc
), GFP_KERNEL
);
503 return ERR_PTR(-ENOMEM
);
505 fsc
->client
= ceph_create_client(opt
, fsc
, supported_features
,
507 if (IS_ERR(fsc
->client
)) {
508 err
= PTR_ERR(fsc
->client
);
511 fsc
->client
->extra_mon_dispatch
= extra_mon_dispatch
;
512 fsc
->client
->monc
.want_mdsmap
= 1;
514 fsc
->mount_options
= fsopt
;
517 fsc
->mount_state
= CEPH_MOUNT_MOUNTING
;
519 atomic_long_set(&fsc
->writeback_count
, 0);
521 err
= bdi_init(&fsc
->backing_dev_info
);
527 * The number of concurrent works can be high but they don't need
528 * to be processed in parallel, limit concurrency.
530 fsc
->wb_wq
= alloc_workqueue("ceph-writeback", 0, 1);
531 if (fsc
->wb_wq
== NULL
)
533 fsc
->pg_inv_wq
= alloc_workqueue("ceph-pg-invalid", 0, 1);
534 if (fsc
->pg_inv_wq
== NULL
)
536 fsc
->trunc_wq
= alloc_workqueue("ceph-trunc", 0, 1);
537 if (fsc
->trunc_wq
== NULL
)
540 /* set up mempools */
542 page_count
= fsc
->mount_options
->wsize
>> PAGE_CACHE_SHIFT
;
543 size
= sizeof (struct page
*) * (page_count
? page_count
: 1);
544 fsc
->wb_pagevec_pool
= mempool_create_kmalloc_pool(10, size
);
545 if (!fsc
->wb_pagevec_pool
)
549 if ((fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
) &&
550 (ceph_fscache_register_fs(fsc
) != 0))
554 fsc
->min_caps
= fsopt
->max_readdir
;
559 ceph_fscache_unregister_fs(fsc
);
561 destroy_workqueue(fsc
->trunc_wq
);
563 destroy_workqueue(fsc
->pg_inv_wq
);
565 destroy_workqueue(fsc
->wb_wq
);
567 bdi_destroy(&fsc
->backing_dev_info
);
569 ceph_destroy_client(fsc
->client
);
575 static void destroy_fs_client(struct ceph_fs_client
*fsc
)
577 dout("destroy_fs_client %p\n", fsc
);
579 ceph_fscache_unregister_fs(fsc
);
581 destroy_workqueue(fsc
->wb_wq
);
582 destroy_workqueue(fsc
->pg_inv_wq
);
583 destroy_workqueue(fsc
->trunc_wq
);
585 bdi_destroy(&fsc
->backing_dev_info
);
587 mempool_destroy(fsc
->wb_pagevec_pool
);
589 destroy_mount_options(fsc
->mount_options
);
591 ceph_fs_debugfs_cleanup(fsc
);
593 ceph_destroy_client(fsc
->client
);
596 dout("destroy_fs_client %p done\n", fsc
);
602 struct kmem_cache
*ceph_inode_cachep
;
603 struct kmem_cache
*ceph_cap_cachep
;
604 struct kmem_cache
*ceph_dentry_cachep
;
605 struct kmem_cache
*ceph_file_cachep
;
607 static void ceph_inode_init_once(void *foo
)
609 struct ceph_inode_info
*ci
= foo
;
610 inode_init_once(&ci
->vfs_inode
);
613 static int __init
init_caches(void)
617 ceph_inode_cachep
= kmem_cache_create("ceph_inode_info",
618 sizeof(struct ceph_inode_info
),
619 __alignof__(struct ceph_inode_info
),
620 (SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
),
621 ceph_inode_init_once
);
622 if (ceph_inode_cachep
== NULL
)
625 ceph_cap_cachep
= KMEM_CACHE(ceph_cap
,
626 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
627 if (ceph_cap_cachep
== NULL
)
630 ceph_dentry_cachep
= KMEM_CACHE(ceph_dentry_info
,
631 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
632 if (ceph_dentry_cachep
== NULL
)
635 ceph_file_cachep
= KMEM_CACHE(ceph_file_info
,
636 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
637 if (ceph_file_cachep
== NULL
)
640 if ((error
= ceph_fscache_register()))
645 kmem_cache_destroy(ceph_dentry_cachep
);
647 kmem_cache_destroy(ceph_cap_cachep
);
649 kmem_cache_destroy(ceph_inode_cachep
);
653 static void destroy_caches(void)
656 * Make sure all delayed rcu free inodes are flushed before we
661 kmem_cache_destroy(ceph_inode_cachep
);
662 kmem_cache_destroy(ceph_cap_cachep
);
663 kmem_cache_destroy(ceph_dentry_cachep
);
664 kmem_cache_destroy(ceph_file_cachep
);
666 ceph_fscache_unregister();
671 * ceph_umount_begin - initiate forced umount. Tear down down the
672 * mount, skipping steps that may hang while waiting for server(s).
674 static void ceph_umount_begin(struct super_block
*sb
)
676 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
678 dout("ceph_umount_begin - starting forced umount\n");
681 fsc
->mount_state
= CEPH_MOUNT_SHUTDOWN
;
685 static const struct super_operations ceph_super_ops
= {
686 .alloc_inode
= ceph_alloc_inode
,
687 .destroy_inode
= ceph_destroy_inode
,
688 .write_inode
= ceph_write_inode
,
689 .sync_fs
= ceph_sync_fs
,
690 .put_super
= ceph_put_super
,
691 .show_options
= ceph_show_options
,
692 .statfs
= ceph_statfs
,
693 .umount_begin
= ceph_umount_begin
,
697 * Bootstrap mount by opening the root directory. Note the mount
698 * @started time from caller, and time out if this takes too long.
700 static struct dentry
*open_root_dentry(struct ceph_fs_client
*fsc
,
702 unsigned long started
)
704 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
705 struct ceph_mds_request
*req
= NULL
;
710 dout("open_root_inode opening '%s'\n", path
);
711 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_GETATTR
, USE_ANY_MDS
);
713 return ERR_CAST(req
);
714 req
->r_path1
= kstrdup(path
, GFP_NOFS
);
715 req
->r_ino1
.ino
= CEPH_INO_ROOT
;
716 req
->r_ino1
.snap
= CEPH_NOSNAP
;
717 req
->r_started
= started
;
718 req
->r_timeout
= fsc
->client
->options
->mount_timeout
* HZ
;
719 req
->r_args
.getattr
.mask
= cpu_to_le32(CEPH_STAT_CAP_INODE
);
721 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
723 struct inode
*inode
= req
->r_target_inode
;
724 req
->r_target_inode
= NULL
;
725 dout("open_root_inode success\n");
726 if (ceph_ino(inode
) == CEPH_INO_ROOT
&&
727 fsc
->sb
->s_root
== NULL
) {
728 root
= d_make_root(inode
);
730 root
= ERR_PTR(-ENOMEM
);
734 root
= d_obtain_alias(inode
);
736 ceph_init_dentry(root
);
737 dout("open_root_inode success, root dentry is %p\n", root
);
742 ceph_mdsc_put_request(req
);
750 * mount: join the ceph cluster, and open root directory.
752 static struct dentry
*ceph_real_mount(struct ceph_fs_client
*fsc
,
756 unsigned long started
= jiffies
; /* note the start time */
758 int first
= 0; /* first vfsmount for this super_block */
760 dout("mount start\n");
761 mutex_lock(&fsc
->client
->mount_mutex
);
763 err
= __ceph_open_session(fsc
->client
, started
);
767 dout("mount opening root\n");
768 root
= open_root_dentry(fsc
, "", started
);
773 if (fsc
->sb
->s_root
) {
776 fsc
->sb
->s_root
= root
;
779 err
= ceph_fs_debugfs_init(fsc
);
787 dout("mount opening base mountpoint\n");
788 root
= open_root_dentry(fsc
, path
, started
);
795 fsc
->mount_state
= CEPH_MOUNT_MOUNTED
;
796 dout("mount success\n");
797 mutex_unlock(&fsc
->client
->mount_mutex
);
801 mutex_unlock(&fsc
->client
->mount_mutex
);
806 dput(fsc
->sb
->s_root
);
807 fsc
->sb
->s_root
= NULL
;
812 static int ceph_set_super(struct super_block
*s
, void *data
)
814 struct ceph_fs_client
*fsc
= data
;
817 dout("set_super %p data %p\n", s
, data
);
819 s
->s_flags
= fsc
->mount_options
->sb_flags
;
820 s
->s_maxbytes
= 1ULL << 40; /* temp value until we get mdsmap */
825 s
->s_op
= &ceph_super_ops
;
826 s
->s_export_op
= &ceph_export_ops
;
828 s
->s_time_gran
= 1000; /* 1000 ns == 1 us */
830 ret
= set_anon_super(s
, NULL
); /* what is that second arg for? */
843 * share superblock if same fs AND options
845 static int ceph_compare_super(struct super_block
*sb
, void *data
)
847 struct ceph_fs_client
*new = data
;
848 struct ceph_mount_options
*fsopt
= new->mount_options
;
849 struct ceph_options
*opt
= new->client
->options
;
850 struct ceph_fs_client
*other
= ceph_sb_to_client(sb
);
852 dout("ceph_compare_super %p\n", sb
);
854 if (compare_mount_options(fsopt
, opt
, other
)) {
855 dout("monitor(s)/mount options don't match\n");
858 if ((opt
->flags
& CEPH_OPT_FSID
) &&
859 ceph_fsid_compare(&opt
->fsid
, &other
->client
->fsid
)) {
860 dout("fsid doesn't match\n");
863 if (fsopt
->sb_flags
!= other
->mount_options
->sb_flags
) {
864 dout("flags differ\n");
871 * construct our own bdi so we can control readahead, etc.
873 static atomic_long_t bdi_seq
= ATOMIC_LONG_INIT(0);
875 static int ceph_register_bdi(struct super_block
*sb
,
876 struct ceph_fs_client
*fsc
)
880 /* set ra_pages based on rasize mount option? */
881 if (fsc
->mount_options
->rasize
>= PAGE_CACHE_SIZE
)
882 fsc
->backing_dev_info
.ra_pages
=
883 (fsc
->mount_options
->rasize
+ PAGE_CACHE_SIZE
- 1)
886 fsc
->backing_dev_info
.ra_pages
=
887 default_backing_dev_info
.ra_pages
;
889 err
= bdi_register(&fsc
->backing_dev_info
, NULL
, "ceph-%ld",
890 atomic_long_inc_return(&bdi_seq
));
892 sb
->s_bdi
= &fsc
->backing_dev_info
;
896 static struct dentry
*ceph_mount(struct file_system_type
*fs_type
,
897 int flags
, const char *dev_name
, void *data
)
899 struct super_block
*sb
;
900 struct ceph_fs_client
*fsc
;
903 int (*compare_super
)(struct super_block
*, void *) = ceph_compare_super
;
904 const char *path
= NULL
;
905 struct ceph_mount_options
*fsopt
= NULL
;
906 struct ceph_options
*opt
= NULL
;
908 dout("ceph_mount\n");
909 err
= parse_mount_options(&fsopt
, &opt
, flags
, data
, dev_name
, &path
);
915 /* create client (which we may/may not use) */
916 fsc
= create_fs_client(fsopt
, opt
);
919 destroy_mount_options(fsopt
);
920 ceph_destroy_options(opt
);
924 err
= ceph_mdsc_init(fsc
);
930 if (ceph_test_opt(fsc
->client
, NOSHARE
))
931 compare_super
= NULL
;
932 sb
= sget(fs_type
, compare_super
, ceph_set_super
, flags
, fsc
);
938 if (ceph_sb_to_client(sb
) != fsc
) {
939 ceph_mdsc_destroy(fsc
);
940 destroy_fs_client(fsc
);
941 fsc
= ceph_sb_to_client(sb
);
942 dout("get_sb got existing client %p\n", fsc
);
944 dout("get_sb using new client %p\n", fsc
);
945 err
= ceph_register_bdi(sb
, fsc
);
952 res
= ceph_real_mount(fsc
, path
);
955 dout("root %p inode %p ino %llx.%llx\n", res
,
956 res
->d_inode
, ceph_vinop(res
->d_inode
));
960 ceph_mdsc_close_sessions(fsc
->mdsc
);
961 deactivate_locked_super(sb
);
965 ceph_mdsc_destroy(fsc
);
966 destroy_fs_client(fsc
);
968 dout("ceph_mount fail %ld\n", PTR_ERR(res
));
972 static void ceph_kill_sb(struct super_block
*s
)
974 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
975 dout("kill_sb %p\n", s
);
976 ceph_mdsc_pre_umount(fsc
->mdsc
);
977 kill_anon_super(s
); /* will call put_super after sb is r/o */
978 ceph_mdsc_destroy(fsc
);
979 destroy_fs_client(fsc
);
982 static struct file_system_type ceph_fs_type
= {
983 .owner
= THIS_MODULE
,
986 .kill_sb
= ceph_kill_sb
,
987 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
989 MODULE_ALIAS_FS("ceph");
991 #define _STRINGIFY(x) #x
992 #define STRINGIFY(x) _STRINGIFY(x)
994 static int __init
init_ceph(void)
996 int ret
= init_caches();
1001 ret
= register_filesystem(&ceph_fs_type
);
1005 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL
);
1016 static void __exit
exit_ceph(void)
1018 dout("exit_ceph\n");
1019 unregister_filesystem(&ceph_fs_type
);
1024 module_init(init_ceph
);
1025 module_exit(exit_ceph
);
1027 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1028 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1029 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1030 MODULE_DESCRIPTION("Ceph filesystem for Linux");
1031 MODULE_LICENSE("GPL");