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
);
308 static int strcmp_null(const char *s1
, const char *s2
)
316 return strcmp(s1
, s2
);
319 static int compare_mount_options(struct ceph_mount_options
*new_fsopt
,
320 struct ceph_options
*new_opt
,
321 struct ceph_fs_client
*fsc
)
323 struct ceph_mount_options
*fsopt1
= new_fsopt
;
324 struct ceph_mount_options
*fsopt2
= fsc
->mount_options
;
325 int ofs
= offsetof(struct ceph_mount_options
, snapdir_name
);
328 ret
= memcmp(fsopt1
, fsopt2
, ofs
);
332 ret
= strcmp_null(fsopt1
->snapdir_name
, fsopt2
->snapdir_name
);
336 return ceph_compare_options(new_opt
, fsc
->client
);
339 static int parse_mount_options(struct ceph_mount_options
**pfsopt
,
340 struct ceph_options
**popt
,
341 int flags
, char *options
,
342 const char *dev_name
,
345 struct ceph_mount_options
*fsopt
;
346 const char *dev_name_end
;
349 if (!dev_name
|| !*dev_name
)
352 fsopt
= kzalloc(sizeof(*fsopt
), GFP_KERNEL
);
356 dout("parse_mount_options %p, dev_name '%s'\n", fsopt
, dev_name
);
358 fsopt
->sb_flags
= flags
;
359 fsopt
->flags
= CEPH_MOUNT_OPT_DEFAULT
;
361 fsopt
->rsize
= CEPH_RSIZE_DEFAULT
;
362 fsopt
->rasize
= CEPH_RASIZE_DEFAULT
;
363 fsopt
->snapdir_name
= kstrdup(CEPH_SNAPDIRNAME_DEFAULT
, GFP_KERNEL
);
364 if (!fsopt
->snapdir_name
) {
369 fsopt
->caps_wanted_delay_min
= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
;
370 fsopt
->caps_wanted_delay_max
= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
;
371 fsopt
->cap_release_safety
= CEPH_CAP_RELEASE_SAFETY_DEFAULT
;
372 fsopt
->max_readdir
= CEPH_MAX_READDIR_DEFAULT
;
373 fsopt
->max_readdir_bytes
= CEPH_MAX_READDIR_BYTES_DEFAULT
;
374 fsopt
->congestion_kb
= default_congestion_kb();
375 fsopt
->mds_namespace
= CEPH_FS_CLUSTER_ID_NONE
;
378 * Distinguish the server list from the path in "dev_name".
379 * Internally we do not include the leading '/' in the path.
381 * "dev_name" will look like:
382 * <server_spec>[,<server_spec>...]:[<path>]
384 * <server_spec> is <ip>[:<port>]
385 * <path> is optional, but if present must begin with '/'
387 dev_name_end
= strchr(dev_name
, '/');
389 /* skip over leading '/' for path */
390 *path
= dev_name_end
+ 1;
393 dev_name_end
= dev_name
+ strlen(dev_name
);
394 *path
= dev_name_end
;
397 dev_name_end
--; /* back up to ':' separator */
398 if (dev_name_end
< dev_name
|| *dev_name_end
!= ':') {
399 pr_err("device name is missing path (no : separator in %s)\n",
403 dout("device name '%.*s'\n", (int)(dev_name_end
- dev_name
), dev_name
);
404 dout("server path '%s'\n", *path
);
406 *popt
= ceph_parse_options(options
, dev_name
, dev_name_end
,
407 parse_fsopt_token
, (void *)fsopt
);
409 err
= PTR_ERR(*popt
);
418 destroy_mount_options(fsopt
);
423 * ceph_show_options - Show mount options in /proc/mounts
424 * @m: seq_file to write to
425 * @root: root of that (sub)tree
427 static int ceph_show_options(struct seq_file
*m
, struct dentry
*root
)
429 struct ceph_fs_client
*fsc
= ceph_sb_to_client(root
->d_sb
);
430 struct ceph_mount_options
*fsopt
= fsc
->mount_options
;
434 /* a comma between MNT/MS and client options */
438 ret
= ceph_print_client_options(m
, fsc
->client
);
442 /* retract our comma if no client options */
446 if (fsopt
->flags
& CEPH_MOUNT_OPT_DIRSTAT
)
447 seq_puts(m
, ",dirstat");
448 if ((fsopt
->flags
& CEPH_MOUNT_OPT_RBYTES
))
449 seq_puts(m
, ",rbytes");
450 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOASYNCREADDIR
)
451 seq_puts(m
, ",noasyncreaddir");
452 if ((fsopt
->flags
& CEPH_MOUNT_OPT_DCACHE
) == 0)
453 seq_puts(m
, ",nodcache");
454 if (fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
)
456 if (fsopt
->flags
& CEPH_MOUNT_OPT_NOPOOLPERM
)
457 seq_puts(m
, ",nopoolperm");
459 #ifdef CONFIG_CEPH_FS_POSIX_ACL
460 if (fsopt
->sb_flags
& MS_POSIXACL
)
463 seq_puts(m
, ",noacl");
466 if (fsopt
->mds_namespace
!= CEPH_FS_CLUSTER_ID_NONE
)
467 seq_printf(m
, ",mds_namespace=%d", fsopt
->mds_namespace
);
469 seq_printf(m
, ",wsize=%d", fsopt
->wsize
);
470 if (fsopt
->rsize
!= CEPH_RSIZE_DEFAULT
)
471 seq_printf(m
, ",rsize=%d", fsopt
->rsize
);
472 if (fsopt
->rasize
!= CEPH_RASIZE_DEFAULT
)
473 seq_printf(m
, ",rasize=%d", fsopt
->rasize
);
474 if (fsopt
->congestion_kb
!= default_congestion_kb())
475 seq_printf(m
, ",write_congestion_kb=%d", fsopt
->congestion_kb
);
476 if (fsopt
->caps_wanted_delay_min
!= CEPH_CAPS_WANTED_DELAY_MIN_DEFAULT
)
477 seq_printf(m
, ",caps_wanted_delay_min=%d",
478 fsopt
->caps_wanted_delay_min
);
479 if (fsopt
->caps_wanted_delay_max
!= CEPH_CAPS_WANTED_DELAY_MAX_DEFAULT
)
480 seq_printf(m
, ",caps_wanted_delay_max=%d",
481 fsopt
->caps_wanted_delay_max
);
482 if (fsopt
->cap_release_safety
!= CEPH_CAP_RELEASE_SAFETY_DEFAULT
)
483 seq_printf(m
, ",cap_release_safety=%d",
484 fsopt
->cap_release_safety
);
485 if (fsopt
->max_readdir
!= CEPH_MAX_READDIR_DEFAULT
)
486 seq_printf(m
, ",readdir_max_entries=%d", fsopt
->max_readdir
);
487 if (fsopt
->max_readdir_bytes
!= CEPH_MAX_READDIR_BYTES_DEFAULT
)
488 seq_printf(m
, ",readdir_max_bytes=%d", fsopt
->max_readdir_bytes
);
489 if (strcmp(fsopt
->snapdir_name
, CEPH_SNAPDIRNAME_DEFAULT
))
490 seq_show_option(m
, "snapdirname", fsopt
->snapdir_name
);
496 * handle any mon messages the standard library doesn't understand.
497 * return error if we don't either.
499 static int extra_mon_dispatch(struct ceph_client
*client
, struct ceph_msg
*msg
)
501 struct ceph_fs_client
*fsc
= client
->private;
502 int type
= le16_to_cpu(msg
->hdr
.type
);
505 case CEPH_MSG_MDS_MAP
:
506 ceph_mdsc_handle_map(fsc
->mdsc
, msg
);
515 * create a new fs client
517 static struct ceph_fs_client
*create_fs_client(struct ceph_mount_options
*fsopt
,
518 struct ceph_options
*opt
)
520 struct ceph_fs_client
*fsc
;
521 const u64 supported_features
=
522 CEPH_FEATURE_FLOCK
| CEPH_FEATURE_DIRLAYOUTHASH
|
523 CEPH_FEATURE_MDSENC
| CEPH_FEATURE_MDS_INLINE_DATA
;
524 const u64 required_features
= 0;
529 fsc
= kzalloc(sizeof(*fsc
), GFP_KERNEL
);
531 return ERR_PTR(-ENOMEM
);
533 fsc
->client
= ceph_create_client(opt
, fsc
, supported_features
,
535 if (IS_ERR(fsc
->client
)) {
536 err
= PTR_ERR(fsc
->client
);
539 fsc
->client
->extra_mon_dispatch
= extra_mon_dispatch
;
540 fsc
->client
->monc
.fs_cluster_id
= fsopt
->mds_namespace
;
541 ceph_monc_want_map(&fsc
->client
->monc
, CEPH_SUB_MDSMAP
, 0, true);
543 fsc
->mount_options
= fsopt
;
546 fsc
->mount_state
= CEPH_MOUNT_MOUNTING
;
548 atomic_long_set(&fsc
->writeback_count
, 0);
550 err
= bdi_init(&fsc
->backing_dev_info
);
556 * The number of concurrent works can be high but they don't need
557 * to be processed in parallel, limit concurrency.
559 fsc
->wb_wq
= alloc_workqueue("ceph-writeback", 0, 1);
560 if (fsc
->wb_wq
== NULL
)
562 fsc
->pg_inv_wq
= alloc_workqueue("ceph-pg-invalid", 0, 1);
563 if (fsc
->pg_inv_wq
== NULL
)
565 fsc
->trunc_wq
= alloc_workqueue("ceph-trunc", 0, 1);
566 if (fsc
->trunc_wq
== NULL
)
569 /* set up mempools */
571 page_count
= fsc
->mount_options
->wsize
>> PAGE_SHIFT
;
572 size
= sizeof (struct page
*) * (page_count
? page_count
: 1);
573 fsc
->wb_pagevec_pool
= mempool_create_kmalloc_pool(10, size
);
574 if (!fsc
->wb_pagevec_pool
)
578 if ((fsopt
->flags
& CEPH_MOUNT_OPT_FSCACHE
) &&
579 (ceph_fscache_register_fs(fsc
) != 0))
583 fsc
->min_caps
= fsopt
->max_readdir
;
588 ceph_fscache_unregister_fs(fsc
);
590 destroy_workqueue(fsc
->trunc_wq
);
592 destroy_workqueue(fsc
->pg_inv_wq
);
594 destroy_workqueue(fsc
->wb_wq
);
596 bdi_destroy(&fsc
->backing_dev_info
);
598 ceph_destroy_client(fsc
->client
);
604 static void destroy_fs_client(struct ceph_fs_client
*fsc
)
606 dout("destroy_fs_client %p\n", fsc
);
608 ceph_fscache_unregister_fs(fsc
);
610 destroy_workqueue(fsc
->wb_wq
);
611 destroy_workqueue(fsc
->pg_inv_wq
);
612 destroy_workqueue(fsc
->trunc_wq
);
614 bdi_destroy(&fsc
->backing_dev_info
);
616 mempool_destroy(fsc
->wb_pagevec_pool
);
618 destroy_mount_options(fsc
->mount_options
);
620 ceph_fs_debugfs_cleanup(fsc
);
622 ceph_destroy_client(fsc
->client
);
625 dout("destroy_fs_client %p done\n", fsc
);
631 struct kmem_cache
*ceph_inode_cachep
;
632 struct kmem_cache
*ceph_cap_cachep
;
633 struct kmem_cache
*ceph_cap_flush_cachep
;
634 struct kmem_cache
*ceph_dentry_cachep
;
635 struct kmem_cache
*ceph_file_cachep
;
637 static void ceph_inode_init_once(void *foo
)
639 struct ceph_inode_info
*ci
= foo
;
640 inode_init_once(&ci
->vfs_inode
);
643 static int __init
init_caches(void)
647 ceph_inode_cachep
= kmem_cache_create("ceph_inode_info",
648 sizeof(struct ceph_inode_info
),
649 __alignof__(struct ceph_inode_info
),
650 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
|
651 SLAB_ACCOUNT
, ceph_inode_init_once
);
652 if (ceph_inode_cachep
== NULL
)
655 ceph_cap_cachep
= KMEM_CACHE(ceph_cap
,
656 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
657 if (ceph_cap_cachep
== NULL
)
659 ceph_cap_flush_cachep
= KMEM_CACHE(ceph_cap_flush
,
660 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
661 if (ceph_cap_flush_cachep
== NULL
)
664 ceph_dentry_cachep
= KMEM_CACHE(ceph_dentry_info
,
665 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
666 if (ceph_dentry_cachep
== NULL
)
669 ceph_file_cachep
= KMEM_CACHE(ceph_file_info
,
670 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
);
671 if (ceph_file_cachep
== NULL
)
674 if ((error
= ceph_fscache_register()))
679 kmem_cache_destroy(ceph_dentry_cachep
);
681 kmem_cache_destroy(ceph_cap_flush_cachep
);
683 kmem_cache_destroy(ceph_cap_cachep
);
685 kmem_cache_destroy(ceph_inode_cachep
);
689 static void destroy_caches(void)
692 * Make sure all delayed rcu free inodes are flushed before we
697 kmem_cache_destroy(ceph_inode_cachep
);
698 kmem_cache_destroy(ceph_cap_cachep
);
699 kmem_cache_destroy(ceph_cap_flush_cachep
);
700 kmem_cache_destroy(ceph_dentry_cachep
);
701 kmem_cache_destroy(ceph_file_cachep
);
703 ceph_fscache_unregister();
708 * ceph_umount_begin - initiate forced umount. Tear down down the
709 * mount, skipping steps that may hang while waiting for server(s).
711 static void ceph_umount_begin(struct super_block
*sb
)
713 struct ceph_fs_client
*fsc
= ceph_sb_to_client(sb
);
715 dout("ceph_umount_begin - starting forced umount\n");
718 fsc
->mount_state
= CEPH_MOUNT_SHUTDOWN
;
719 ceph_mdsc_force_umount(fsc
->mdsc
);
723 static const struct super_operations ceph_super_ops
= {
724 .alloc_inode
= ceph_alloc_inode
,
725 .destroy_inode
= ceph_destroy_inode
,
726 .write_inode
= ceph_write_inode
,
727 .drop_inode
= ceph_drop_inode
,
728 .sync_fs
= ceph_sync_fs
,
729 .put_super
= ceph_put_super
,
730 .show_options
= ceph_show_options
,
731 .statfs
= ceph_statfs
,
732 .umount_begin
= ceph_umount_begin
,
736 * Bootstrap mount by opening the root directory. Note the mount
737 * @started time from caller, and time out if this takes too long.
739 static struct dentry
*open_root_dentry(struct ceph_fs_client
*fsc
,
741 unsigned long started
)
743 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
744 struct ceph_mds_request
*req
= NULL
;
749 dout("open_root_inode opening '%s'\n", path
);
750 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_GETATTR
, USE_ANY_MDS
);
752 return ERR_CAST(req
);
753 req
->r_path1
= kstrdup(path
, GFP_NOFS
);
755 root
= ERR_PTR(-ENOMEM
);
759 req
->r_ino1
.ino
= CEPH_INO_ROOT
;
760 req
->r_ino1
.snap
= CEPH_NOSNAP
;
761 req
->r_started
= started
;
762 req
->r_timeout
= fsc
->client
->options
->mount_timeout
;
763 req
->r_args
.getattr
.mask
= cpu_to_le32(CEPH_STAT_CAP_INODE
);
765 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
767 struct inode
*inode
= req
->r_target_inode
;
768 req
->r_target_inode
= NULL
;
769 dout("open_root_inode success\n");
770 if (ceph_ino(inode
) == CEPH_INO_ROOT
&&
771 fsc
->sb
->s_root
== NULL
) {
772 root
= d_make_root(inode
);
774 root
= ERR_PTR(-ENOMEM
);
778 root
= d_obtain_root(inode
);
780 ceph_init_dentry(root
);
781 dout("open_root_inode success, root dentry is %p\n", root
);
786 ceph_mdsc_put_request(req
);
794 * mount: join the ceph cluster, and open root directory.
796 static struct dentry
*ceph_real_mount(struct ceph_fs_client
*fsc
,
800 unsigned long started
= jiffies
; /* note the start time */
802 int first
= 0; /* first vfsmount for this super_block */
804 dout("mount start %p\n", fsc
);
805 mutex_lock(&fsc
->client
->mount_mutex
);
807 if (!fsc
->sb
->s_root
) {
808 err
= __ceph_open_session(fsc
->client
, started
);
812 dout("mount opening root\n");
813 root
= open_root_dentry(fsc
, "", started
);
818 fsc
->sb
->s_root
= root
;
821 err
= ceph_fs_debugfs_init(fsc
);
827 root
= fsc
->sb
->s_root
;
830 dout("mount opening base mountpoint\n");
831 root
= open_root_dentry(fsc
, path
, started
);
838 fsc
->mount_state
= CEPH_MOUNT_MOUNTED
;
839 dout("mount success\n");
840 mutex_unlock(&fsc
->client
->mount_mutex
);
845 dput(fsc
->sb
->s_root
);
846 fsc
->sb
->s_root
= NULL
;
849 mutex_unlock(&fsc
->client
->mount_mutex
);
853 static int ceph_set_super(struct super_block
*s
, void *data
)
855 struct ceph_fs_client
*fsc
= data
;
858 dout("set_super %p data %p\n", s
, data
);
860 s
->s_flags
= fsc
->mount_options
->sb_flags
;
861 s
->s_maxbytes
= 1ULL << 40; /* temp value until we get mdsmap */
863 s
->s_xattr
= ceph_xattr_handlers
;
867 s
->s_op
= &ceph_super_ops
;
868 s
->s_export_op
= &ceph_export_ops
;
870 s
->s_time_gran
= 1000; /* 1000 ns == 1 us */
872 ret
= set_anon_super(s
, NULL
); /* what is that second arg for? */
885 * share superblock if same fs AND options
887 static int ceph_compare_super(struct super_block
*sb
, void *data
)
889 struct ceph_fs_client
*new = data
;
890 struct ceph_mount_options
*fsopt
= new->mount_options
;
891 struct ceph_options
*opt
= new->client
->options
;
892 struct ceph_fs_client
*other
= ceph_sb_to_client(sb
);
894 dout("ceph_compare_super %p\n", sb
);
896 if (compare_mount_options(fsopt
, opt
, other
)) {
897 dout("monitor(s)/mount options don't match\n");
900 if ((opt
->flags
& CEPH_OPT_FSID
) &&
901 ceph_fsid_compare(&opt
->fsid
, &other
->client
->fsid
)) {
902 dout("fsid doesn't match\n");
905 if (fsopt
->sb_flags
!= other
->mount_options
->sb_flags
) {
906 dout("flags differ\n");
913 * construct our own bdi so we can control readahead, etc.
915 static atomic_long_t bdi_seq
= ATOMIC_LONG_INIT(0);
917 static int ceph_register_bdi(struct super_block
*sb
,
918 struct ceph_fs_client
*fsc
)
922 /* set ra_pages based on rasize mount option? */
923 if (fsc
->mount_options
->rasize
>= PAGE_SIZE
)
924 fsc
->backing_dev_info
.ra_pages
=
925 (fsc
->mount_options
->rasize
+ PAGE_SIZE
- 1)
928 fsc
->backing_dev_info
.ra_pages
=
929 VM_MAX_READAHEAD
* 1024 / PAGE_SIZE
;
931 err
= bdi_register(&fsc
->backing_dev_info
, NULL
, "ceph-%ld",
932 atomic_long_inc_return(&bdi_seq
));
934 sb
->s_bdi
= &fsc
->backing_dev_info
;
938 static struct dentry
*ceph_mount(struct file_system_type
*fs_type
,
939 int flags
, const char *dev_name
, void *data
)
941 struct super_block
*sb
;
942 struct ceph_fs_client
*fsc
;
945 int (*compare_super
)(struct super_block
*, void *) = ceph_compare_super
;
946 const char *path
= NULL
;
947 struct ceph_mount_options
*fsopt
= NULL
;
948 struct ceph_options
*opt
= NULL
;
950 dout("ceph_mount\n");
952 #ifdef CONFIG_CEPH_FS_POSIX_ACL
953 flags
|= MS_POSIXACL
;
955 err
= parse_mount_options(&fsopt
, &opt
, flags
, data
, dev_name
, &path
);
961 /* create client (which we may/may not use) */
962 fsc
= create_fs_client(fsopt
, opt
);
965 destroy_mount_options(fsopt
);
966 ceph_destroy_options(opt
);
970 err
= ceph_mdsc_init(fsc
);
976 if (ceph_test_opt(fsc
->client
, NOSHARE
))
977 compare_super
= NULL
;
978 sb
= sget(fs_type
, compare_super
, ceph_set_super
, flags
, fsc
);
984 if (ceph_sb_to_client(sb
) != fsc
) {
985 ceph_mdsc_destroy(fsc
);
986 destroy_fs_client(fsc
);
987 fsc
= ceph_sb_to_client(sb
);
988 dout("get_sb got existing client %p\n", fsc
);
990 dout("get_sb using new client %p\n", fsc
);
991 err
= ceph_register_bdi(sb
, fsc
);
998 res
= ceph_real_mount(fsc
, path
);
1001 dout("root %p inode %p ino %llx.%llx\n", res
,
1002 d_inode(res
), ceph_vinop(d_inode(res
)));
1006 ceph_mdsc_close_sessions(fsc
->mdsc
);
1007 deactivate_locked_super(sb
);
1011 ceph_mdsc_destroy(fsc
);
1012 destroy_fs_client(fsc
);
1014 dout("ceph_mount fail %ld\n", PTR_ERR(res
));
1018 static void ceph_kill_sb(struct super_block
*s
)
1020 struct ceph_fs_client
*fsc
= ceph_sb_to_client(s
);
1021 dev_t dev
= s
->s_dev
;
1023 dout("kill_sb %p\n", s
);
1025 ceph_mdsc_pre_umount(fsc
->mdsc
);
1026 generic_shutdown_super(s
);
1027 ceph_mdsc_destroy(fsc
);
1029 destroy_fs_client(fsc
);
1030 free_anon_bdev(dev
);
1033 static struct file_system_type ceph_fs_type
= {
1034 .owner
= THIS_MODULE
,
1036 .mount
= ceph_mount
,
1037 .kill_sb
= ceph_kill_sb
,
1038 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
1040 MODULE_ALIAS_FS("ceph");
1042 static int __init
init_ceph(void)
1044 int ret
= init_caches();
1050 ret
= register_filesystem(&ceph_fs_type
);
1054 pr_info("loaded (mds proto %d)\n", CEPH_MDSC_PROTOCOL
);
1065 static void __exit
exit_ceph(void)
1067 dout("exit_ceph\n");
1068 unregister_filesystem(&ceph_fs_type
);
1073 module_init(init_ceph
);
1074 module_exit(exit_ceph
);
1076 MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
1077 MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
1078 MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
1079 MODULE_DESCRIPTION("Ceph filesystem for Linux");
1080 MODULE_LICENSE("GPL");