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"
21 #include <linux/ceph/ceph_features.h>
22 #include <linux/ceph/decode.h>
23 #include <linux/ceph/mon_client.h>
24 #include <linux/ceph/auth.h>
25 #include <linux/ceph/debugfs.h>
28 * Ceph superblock operations
30 * Handle the basics of mounting, unmounting.
36 static void ceph_put_super(struct super_block
*s
)
38 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
41 ceph_mdsc_close_sessions(fsc
->mdsc
);
44 * ensure we release the bdi before put_anon_super releases
47 if (s
->s_bdi
== &fsc
->backing_dev_info
) {
48 bdi_unregister(&fsc
->backing_dev_info
);
55 static int ceph_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
57 struct ceph_fs_client
*fsc
= ceph_inode_to_client(dentry
->d_inode
);
58 struct ceph_monmap
*monmap
= fsc
->client
->monc
.monmap
;
59 struct ceph_statfs st
;
64 err
= ceph_monc_do_statfs(&fsc
->client
->monc
, &st
);
69 buf
->f_type
= CEPH_SUPER_MAGIC
; /* ?? */
72 * express utilization in terms of large blocks to avoid
73 * overflow on 32-bit machines.
75 * NOTE: for the time being, we make bsize == frsize to humor
76 * not-yet-ancient versions of glibc that are broken.
77 * Someday, we will probably want to report a real block
78 * size... whatever that may mean for a network file system!
80 buf
->f_bsize
= 1 << CEPH_BLOCK_SHIFT
;
81 buf
->f_frsize
= 1 << CEPH_BLOCK_SHIFT
;
82 buf
->f_blocks
= le64_to_cpu(st
.kb
) >> (CEPH_BLOCK_SHIFT
-10);
83 buf
->f_bfree
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
84 buf
->f_bavail
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
86 buf
->f_files
= le64_to_cpu(st
.num_objects
);
88 buf
->f_namelen
= NAME_MAX
;
90 /* leave fsid little-endian, regardless of host endianness */
91 fsid
= *(u64
*)(&monmap
->fsid
) ^ *((u64
*)&monmap
->fsid
+ 1);
92 buf
->f_fsid
.val
[0] = fsid
& 0xffffffff;
93 buf
->f_fsid
.val
[1] = fsid
>> 32;
99 static int ceph_sync_fs(struct super_block
*sb
, int wait
)
101 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
104 dout("sync_fs (non-blocking)\n");
105 ceph_flush_dirty_caps(fsc
->mdsc
);
106 dout("sync_fs (non-blocking) done\n");
110 dout("sync_fs (blocking)\n");
111 ceph_osdc_sync(&fsc
->client
->osdc
);
112 ceph_mdsc_sync(fsc
->mdsc
);
113 dout("sync_fs (blocking) done\n");
124 Opt_caps_wanted_delay_min
,
125 Opt_caps_wanted_delay_max
,
126 Opt_cap_release_safety
,
127 Opt_readdir_max_entries
,
128 Opt_readdir_max_bytes
,
134 /* string args above */
147 static match_table_t fsopt_tokens
= {
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"},
173 static int parse_fsopt_token(char *c
, void *private)
175 struct ceph_mount_options
*fsopt
= private;
176 substring_t argstr
[MAX_OPT_ARGS
];
177 int token
, intval
, ret
;
179 token
= match_token((char *)c
, fsopt_tokens
, argstr
);
183 if (token
< Opt_last_int
) {
184 ret
= match_int(&argstr
[0], &intval
);
186 pr_err("bad mount option arg (not int) "
190 dout("got int token %d val %d\n", token
, intval
);
191 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
192 dout("got string token %d val %s\n", token
,
195 dout("got token %d\n", token
);
199 case Opt_snapdirname
:
200 kfree(fsopt
->snapdir_name
);
201 fsopt
->snapdir_name
= kstrndup(argstr
[0].from
,
202 argstr
[0].to
-argstr
[0].from
,
204 if (!fsopt
->snapdir_name
)
210 fsopt
->wsize
= intval
;
213 fsopt
->rsize
= intval
;
216 fsopt
->rasize
= intval
;
218 case Opt_caps_wanted_delay_min
:
219 fsopt
->caps_wanted_delay_min
= intval
;
221 case Opt_caps_wanted_delay_max
:
222 fsopt
->caps_wanted_delay_max
= intval
;
224 case Opt_readdir_max_entries
:
225 fsopt
->max_readdir
= intval
;
227 case Opt_readdir_max_bytes
:
228 fsopt
->max_readdir_bytes
= intval
;
230 case Opt_congestion_kb
:
231 fsopt
->congestion_kb
= intval
;
234 fsopt
->flags
|= CEPH_MOUNT_OPT_DIRSTAT
;
237 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DIRSTAT
;
240 fsopt
->flags
|= CEPH_MOUNT_OPT_RBYTES
;
243 fsopt
->flags
&= ~CEPH_MOUNT_OPT_RBYTES
;
245 case Opt_asyncreaddir
:
246 fsopt
->flags
&= ~CEPH_MOUNT_OPT_NOASYNCREADDIR
;
248 case Opt_noasyncreaddir
:
249 fsopt
->flags
|= CEPH_MOUNT_OPT_NOASYNCREADDIR
;
252 fsopt
->flags
|= CEPH_MOUNT_OPT_DCACHE
;
255 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DCACHE
;
258 fsopt
->flags
|= CEPH_MOUNT_OPT_INO32
;
261 fsopt
->flags
&= ~CEPH_MOUNT_OPT_INO32
;
269 static void destroy_mount_options(struct ceph_mount_options
*args
)
271 dout("destroy_mount_options %p\n", args
);
272 kfree(args
->snapdir_name
);
276 static int strcmp_null(const char *s1
, const char *s2
)
284 return strcmp(s1
, s2
);
287 static int compare_mount_options(struct ceph_mount_options
*new_fsopt
,
288 struct ceph_options
*new_opt
,
289 struct ceph_fs_client
*fsc
)
291 struct ceph_mount_options
*fsopt1
= new_fsopt
;
292 struct ceph_mount_options
*fsopt2
= fsc
->mount_options
;
293 int ofs
= offsetof(struct ceph_mount_options
, snapdir_name
);
296 ret
= memcmp(fsopt1
, fsopt2
, ofs
);
300 ret
= strcmp_null(fsopt1
->snapdir_name
, fsopt2
->snapdir_name
);
304 return ceph_compare_options(new_opt
, fsc
->client
);
307 static int parse_mount_options(struct ceph_mount_options
**pfsopt
,
308 struct ceph_options
**popt
,
309 int flags
, char *options
,
310 const char *dev_name
,
313 struct ceph_mount_options
*fsopt
;
314 const char *dev_name_end
;
317 if (!dev_name
|| !*dev_name
)
320 fsopt
= kzalloc(sizeof(*fsopt
), GFP_KERNEL
);
324 dout("parse_mount_options %p, dev_name '%s'\n", fsopt
, dev_name
);
326 fsopt
->sb_flags
= flags
;
327 fsopt
->flags
= CEPH_MOUNT_OPT_DEFAULT
;
329 fsopt
->rsize
= CEPH_RSIZE_DEFAULT
;
330 fsopt
->rasize
= CEPH_RASIZE_DEFAULT
;
331 fsopt
->snapdir_name
= kstrdup(CEPH_SNAPDIRNAME_DEFAULT
, GFP_KERNEL
);
332 fsopt
->caps_wanted_delay_min
= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
;
333 fsopt
->caps_wanted_delay_max
= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
;
334 fsopt
->cap_release_safety
= CEPH_CAP_RELEASE_SAFETY_DEFAULT
;
335 fsopt
->max_readdir
= CEPH_MAX_READDIR_DEFAULT
;
336 fsopt
->max_readdir_bytes
= CEPH_MAX_READDIR_BYTES_DEFAULT
;
337 fsopt
->congestion_kb
= default_congestion_kb();
340 * Distinguish the server list from the path in "dev_name".
341 * Internally we do not include the leading '/' in the path.
343 * "dev_name" will look like:
344 * <server_spec>[,<server_spec>...]:[<path>]
346 * <server_spec> is <ip>[:<port>]
347 * <path> is optional, but if present must begin with '/'
349 dev_name_end
= strchr(dev_name
, '/');
351 /* skip over leading '/' for path */
352 *path
= dev_name_end
+ 1;
355 dev_name_end
= dev_name
+ strlen(dev_name
);
356 *path
= dev_name_end
;
359 dev_name_end
--; /* back up to ':' separator */
360 if (*dev_name_end
!= ':') {
361 pr_err("device name is missing path (no : separator in %s)\n",
365 dout("device name '%.*s'\n", (int)(dev_name_end
- dev_name
), dev_name
);
366 dout("server path '%s'\n", *path
);
368 *popt
= ceph_parse_options(options
, dev_name
, dev_name_end
,
369 parse_fsopt_token
, (void *)fsopt
);
371 err
= PTR_ERR(*popt
);
380 destroy_mount_options(fsopt
);
385 * ceph_show_options - Show mount options in /proc/mounts
386 * @m: seq_file to write to
387 * @root: root of that (sub)tree
389 static int ceph_show_options(struct seq_file
*m
, struct dentry
*root
)
391 struct ceph_fs_client
*fsc
= ceph_sb_to_client(root
->d_sb
);
392 struct ceph_mount_options
*fsopt
= fsc
->mount_options
;
393 struct ceph_options
*opt
= fsc
->client
->options
;
395 if (opt
->flags
& CEPH_OPT_FSID
)
396 seq_printf(m
, ",fsid=%pU", &opt
->fsid
);
397 if (opt
->flags
& CEPH_OPT_NOSHARE
)
398 seq_puts(m
, ",noshare");
399 if (opt
->flags
& CEPH_OPT_NOCRC
)
400 seq_puts(m
, ",nocrc");
403 seq_printf(m
, ",name=%s", opt
->name
);
405 seq_puts(m
, ",secret=<hidden>");
407 if (opt
->mount_timeout
!= CEPH_MOUNT_TIMEOUT_DEFAULT
)
408 seq_printf(m
, ",mount_timeout=%d", opt
->mount_timeout
);
409 if (opt
->osd_idle_ttl
!= CEPH_OSD_IDLE_TTL_DEFAULT
)
410 seq_printf(m
, ",osd_idle_ttl=%d", opt
->osd_idle_ttl
);
411 if (opt
->osd_keepalive_timeout
!= CEPH_OSD_KEEPALIVE_DEFAULT
)
412 seq_printf(m
, ",osdkeepalivetimeout=%d",
413 opt
->osd_keepalive_timeout
);
415 if (fsopt
->flags
& CEPH_MOUNT_OPT_DIRSTAT
)
416 seq_puts(m
, ",dirstat");
417 if ((fsopt
->flags
& CEPH_MOUNT_OPT_RBYTES
) == 0)
418 seq_puts(m
, ",norbytes");
419 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOASYNCREADDIR
)
420 seq_puts(m
, ",noasyncreaddir");
421 if (fsopt
->flags
& CEPH_MOUNT_OPT_DCACHE
)
422 seq_puts(m
, ",dcache");
424 seq_puts(m
, ",nodcache");
427 seq_printf(m
, ",wsize=%d", fsopt
->wsize
);
428 if (fsopt
->rsize
!= CEPH_RSIZE_DEFAULT
)
429 seq_printf(m
, ",rsize=%d", fsopt
->rsize
);
430 if (fsopt
->rasize
!= CEPH_RASIZE_DEFAULT
)
431 seq_printf(m
, ",rasize=%d", fsopt
->rasize
);
432 if (fsopt
->congestion_kb
!= default_congestion_kb())
433 seq_printf(m
, ",write_congestion_kb=%d", fsopt
->congestion_kb
);
434 if (fsopt
->caps_wanted_delay_min
!= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
)
435 seq_printf(m
, ",caps_wanted_delay_min=%d",
436 fsopt
->caps_wanted_delay_min
);
437 if (fsopt
->caps_wanted_delay_max
!= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
)
438 seq_printf(m
, ",caps_wanted_delay_max=%d",
439 fsopt
->caps_wanted_delay_max
);
440 if (fsopt
->cap_release_safety
!= CEPH_CAP_RELEASE_SAFETY_DEFAULT
)
441 seq_printf(m
, ",cap_release_safety=%d",
442 fsopt
->cap_release_safety
);
443 if (fsopt
->max_readdir
!= CEPH_MAX_READDIR_DEFAULT
)
444 seq_printf(m
, ",readdir_max_entries=%d", fsopt
->max_readdir
);
445 if (fsopt
->max_readdir_bytes
!= CEPH_MAX_READDIR_BYTES_DEFAULT
)
446 seq_printf(m
, ",readdir_max_bytes=%d", fsopt
->max_readdir_bytes
);
447 if (strcmp(fsopt
->snapdir_name
, CEPH_SNAPDIRNAME_DEFAULT
))
448 seq_printf(m
, ",snapdirname=%s", fsopt
->snapdir_name
);
453 * handle any mon messages the standard library doesn't understand.
454 * return error if we don't either.
456 static int extra_mon_dispatch(struct ceph_client
*client
, struct ceph_msg
*msg
)
458 struct ceph_fs_client
*fsc
= client
->private;
459 int type
= le16_to_cpu(msg
->hdr
.type
);
462 case CEPH_MSG_MDS_MAP
:
463 ceph_mdsc_handle_map(fsc
->mdsc
, msg
);
472 * create a new fs client
474 static struct ceph_fs_client
*create_fs_client(struct ceph_mount_options
*fsopt
,
475 struct ceph_options
*opt
)
477 struct ceph_fs_client
*fsc
;
478 const unsigned supported_features
=
480 CEPH_FEATURE_DIRLAYOUTHASH
;
481 const unsigned required_features
= 0;
484 fsc
= kzalloc(sizeof(*fsc
), GFP_KERNEL
);
486 return ERR_PTR(-ENOMEM
);
488 fsc
->client
= ceph_create_client(opt
, fsc
, supported_features
,
490 if (IS_ERR(fsc
->client
)) {
491 err
= PTR_ERR(fsc
->client
);
494 fsc
->client
->extra_mon_dispatch
= extra_mon_dispatch
;
495 fsc
->client
->monc
.want_mdsmap
= 1;
497 fsc
->mount_options
= fsopt
;
500 fsc
->mount_state
= CEPH_MOUNT_MOUNTING
;
502 atomic_long_set(&fsc
->writeback_count
, 0);
504 err
= bdi_init(&fsc
->backing_dev_info
);
510 * The number of concurrent works can be high but they don't need
511 * to be processed in parallel, limit concurrency.
513 fsc
->wb_wq
= alloc_workqueue("ceph-writeback", 0, 1);
514 if (fsc
->wb_wq
== NULL
)
516 fsc
->pg_inv_wq
= alloc_workqueue("ceph-pg-invalid", 0, 1);
517 if (fsc
->pg_inv_wq
== NULL
)
519 fsc
->trunc_wq
= alloc_workqueue("ceph-trunc", 0, 1);
520 if (fsc
->trunc_wq
== NULL
)
523 /* set up mempools */
525 fsc
->wb_pagevec_pool
= mempool_create_kmalloc_pool(10,
526 fsc
->mount_options
->wsize
>> PAGE_CACHE_SHIFT
);
527 if (!fsc
->wb_pagevec_pool
)
531 fsc
->min_caps
= fsopt
->max_readdir
;
536 destroy_workqueue(fsc
->trunc_wq
);
538 destroy_workqueue(fsc
->pg_inv_wq
);
540 destroy_workqueue(fsc
->wb_wq
);
542 bdi_destroy(&fsc
->backing_dev_info
);
544 ceph_destroy_client(fsc
->client
);
550 static void destroy_fs_client(struct ceph_fs_client
*fsc
)
552 dout("destroy_fs_client %p\n", fsc
);
554 destroy_workqueue(fsc
->wb_wq
);
555 destroy_workqueue(fsc
->pg_inv_wq
);
556 destroy_workqueue(fsc
->trunc_wq
);
558 bdi_destroy(&fsc
->backing_dev_info
);
560 mempool_destroy(fsc
->wb_pagevec_pool
);
562 destroy_mount_options(fsc
->mount_options
);
564 ceph_fs_debugfs_cleanup(fsc
);
566 ceph_destroy_client(fsc
->client
);
569 dout("destroy_fs_client %p done\n", fsc
);
575 struct kmem_cache
*ceph_inode_cachep
;
576 struct kmem_cache
*ceph_cap_cachep
;
577 struct kmem_cache
*ceph_dentry_cachep
;
578 struct kmem_cache
*ceph_file_cachep
;
580 static void ceph_inode_init_once(void *foo
)
582 struct ceph_inode_info
*ci
= foo
;
583 inode_init_once(&ci
->vfs_inode
);
586 static int __init
init_caches(void)
588 ceph_inode_cachep
= kmem_cache_create("ceph_inode_info",
589 sizeof(struct ceph_inode_info
),
590 __alignof__(struct ceph_inode_info
),
591 (SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
),
592 ceph_inode_init_once
);
593 if (ceph_inode_cachep
== NULL
)
596 ceph_cap_cachep
= KMEM_CACHE(ceph_cap
,
597 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
598 if (ceph_cap_cachep
== NULL
)
601 ceph_dentry_cachep
= KMEM_CACHE(ceph_dentry_info
,
602 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
603 if (ceph_dentry_cachep
== NULL
)
606 ceph_file_cachep
= KMEM_CACHE(ceph_file_info
,
607 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
608 if (ceph_file_cachep
== NULL
)
614 kmem_cache_destroy(ceph_dentry_cachep
);
616 kmem_cache_destroy(ceph_cap_cachep
);
618 kmem_cache_destroy(ceph_inode_cachep
);
622 static void destroy_caches(void)
625 * Make sure all delayed rcu free inodes are flushed before we
629 kmem_cache_destroy(ceph_inode_cachep
);
630 kmem_cache_destroy(ceph_cap_cachep
);
631 kmem_cache_destroy(ceph_dentry_cachep
);
632 kmem_cache_destroy(ceph_file_cachep
);
637 * ceph_umount_begin - initiate forced umount. Tear down down the
638 * mount, skipping steps that may hang while waiting for server(s).
640 static void ceph_umount_begin(struct super_block
*sb
)
642 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
644 dout("ceph_umount_begin - starting forced umount\n");
647 fsc
->mount_state
= CEPH_MOUNT_SHUTDOWN
;
651 static const struct super_operations ceph_super_ops
= {
652 .alloc_inode
= ceph_alloc_inode
,
653 .destroy_inode
= ceph_destroy_inode
,
654 .write_inode
= ceph_write_inode
,
655 .sync_fs
= ceph_sync_fs
,
656 .put_super
= ceph_put_super
,
657 .show_options
= ceph_show_options
,
658 .statfs
= ceph_statfs
,
659 .umount_begin
= ceph_umount_begin
,
663 * Bootstrap mount by opening the root directory. Note the mount
664 * @started time from caller, and time out if this takes too long.
666 static struct dentry
*open_root_dentry(struct ceph_fs_client
*fsc
,
668 unsigned long started
)
670 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
671 struct ceph_mds_request
*req
= NULL
;
676 dout("open_root_inode opening '%s'\n", path
);
677 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_GETATTR
, USE_ANY_MDS
);
679 return ERR_CAST(req
);
680 req
->r_path1
= kstrdup(path
, GFP_NOFS
);
681 req
->r_ino1
.ino
= CEPH_INO_ROOT
;
682 req
->r_ino1
.snap
= CEPH_NOSNAP
;
683 req
->r_started
= started
;
684 req
->r_timeout
= fsc
->client
->options
->mount_timeout
* HZ
;
685 req
->r_args
.getattr
.mask
= cpu_to_le32(CEPH_STAT_CAP_INODE
);
687 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
689 struct inode
*inode
= req
->r_target_inode
;
690 req
->r_target_inode
= NULL
;
691 dout("open_root_inode success\n");
692 if (ceph_ino(inode
) == CEPH_INO_ROOT
&&
693 fsc
->sb
->s_root
== NULL
) {
694 root
= d_make_root(inode
);
696 root
= ERR_PTR(-ENOMEM
);
700 root
= d_obtain_alias(inode
);
702 ceph_init_dentry(root
);
703 dout("open_root_inode success, root dentry is %p\n", root
);
708 ceph_mdsc_put_request(req
);
716 * mount: join the ceph cluster, and open root directory.
718 static struct dentry
*ceph_real_mount(struct ceph_fs_client
*fsc
,
722 unsigned long started
= jiffies
; /* note the start time */
724 int first
= 0; /* first vfsmount for this super_block */
726 dout("mount start\n");
727 mutex_lock(&fsc
->client
->mount_mutex
);
729 err
= __ceph_open_session(fsc
->client
, started
);
733 dout("mount opening root\n");
734 root
= open_root_dentry(fsc
, "", started
);
739 if (fsc
->sb
->s_root
) {
742 fsc
->sb
->s_root
= root
;
745 err
= ceph_fs_debugfs_init(fsc
);
753 dout("mount opening base mountpoint\n");
754 root
= open_root_dentry(fsc
, path
, started
);
761 fsc
->mount_state
= CEPH_MOUNT_MOUNTED
;
762 dout("mount success\n");
763 mutex_unlock(&fsc
->client
->mount_mutex
);
767 mutex_unlock(&fsc
->client
->mount_mutex
);
772 dput(fsc
->sb
->s_root
);
773 fsc
->sb
->s_root
= NULL
;
778 static int ceph_set_super(struct super_block
*s
, void *data
)
780 struct ceph_fs_client
*fsc
= data
;
783 dout("set_super %p data %p\n", s
, data
);
785 s
->s_flags
= fsc
->mount_options
->sb_flags
;
786 s
->s_maxbytes
= 1ULL << 40; /* temp value until we get mdsmap */
791 s
->s_op
= &ceph_super_ops
;
792 s
->s_export_op
= &ceph_export_ops
;
794 s
->s_time_gran
= 1000; /* 1000 ns == 1 us */
796 ret
= set_anon_super(s
, NULL
); /* what is that second arg for? */
809 * share superblock if same fs AND options
811 static int ceph_compare_super(struct super_block
*sb
, void *data
)
813 struct ceph_fs_client
*new = data
;
814 struct ceph_mount_options
*fsopt
= new->mount_options
;
815 struct ceph_options
*opt
= new->client
->options
;
816 struct ceph_fs_client
*other
= ceph_sb_to_client(sb
);
818 dout("ceph_compare_super %p\n", sb
);
820 if (compare_mount_options(fsopt
, opt
, other
)) {
821 dout("monitor(s)/mount options don't match\n");
824 if ((opt
->flags
& CEPH_OPT_FSID
) &&
825 ceph_fsid_compare(&opt
->fsid
, &other
->client
->fsid
)) {
826 dout("fsid doesn't match\n");
829 if (fsopt
->sb_flags
!= other
->mount_options
->sb_flags
) {
830 dout("flags differ\n");
837 * construct our own bdi so we can control readahead, etc.
839 static atomic_long_t bdi_seq
= ATOMIC_LONG_INIT(0);
841 static int ceph_register_bdi(struct super_block
*sb
,
842 struct ceph_fs_client
*fsc
)
846 /* set ra_pages based on rasize mount option? */
847 if (fsc
->mount_options
->rasize
>= PAGE_CACHE_SIZE
)
848 fsc
->backing_dev_info
.ra_pages
=
849 (fsc
->mount_options
->rasize
+ PAGE_CACHE_SIZE
- 1)
852 fsc
->backing_dev_info
.ra_pages
=
853 default_backing_dev_info
.ra_pages
;
855 err
= bdi_register(&fsc
->backing_dev_info
, NULL
, "ceph-%ld",
856 atomic_long_inc_return(&bdi_seq
));
858 sb
->s_bdi
= &fsc
->backing_dev_info
;
862 static struct dentry
*ceph_mount(struct file_system_type
*fs_type
,
863 int flags
, const char *dev_name
, void *data
)
865 struct super_block
*sb
;
866 struct ceph_fs_client
*fsc
;
869 int (*compare_super
)(struct super_block
*, void *) = ceph_compare_super
;
870 const char *path
= NULL
;
871 struct ceph_mount_options
*fsopt
= NULL
;
872 struct ceph_options
*opt
= NULL
;
874 dout("ceph_mount\n");
875 err
= parse_mount_options(&fsopt
, &opt
, flags
, data
, dev_name
, &path
);
881 /* create client (which we may/may not use) */
882 fsc
= create_fs_client(fsopt
, opt
);
885 destroy_mount_options(fsopt
);
886 ceph_destroy_options(opt
);
890 err
= ceph_mdsc_init(fsc
);
896 if (ceph_test_opt(fsc
->client
, NOSHARE
))
897 compare_super
= NULL
;
898 sb
= sget(fs_type
, compare_super
, ceph_set_super
, flags
, fsc
);
904 if (ceph_sb_to_client(sb
) != fsc
) {
905 ceph_mdsc_destroy(fsc
);
906 destroy_fs_client(fsc
);
907 fsc
= ceph_sb_to_client(sb
);
908 dout("get_sb got existing client %p\n", fsc
);
910 dout("get_sb using new client %p\n", fsc
);
911 err
= ceph_register_bdi(sb
, fsc
);
918 res
= ceph_real_mount(fsc
, path
);
921 dout("root %p inode %p ino %llx.%llx\n", res
,
922 res
->d_inode
, ceph_vinop(res
->d_inode
));
926 ceph_mdsc_close_sessions(fsc
->mdsc
);
927 deactivate_locked_super(sb
);
931 ceph_mdsc_destroy(fsc
);
932 destroy_fs_client(fsc
);
934 dout("ceph_mount fail %ld\n", PTR_ERR(res
));
938 static void ceph_kill_sb(struct super_block
*s
)
940 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
941 dout("kill_sb %p\n", s
);
942 ceph_mdsc_pre_umount(fsc
->mdsc
);
943 kill_anon_super(s
); /* will call put_super after sb is r/o */
944 ceph_mdsc_destroy(fsc
);
945 destroy_fs_client(fsc
);
948 static struct file_system_type ceph_fs_type
= {
949 .owner
= THIS_MODULE
,
952 .kill_sb
= ceph_kill_sb
,
953 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
955 MODULE_ALIAS_FS("ceph");
957 #define _STRINGIFY(x) #x
958 #define STRINGIFY(x) _STRINGIFY(x)
960 static int __init
init_ceph(void)
962 int ret
= init_caches();
967 ret
= register_filesystem(&ceph_fs_type
);
971 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL
);
982 static void __exit
exit_ceph(void)
985 unregister_filesystem(&ceph_fs_type
);
990 module_init(init_ceph
);
991 module_exit(exit_ceph
);
993 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
994 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
995 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
996 MODULE_DESCRIPTION("Ceph filesystem for Linux");
997 MODULE_LICENSE("GPL");