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 buf
->f_bsize
= 1 << CEPH_BLOCK_SHIFT
;
76 buf
->f_blocks
= le64_to_cpu(st
.kb
) >> (CEPH_BLOCK_SHIFT
-10);
77 buf
->f_bfree
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
78 buf
->f_bavail
= le64_to_cpu(st
.kb_avail
) >> (CEPH_BLOCK_SHIFT
-10);
80 buf
->f_files
= le64_to_cpu(st
.num_objects
);
82 buf
->f_namelen
= NAME_MAX
;
83 buf
->f_frsize
= PAGE_CACHE_SIZE
;
85 /* leave fsid little-endian, regardless of host endianness */
86 fsid
= *(u64
*)(&monmap
->fsid
) ^ *((u64
*)&monmap
->fsid
+ 1);
87 buf
->f_fsid
.val
[0] = fsid
& 0xffffffff;
88 buf
->f_fsid
.val
[1] = fsid
>> 32;
94 static int ceph_sync_fs(struct super_block
*sb
, int wait
)
96 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
99 dout("sync_fs (non-blocking)\n");
100 ceph_flush_dirty_caps(fsc
->mdsc
);
101 dout("sync_fs (non-blocking) done\n");
105 dout("sync_fs (blocking)\n");
106 ceph_osdc_sync(&fsc
->client
->osdc
);
107 ceph_mdsc_sync(fsc
->mdsc
);
108 dout("sync_fs (blocking) done\n");
119 Opt_caps_wanted_delay_min
,
120 Opt_caps_wanted_delay_max
,
121 Opt_cap_release_safety
,
122 Opt_readdir_max_entries
,
123 Opt_readdir_max_bytes
,
129 /* string args above */
142 static match_table_t fsopt_tokens
= {
143 {Opt_wsize
, "wsize=%d"},
144 {Opt_rsize
, "rsize=%d"},
145 {Opt_rasize
, "rasize=%d"},
146 {Opt_caps_wanted_delay_min
, "caps_wanted_delay_min=%d"},
147 {Opt_caps_wanted_delay_max
, "caps_wanted_delay_max=%d"},
148 {Opt_cap_release_safety
, "cap_release_safety=%d"},
149 {Opt_readdir_max_entries
, "readdir_max_entries=%d"},
150 {Opt_readdir_max_bytes
, "readdir_max_bytes=%d"},
151 {Opt_congestion_kb
, "write_congestion_kb=%d"},
153 {Opt_snapdirname
, "snapdirname=%s"},
154 /* string args above */
155 {Opt_dirstat
, "dirstat"},
156 {Opt_nodirstat
, "nodirstat"},
157 {Opt_rbytes
, "rbytes"},
158 {Opt_norbytes
, "norbytes"},
159 {Opt_asyncreaddir
, "asyncreaddir"},
160 {Opt_noasyncreaddir
, "noasyncreaddir"},
161 {Opt_dcache
, "dcache"},
162 {Opt_nodcache
, "nodcache"},
163 {Opt_ino32
, "ino32"},
164 {Opt_noino32
, "noino32"},
168 static int parse_fsopt_token(char *c
, void *private)
170 struct ceph_mount_options
*fsopt
= private;
171 substring_t argstr
[MAX_OPT_ARGS
];
172 int token
, intval
, ret
;
174 token
= match_token((char *)c
, fsopt_tokens
, argstr
);
178 if (token
< Opt_last_int
) {
179 ret
= match_int(&argstr
[0], &intval
);
181 pr_err("bad mount option arg (not int) "
185 dout("got int token %d val %d\n", token
, intval
);
186 } else if (token
> Opt_last_int
&& token
< Opt_last_string
) {
187 dout("got string token %d val %s\n", token
,
190 dout("got token %d\n", token
);
194 case Opt_snapdirname
:
195 kfree(fsopt
->snapdir_name
);
196 fsopt
->snapdir_name
= kstrndup(argstr
[0].from
,
197 argstr
[0].to
-argstr
[0].from
,
199 if (!fsopt
->snapdir_name
)
205 fsopt
->wsize
= intval
;
208 fsopt
->rsize
= intval
;
211 fsopt
->rasize
= intval
;
213 case Opt_caps_wanted_delay_min
:
214 fsopt
->caps_wanted_delay_min
= intval
;
216 case Opt_caps_wanted_delay_max
:
217 fsopt
->caps_wanted_delay_max
= intval
;
219 case Opt_readdir_max_entries
:
220 fsopt
->max_readdir
= intval
;
222 case Opt_readdir_max_bytes
:
223 fsopt
->max_readdir_bytes
= intval
;
225 case Opt_congestion_kb
:
226 fsopt
->congestion_kb
= intval
;
229 fsopt
->flags
|= CEPH_MOUNT_OPT_DIRSTAT
;
232 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DIRSTAT
;
235 fsopt
->flags
|= CEPH_MOUNT_OPT_RBYTES
;
238 fsopt
->flags
&= ~CEPH_MOUNT_OPT_RBYTES
;
240 case Opt_asyncreaddir
:
241 fsopt
->flags
&= ~CEPH_MOUNT_OPT_NOASYNCREADDIR
;
243 case Opt_noasyncreaddir
:
244 fsopt
->flags
|= CEPH_MOUNT_OPT_NOASYNCREADDIR
;
247 fsopt
->flags
|= CEPH_MOUNT_OPT_DCACHE
;
250 fsopt
->flags
&= ~CEPH_MOUNT_OPT_DCACHE
;
253 fsopt
->flags
|= CEPH_MOUNT_OPT_INO32
;
256 fsopt
->flags
&= ~CEPH_MOUNT_OPT_INO32
;
264 static void destroy_mount_options(struct ceph_mount_options
*args
)
266 dout("destroy_mount_options %p\n", args
);
267 kfree(args
->snapdir_name
);
271 static int strcmp_null(const char *s1
, const char *s2
)
279 return strcmp(s1
, s2
);
282 static int compare_mount_options(struct ceph_mount_options
*new_fsopt
,
283 struct ceph_options
*new_opt
,
284 struct ceph_fs_client
*fsc
)
286 struct ceph_mount_options
*fsopt1
= new_fsopt
;
287 struct ceph_mount_options
*fsopt2
= fsc
->mount_options
;
288 int ofs
= offsetof(struct ceph_mount_options
, snapdir_name
);
291 ret
= memcmp(fsopt1
, fsopt2
, ofs
);
295 ret
= strcmp_null(fsopt1
->snapdir_name
, fsopt2
->snapdir_name
);
299 return ceph_compare_options(new_opt
, fsc
->client
);
302 static int parse_mount_options(struct ceph_mount_options
**pfsopt
,
303 struct ceph_options
**popt
,
304 int flags
, char *options
,
305 const char *dev_name
,
308 struct ceph_mount_options
*fsopt
;
309 const char *dev_name_end
;
312 fsopt
= kzalloc(sizeof(*fsopt
), GFP_KERNEL
);
316 dout("parse_mount_options %p, dev_name '%s'\n", fsopt
, dev_name
);
318 fsopt
->sb_flags
= flags
;
319 fsopt
->flags
= CEPH_MOUNT_OPT_DEFAULT
;
321 fsopt
->rsize
= CEPH_RSIZE_DEFAULT
;
322 fsopt
->rasize
= CEPH_RASIZE_DEFAULT
;
323 fsopt
->snapdir_name
= kstrdup(CEPH_SNAPDIRNAME_DEFAULT
, GFP_KERNEL
);
324 fsopt
->caps_wanted_delay_min
= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
;
325 fsopt
->caps_wanted_delay_max
= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
;
326 fsopt
->cap_release_safety
= CEPH_CAP_RELEASE_SAFETY_DEFAULT
;
327 fsopt
->max_readdir
= CEPH_MAX_READDIR_DEFAULT
;
328 fsopt
->max_readdir_bytes
= CEPH_MAX_READDIR_BYTES_DEFAULT
;
329 fsopt
->congestion_kb
= default_congestion_kb();
331 /* ip1[:port1][,ip2[:port2]...]:/subdir/in/fs */
335 *path
= strstr(dev_name
, ":/");
337 pr_err("device name is missing path (no :/ in %s)\n",
341 dev_name_end
= *path
;
342 dout("device name '%.*s'\n", (int)(dev_name_end
- dev_name
), dev_name
);
346 dout("server path '%s'\n", *path
);
348 *popt
= ceph_parse_options(options
, dev_name
, dev_name_end
,
349 parse_fsopt_token
, (void *)fsopt
);
351 err
= PTR_ERR(*popt
);
360 destroy_mount_options(fsopt
);
365 * ceph_show_options - Show mount options in /proc/mounts
366 * @m: seq_file to write to
367 * @root: root of that (sub)tree
369 static int ceph_show_options(struct seq_file
*m
, struct dentry
*root
)
371 struct ceph_fs_client
*fsc
= ceph_sb_to_client(root
->d_sb
);
372 struct ceph_mount_options
*fsopt
= fsc
->mount_options
;
373 struct ceph_options
*opt
= fsc
->client
->options
;
375 if (opt
->flags
& CEPH_OPT_FSID
)
376 seq_printf(m
, ",fsid=%pU", &opt
->fsid
);
377 if (opt
->flags
& CEPH_OPT_NOSHARE
)
378 seq_puts(m
, ",noshare");
379 if (opt
->flags
& CEPH_OPT_NOCRC
)
380 seq_puts(m
, ",nocrc");
383 seq_printf(m
, ",name=%s", opt
->name
);
385 seq_puts(m
, ",secret=<hidden>");
387 if (opt
->mount_timeout
!= CEPH_MOUNT_TIMEOUT_DEFAULT
)
388 seq_printf(m
, ",mount_timeout=%d", opt
->mount_timeout
);
389 if (opt
->osd_idle_ttl
!= CEPH_OSD_IDLE_TTL_DEFAULT
)
390 seq_printf(m
, ",osd_idle_ttl=%d", opt
->osd_idle_ttl
);
391 if (opt
->osd_timeout
!= CEPH_OSD_TIMEOUT_DEFAULT
)
392 seq_printf(m
, ",osdtimeout=%d", opt
->osd_timeout
);
393 if (opt
->osd_keepalive_timeout
!= CEPH_OSD_KEEPALIVE_DEFAULT
)
394 seq_printf(m
, ",osdkeepalivetimeout=%d",
395 opt
->osd_keepalive_timeout
);
397 if (fsopt
->flags
& CEPH_MOUNT_OPT_DIRSTAT
)
398 seq_puts(m
, ",dirstat");
399 if ((fsopt
->flags
& CEPH_MOUNT_OPT_RBYTES
) == 0)
400 seq_puts(m
, ",norbytes");
401 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOASYNCREADDIR
)
402 seq_puts(m
, ",noasyncreaddir");
403 if (fsopt
->flags
& CEPH_MOUNT_OPT_DCACHE
)
404 seq_puts(m
, ",dcache");
406 seq_puts(m
, ",nodcache");
409 seq_printf(m
, ",wsize=%d", fsopt
->wsize
);
410 if (fsopt
->rsize
!= CEPH_RSIZE_DEFAULT
)
411 seq_printf(m
, ",rsize=%d", fsopt
->rsize
);
412 if (fsopt
->rasize
!= CEPH_RASIZE_DEFAULT
)
413 seq_printf(m
, ",rasize=%d", fsopt
->rasize
);
414 if (fsopt
->congestion_kb
!= default_congestion_kb())
415 seq_printf(m
, ",write_congestion_kb=%d", fsopt
->congestion_kb
);
416 if (fsopt
->caps_wanted_delay_min
!= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
)
417 seq_printf(m
, ",caps_wanted_delay_min=%d",
418 fsopt
->caps_wanted_delay_min
);
419 if (fsopt
->caps_wanted_delay_max
!= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
)
420 seq_printf(m
, ",caps_wanted_delay_max=%d",
421 fsopt
->caps_wanted_delay_max
);
422 if (fsopt
->cap_release_safety
!= CEPH_CAP_RELEASE_SAFETY_DEFAULT
)
423 seq_printf(m
, ",cap_release_safety=%d",
424 fsopt
->cap_release_safety
);
425 if (fsopt
->max_readdir
!= CEPH_MAX_READDIR_DEFAULT
)
426 seq_printf(m
, ",readdir_max_entries=%d", fsopt
->max_readdir
);
427 if (fsopt
->max_readdir_bytes
!= CEPH_MAX_READDIR_BYTES_DEFAULT
)
428 seq_printf(m
, ",readdir_max_bytes=%d", fsopt
->max_readdir_bytes
);
429 if (strcmp(fsopt
->snapdir_name
, CEPH_SNAPDIRNAME_DEFAULT
))
430 seq_printf(m
, ",snapdirname=%s", fsopt
->snapdir_name
);
435 * handle any mon messages the standard library doesn't understand.
436 * return error if we don't either.
438 static int extra_mon_dispatch(struct ceph_client
*client
, struct ceph_msg
*msg
)
440 struct ceph_fs_client
*fsc
= client
->private;
441 int type
= le16_to_cpu(msg
->hdr
.type
);
444 case CEPH_MSG_MDS_MAP
:
445 ceph_mdsc_handle_map(fsc
->mdsc
, msg
);
454 * create a new fs client
456 static struct ceph_fs_client
*create_fs_client(struct ceph_mount_options
*fsopt
,
457 struct ceph_options
*opt
)
459 struct ceph_fs_client
*fsc
;
460 const unsigned supported_features
=
462 CEPH_FEATURE_DIRLAYOUTHASH
;
463 const unsigned required_features
= 0;
466 fsc
= kzalloc(sizeof(*fsc
), GFP_KERNEL
);
468 return ERR_PTR(-ENOMEM
);
470 fsc
->client
= ceph_create_client(opt
, fsc
, supported_features
,
472 if (IS_ERR(fsc
->client
)) {
473 err
= PTR_ERR(fsc
->client
);
476 fsc
->client
->extra_mon_dispatch
= extra_mon_dispatch
;
477 fsc
->client
->monc
.want_mdsmap
= 1;
479 fsc
->mount_options
= fsopt
;
482 fsc
->mount_state
= CEPH_MOUNT_MOUNTING
;
484 atomic_long_set(&fsc
->writeback_count
, 0);
486 err
= bdi_init(&fsc
->backing_dev_info
);
492 * The number of concurrent works can be high but they don't need
493 * to be processed in parallel, limit concurrency.
495 fsc
->wb_wq
= alloc_workqueue("ceph-writeback", 0, 1);
496 if (fsc
->wb_wq
== NULL
)
498 fsc
->pg_inv_wq
= alloc_workqueue("ceph-pg-invalid", 0, 1);
499 if (fsc
->pg_inv_wq
== NULL
)
501 fsc
->trunc_wq
= alloc_workqueue("ceph-trunc", 0, 1);
502 if (fsc
->trunc_wq
== NULL
)
505 /* set up mempools */
507 fsc
->wb_pagevec_pool
= mempool_create_kmalloc_pool(10,
508 fsc
->mount_options
->wsize
>> PAGE_CACHE_SHIFT
);
509 if (!fsc
->wb_pagevec_pool
)
513 fsc
->min_caps
= fsopt
->max_readdir
;
518 destroy_workqueue(fsc
->trunc_wq
);
520 destroy_workqueue(fsc
->pg_inv_wq
);
522 destroy_workqueue(fsc
->wb_wq
);
524 bdi_destroy(&fsc
->backing_dev_info
);
526 ceph_destroy_client(fsc
->client
);
532 static void destroy_fs_client(struct ceph_fs_client
*fsc
)
534 dout("destroy_fs_client %p\n", fsc
);
536 destroy_workqueue(fsc
->wb_wq
);
537 destroy_workqueue(fsc
->pg_inv_wq
);
538 destroy_workqueue(fsc
->trunc_wq
);
540 bdi_destroy(&fsc
->backing_dev_info
);
542 mempool_destroy(fsc
->wb_pagevec_pool
);
544 destroy_mount_options(fsc
->mount_options
);
546 ceph_fs_debugfs_cleanup(fsc
);
548 ceph_destroy_client(fsc
->client
);
551 dout("destroy_fs_client %p done\n", fsc
);
557 struct kmem_cache
*ceph_inode_cachep
;
558 struct kmem_cache
*ceph_cap_cachep
;
559 struct kmem_cache
*ceph_dentry_cachep
;
560 struct kmem_cache
*ceph_file_cachep
;
562 static void ceph_inode_init_once(void *foo
)
564 struct ceph_inode_info
*ci
= foo
;
565 inode_init_once(&ci
->vfs_inode
);
568 static int __init
init_caches(void)
570 ceph_inode_cachep
= kmem_cache_create("ceph_inode_info",
571 sizeof(struct ceph_inode_info
),
572 __alignof__(struct ceph_inode_info
),
573 (SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
),
574 ceph_inode_init_once
);
575 if (ceph_inode_cachep
== NULL
)
578 ceph_cap_cachep
= KMEM_CACHE(ceph_cap
,
579 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
580 if (ceph_cap_cachep
== NULL
)
583 ceph_dentry_cachep
= KMEM_CACHE(ceph_dentry_info
,
584 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
585 if (ceph_dentry_cachep
== NULL
)
588 ceph_file_cachep
= KMEM_CACHE(ceph_file_info
,
589 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
590 if (ceph_file_cachep
== NULL
)
596 kmem_cache_destroy(ceph_dentry_cachep
);
598 kmem_cache_destroy(ceph_cap_cachep
);
600 kmem_cache_destroy(ceph_inode_cachep
);
604 static void destroy_caches(void)
606 kmem_cache_destroy(ceph_inode_cachep
);
607 kmem_cache_destroy(ceph_cap_cachep
);
608 kmem_cache_destroy(ceph_dentry_cachep
);
609 kmem_cache_destroy(ceph_file_cachep
);
614 * ceph_umount_begin - initiate forced umount. Tear down down the
615 * mount, skipping steps that may hang while waiting for server(s).
617 static void ceph_umount_begin(struct super_block
*sb
)
619 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
621 dout("ceph_umount_begin - starting forced umount\n");
624 fsc
->mount_state
= CEPH_MOUNT_SHUTDOWN
;
628 static const struct super_operations ceph_super_ops
= {
629 .alloc_inode
= ceph_alloc_inode
,
630 .destroy_inode
= ceph_destroy_inode
,
631 .write_inode
= ceph_write_inode
,
632 .sync_fs
= ceph_sync_fs
,
633 .put_super
= ceph_put_super
,
634 .show_options
= ceph_show_options
,
635 .statfs
= ceph_statfs
,
636 .umount_begin
= ceph_umount_begin
,
640 * Bootstrap mount by opening the root directory. Note the mount
641 * @started time from caller, and time out if this takes too long.
643 static struct dentry
*open_root_dentry(struct ceph_fs_client
*fsc
,
645 unsigned long started
)
647 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
648 struct ceph_mds_request
*req
= NULL
;
653 dout("open_root_inode opening '%s'\n", path
);
654 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_GETATTR
, USE_ANY_MDS
);
656 return ERR_CAST(req
);
657 req
->r_path1
= kstrdup(path
, GFP_NOFS
);
658 req
->r_ino1
.ino
= CEPH_INO_ROOT
;
659 req
->r_ino1
.snap
= CEPH_NOSNAP
;
660 req
->r_started
= started
;
661 req
->r_timeout
= fsc
->client
->options
->mount_timeout
* HZ
;
662 req
->r_args
.getattr
.mask
= cpu_to_le32(CEPH_STAT_CAP_INODE
);
664 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
666 struct inode
*inode
= req
->r_target_inode
;
667 req
->r_target_inode
= NULL
;
668 dout("open_root_inode success\n");
669 if (ceph_ino(inode
) == CEPH_INO_ROOT
&&
670 fsc
->sb
->s_root
== NULL
) {
671 root
= d_make_root(inode
);
673 root
= ERR_PTR(-ENOMEM
);
677 root
= d_obtain_alias(inode
);
679 ceph_init_dentry(root
);
680 dout("open_root_inode success, root dentry is %p\n", root
);
685 ceph_mdsc_put_request(req
);
693 * mount: join the ceph cluster, and open root directory.
695 static struct dentry
*ceph_real_mount(struct ceph_fs_client
*fsc
,
699 unsigned long started
= jiffies
; /* note the start time */
701 int first
= 0; /* first vfsmount for this super_block */
703 dout("mount start\n");
704 mutex_lock(&fsc
->client
->mount_mutex
);
706 err
= __ceph_open_session(fsc
->client
, started
);
710 dout("mount opening root\n");
711 root
= open_root_dentry(fsc
, "", started
);
716 if (fsc
->sb
->s_root
) {
719 fsc
->sb
->s_root
= root
;
722 err
= ceph_fs_debugfs_init(fsc
);
730 dout("mount opening base mountpoint\n");
731 root
= open_root_dentry(fsc
, path
, started
);
738 fsc
->mount_state
= CEPH_MOUNT_MOUNTED
;
739 dout("mount success\n");
740 mutex_unlock(&fsc
->client
->mount_mutex
);
744 mutex_unlock(&fsc
->client
->mount_mutex
);
749 dput(fsc
->sb
->s_root
);
750 fsc
->sb
->s_root
= NULL
;
755 static int ceph_set_super(struct super_block
*s
, void *data
)
757 struct ceph_fs_client
*fsc
= data
;
760 dout("set_super %p data %p\n", s
, data
);
762 s
->s_flags
= fsc
->mount_options
->sb_flags
;
763 s
->s_maxbytes
= 1ULL << 40; /* temp value until we get mdsmap */
768 s
->s_op
= &ceph_super_ops
;
769 s
->s_export_op
= &ceph_export_ops
;
771 s
->s_time_gran
= 1000; /* 1000 ns == 1 us */
773 ret
= set_anon_super(s
, NULL
); /* what is that second arg for? */
786 * share superblock if same fs AND options
788 static int ceph_compare_super(struct super_block
*sb
, void *data
)
790 struct ceph_fs_client
*new = data
;
791 struct ceph_mount_options
*fsopt
= new->mount_options
;
792 struct ceph_options
*opt
= new->client
->options
;
793 struct ceph_fs_client
*other
= ceph_sb_to_client(sb
);
795 dout("ceph_compare_super %p\n", sb
);
797 if (compare_mount_options(fsopt
, opt
, other
)) {
798 dout("monitor(s)/mount options don't match\n");
801 if ((opt
->flags
& CEPH_OPT_FSID
) &&
802 ceph_fsid_compare(&opt
->fsid
, &other
->client
->fsid
)) {
803 dout("fsid doesn't match\n");
806 if (fsopt
->sb_flags
!= other
->mount_options
->sb_flags
) {
807 dout("flags differ\n");
814 * construct our own bdi so we can control readahead, etc.
816 static atomic_long_t bdi_seq
= ATOMIC_LONG_INIT(0);
818 static int ceph_register_bdi(struct super_block
*sb
,
819 struct ceph_fs_client
*fsc
)
823 /* set ra_pages based on rasize mount option? */
824 if (fsc
->mount_options
->rasize
>= PAGE_CACHE_SIZE
)
825 fsc
->backing_dev_info
.ra_pages
=
826 (fsc
->mount_options
->rasize
+ PAGE_CACHE_SIZE
- 1)
829 fsc
->backing_dev_info
.ra_pages
=
830 default_backing_dev_info
.ra_pages
;
832 err
= bdi_register(&fsc
->backing_dev_info
, NULL
, "ceph-%d",
833 atomic_long_inc_return(&bdi_seq
));
835 sb
->s_bdi
= &fsc
->backing_dev_info
;
839 static struct dentry
*ceph_mount(struct file_system_type
*fs_type
,
840 int flags
, const char *dev_name
, void *data
)
842 struct super_block
*sb
;
843 struct ceph_fs_client
*fsc
;
846 int (*compare_super
)(struct super_block
*, void *) = ceph_compare_super
;
847 const char *path
= NULL
;
848 struct ceph_mount_options
*fsopt
= NULL
;
849 struct ceph_options
*opt
= NULL
;
851 dout("ceph_mount\n");
852 err
= parse_mount_options(&fsopt
, &opt
, flags
, data
, dev_name
, &path
);
858 /* create client (which we may/may not use) */
859 fsc
= create_fs_client(fsopt
, opt
);
862 destroy_mount_options(fsopt
);
863 ceph_destroy_options(opt
);
867 err
= ceph_mdsc_init(fsc
);
873 if (ceph_test_opt(fsc
->client
, NOSHARE
))
874 compare_super
= NULL
;
875 sb
= sget(fs_type
, compare_super
, ceph_set_super
, flags
, fsc
);
881 if (ceph_sb_to_client(sb
) != fsc
) {
882 ceph_mdsc_destroy(fsc
);
883 destroy_fs_client(fsc
);
884 fsc
= ceph_sb_to_client(sb
);
885 dout("get_sb got existing client %p\n", fsc
);
887 dout("get_sb using new client %p\n", fsc
);
888 err
= ceph_register_bdi(sb
, fsc
);
895 res
= ceph_real_mount(fsc
, path
);
898 dout("root %p inode %p ino %llx.%llx\n", res
,
899 res
->d_inode
, ceph_vinop(res
->d_inode
));
903 ceph_mdsc_close_sessions(fsc
->mdsc
);
904 deactivate_locked_super(sb
);
908 ceph_mdsc_destroy(fsc
);
909 destroy_fs_client(fsc
);
911 dout("ceph_mount fail %ld\n", PTR_ERR(res
));
915 static void ceph_kill_sb(struct super_block
*s
)
917 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
918 dout("kill_sb %p\n", s
);
919 ceph_mdsc_pre_umount(fsc
->mdsc
);
920 kill_anon_super(s
); /* will call put_super after sb is r/o */
921 ceph_mdsc_destroy(fsc
);
922 destroy_fs_client(fsc
);
925 static struct file_system_type ceph_fs_type
= {
926 .owner
= THIS_MODULE
,
929 .kill_sb
= ceph_kill_sb
,
930 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
933 #define _STRINGIFY(x) #x
934 #define STRINGIFY(x) _STRINGIFY(x)
936 static int __init
init_ceph(void)
938 int ret
= init_caches();
943 ret
= register_filesystem(&ceph_fs_type
);
947 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL
);
958 static void __exit
exit_ceph(void)
961 unregister_filesystem(&ceph_fs_type
);
966 module_init(init_ceph
);
967 module_exit(exit_ceph
);
969 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
970 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
971 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
972 MODULE_DESCRIPTION("Ceph filesystem for Linux");
973 MODULE_LICENSE("GPL");