2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/blkdev.h>
16 #include <linux/kthread.h>
17 #include <linux/namei.h>
18 #include <linux/mount.h>
19 #include <linux/gfs2_ondisk.h>
20 #include <linux/lm_interface.h>
30 #include "ops_fstype.h"
31 #include "ops_dentry.h"
32 #include "ops_super.h"
42 static struct gfs2_sbd
*init_sbd(struct super_block
*sb
)
46 sdp
= kzalloc(sizeof(struct gfs2_sbd
), GFP_KERNEL
);
53 gfs2_tune_init(&sdp
->sd_tune
);
55 INIT_LIST_HEAD(&sdp
->sd_reclaim_list
);
56 spin_lock_init(&sdp
->sd_reclaim_lock
);
57 init_waitqueue_head(&sdp
->sd_reclaim_wq
);
59 mutex_init(&sdp
->sd_inum_mutex
);
60 spin_lock_init(&sdp
->sd_statfs_spin
);
61 mutex_init(&sdp
->sd_statfs_mutex
);
63 spin_lock_init(&sdp
->sd_rindex_spin
);
64 mutex_init(&sdp
->sd_rindex_mutex
);
65 INIT_LIST_HEAD(&sdp
->sd_rindex_list
);
66 INIT_LIST_HEAD(&sdp
->sd_rindex_mru_list
);
67 INIT_LIST_HEAD(&sdp
->sd_rindex_recent_list
);
69 INIT_LIST_HEAD(&sdp
->sd_jindex_list
);
70 spin_lock_init(&sdp
->sd_jindex_spin
);
71 mutex_init(&sdp
->sd_jindex_mutex
);
73 INIT_LIST_HEAD(&sdp
->sd_quota_list
);
74 spin_lock_init(&sdp
->sd_quota_spin
);
75 mutex_init(&sdp
->sd_quota_mutex
);
77 spin_lock_init(&sdp
->sd_log_lock
);
79 INIT_LIST_HEAD(&sdp
->sd_log_le_gl
);
80 INIT_LIST_HEAD(&sdp
->sd_log_le_buf
);
81 INIT_LIST_HEAD(&sdp
->sd_log_le_revoke
);
82 INIT_LIST_HEAD(&sdp
->sd_log_le_rg
);
83 INIT_LIST_HEAD(&sdp
->sd_log_le_databuf
);
85 mutex_init(&sdp
->sd_log_reserve_mutex
);
86 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
87 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
89 init_rwsem(&sdp
->sd_log_flush_lock
);
90 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
92 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
94 mutex_init(&sdp
->sd_freeze_lock
);
99 static void init_vfs(struct super_block
*sb
, unsigned noatime
)
101 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
103 sb
->s_magic
= GFS2_MAGIC
;
104 sb
->s_op
= &gfs2_super_ops
;
105 sb
->s_export_op
= &gfs2_export_ops
;
107 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
109 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
110 set_bit(noatime
, &sdp
->sd_flags
);
112 /* Don't let the VFS update atimes. GFS2 handles this itself. */
113 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
116 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
121 proto
= sdp
->sd_args
.ar_lockproto
;
122 table
= sdp
->sd_args
.ar_locktable
;
124 /* Try to autodetect */
126 if (!proto
[0] || !table
[0]) {
127 error
= gfs2_read_super(sdp
, GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
131 error
= gfs2_check_sb(sdp
, &sdp
->sd_sb
, silent
);
136 proto
= sdp
->sd_sb
.sb_lockproto
;
138 table
= sdp
->sd_sb
.sb_locktable
;
142 table
= sdp
->sd_vfs
->s_id
;
144 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
145 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
147 while ((table
= strchr(sdp
->sd_table_name
, '/')))
154 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
157 struct task_struct
*p
;
163 for (sdp
->sd_glockd_num
= 0;
164 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
165 sdp
->sd_glockd_num
++) {
166 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
169 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
172 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
175 error
= gfs2_glock_nq_num(sdp
,
176 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
177 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
180 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
184 error
= gfs2_glock_nq_num(sdp
,
185 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
187 LM_FLAG_NOEXP
| GL_EXACT
,
190 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
194 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
195 CREATE
, &sdp
->sd_rename_gl
);
197 fs_err(sdp
, "can't create rename glock: %d\n", error
);
201 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
202 CREATE
, &sdp
->sd_trans_gl
);
204 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
207 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
212 gfs2_glock_put(sdp
->sd_trans_gl
);
214 gfs2_glock_put(sdp
->sd_rename_gl
);
216 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
218 gfs2_glock_dq_uninit(mount_gh
);
220 while (sdp
->sd_glockd_num
--)
221 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
226 static inline struct inode
*gfs2_lookup_root(struct super_block
*sb
,
229 return gfs2_inode_lookup(sb
, DT_DIR
, no_addr
, 0);
232 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
234 struct super_block
*sb
= sdp
->sd_vfs
;
235 struct gfs2_holder sb_gh
;
248 error
= gfs2_glock_nq_num(sdp
, GFS2_SB_LOCK
, &gfs2_meta_glops
,
249 LM_ST_SHARED
, 0, &sb_gh
);
251 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
255 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
257 fs_err(sdp
, "can't read superblock: %d\n", error
);
261 /* Set up the buffer cache and SB for real */
262 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
264 fs_err(sdp
, "FS block size (%u) is too small for device "
266 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
269 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
271 fs_err(sdp
, "FS block size (%u) is too big for machine "
273 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
276 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
278 /* Get the root inode */
279 no_addr
= sdp
->sd_sb
.sb_root_dir
.no_addr
;
280 if (sb
->s_type
== &gfs2meta_fs_type
)
281 no_addr
= sdp
->sd_sb
.sb_master_dir
.no_addr
;
282 inode
= gfs2_lookup_root(sb
, no_addr
);
284 error
= PTR_ERR(inode
);
285 fs_err(sdp
, "can't read in root inode: %d\n", error
);
289 sb
->s_root
= d_alloc_root(inode
);
291 fs_err(sdp
, "can't get root dentry\n");
295 sb
->s_root
->d_op
= &gfs2_dops
;
297 gfs2_glock_dq_uninit(&sb_gh
);
301 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
303 struct gfs2_holder ji_gh
;
304 struct task_struct
*p
;
305 struct gfs2_inode
*ip
;
314 sdp
->sd_jindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex");
315 if (IS_ERR(sdp
->sd_jindex
)) {
316 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
317 return PTR_ERR(sdp
->sd_jindex
);
319 ip
= GFS2_I(sdp
->sd_jindex
);
320 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
322 /* Load in the journal index special file */
324 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
326 fs_err(sdp
, "can't read journal index: %d\n", error
);
331 if (!gfs2_jindex_size(sdp
)) {
332 fs_err(sdp
, "no journals!\n");
336 if (sdp
->sd_args
.ar_spectator
) {
337 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
338 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
340 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
341 fs_err(sdp
, "can't mount journal #%u\n",
342 sdp
->sd_lockstruct
.ls_jid
);
343 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
344 gfs2_jindex_size(sdp
),
345 gfs2_jindex_size(sdp
) - 1);
348 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
350 error
= gfs2_glock_nq_num(sdp
, sdp
->sd_lockstruct
.ls_jid
,
352 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
353 &sdp
->sd_journal_gh
);
355 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
359 ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
360 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
361 LM_FLAG_NOEXP
| GL_EXACT
| GL_NOCACHE
,
364 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
366 goto fail_journal_gh
;
369 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
371 fs_err(sdp
, "my journal (%u) is bad: %d\n",
372 sdp
->sd_jdesc
->jd_jid
, error
);
375 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
378 if (sdp
->sd_lockstruct
.ls_first
) {
380 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
381 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
));
383 fs_err(sdp
, "error recovering journal %u: %d\n",
389 gfs2_lm_others_may_mount(sdp
);
390 } else if (!sdp
->sd_args
.ar_spectator
) {
391 error
= gfs2_recover_journal(sdp
->sd_jdesc
);
393 fs_err(sdp
, "error recovering my journal: %d\n", error
);
398 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
399 gfs2_glock_dq_uninit(&ji_gh
);
402 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
405 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
408 sdp
->sd_recoverd_process
= p
;
413 kthread_stop(sdp
->sd_recoverd_process
);
415 if (!sdp
->sd_args
.ar_spectator
)
416 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
418 if (!sdp
->sd_args
.ar_spectator
)
419 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
421 gfs2_jindex_free(sdp
);
423 gfs2_glock_dq_uninit(&ji_gh
);
425 iput(sdp
->sd_jindex
);
430 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
433 struct gfs2_inode
*ip
;
439 inode
= gfs2_lookup_root(sdp
->sd_vfs
, sdp
->sd_sb
.sb_master_dir
.no_addr
);
441 error
= PTR_ERR(inode
);
442 fs_err(sdp
, "can't read in master directory: %d\n", error
);
445 sdp
->sd_master_dir
= inode
;
447 error
= init_journal(sdp
, undo
);
451 /* Read in the master inode number inode */
452 sdp
->sd_inum_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum");
453 if (IS_ERR(sdp
->sd_inum_inode
)) {
454 error
= PTR_ERR(sdp
->sd_inum_inode
);
455 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
460 /* Read in the master statfs inode */
461 sdp
->sd_statfs_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs");
462 if (IS_ERR(sdp
->sd_statfs_inode
)) {
463 error
= PTR_ERR(sdp
->sd_statfs_inode
);
464 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
468 /* Read in the resource index inode */
469 sdp
->sd_rindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex");
470 if (IS_ERR(sdp
->sd_rindex
)) {
471 error
= PTR_ERR(sdp
->sd_rindex
);
472 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
475 ip
= GFS2_I(sdp
->sd_rindex
);
476 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
477 sdp
->sd_rindex_vn
= ip
->i_gl
->gl_vn
- 1;
479 /* Read in the quota inode */
480 sdp
->sd_quota_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota");
481 if (IS_ERR(sdp
->sd_quota_inode
)) {
482 error
= PTR_ERR(sdp
->sd_quota_inode
);
483 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
489 iput(sdp
->sd_quota_inode
);
491 gfs2_clear_rgrpd(sdp
);
492 iput(sdp
->sd_rindex
);
494 iput(sdp
->sd_statfs_inode
);
496 iput(sdp
->sd_inum_inode
);
498 init_journal(sdp
, UNDO
);
500 iput(sdp
->sd_master_dir
);
505 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
507 struct inode
*pn
= NULL
;
510 struct gfs2_inode
*ip
;
512 if (sdp
->sd_args
.ar_spectator
)
518 pn
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node");
521 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
525 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
526 sdp
->sd_ir_inode
= gfs2_lookup_simple(pn
, buf
);
527 if (IS_ERR(sdp
->sd_ir_inode
)) {
528 error
= PTR_ERR(sdp
->sd_ir_inode
);
529 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
533 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
534 sdp
->sd_sc_inode
= gfs2_lookup_simple(pn
, buf
);
535 if (IS_ERR(sdp
->sd_sc_inode
)) {
536 error
= PTR_ERR(sdp
->sd_sc_inode
);
537 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
541 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
542 sdp
->sd_qc_inode
= gfs2_lookup_simple(pn
, buf
);
543 if (IS_ERR(sdp
->sd_qc_inode
)) {
544 error
= PTR_ERR(sdp
->sd_qc_inode
);
545 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
552 ip
= GFS2_I(sdp
->sd_ir_inode
);
553 error
= gfs2_glock_nq_init(ip
->i_gl
,
557 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
561 ip
= GFS2_I(sdp
->sd_sc_inode
);
562 error
= gfs2_glock_nq_init(ip
->i_gl
,
566 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
570 ip
= GFS2_I(sdp
->sd_qc_inode
);
571 error
= gfs2_glock_nq_init(ip
->i_gl
,
575 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
582 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
584 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
586 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
588 iput(sdp
->sd_qc_inode
);
590 iput(sdp
->sd_sc_inode
);
592 iput(sdp
->sd_ir_inode
);
599 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
601 struct task_struct
*p
;
607 sdp
->sd_log_flush_time
= jiffies
;
608 sdp
->sd_jindex_refresh_time
= jiffies
;
610 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
613 fs_err(sdp
, "can't start logd thread: %d\n", error
);
616 sdp
->sd_logd_process
= p
;
618 sdp
->sd_statfs_sync_time
= jiffies
;
619 sdp
->sd_quota_sync_time
= jiffies
;
621 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
624 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
627 sdp
->sd_quotad_process
= p
;
633 kthread_stop(sdp
->sd_quotad_process
);
635 kthread_stop(sdp
->sd_logd_process
);
640 * fill_super - Read in superblock
641 * @sb: The VFS superblock
642 * @data: Mount options
643 * @silent: Don't complain if it's not a GFS2 filesystem
648 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
650 struct gfs2_sbd
*sdp
;
651 struct gfs2_holder mount_gh
;
656 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
660 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
662 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
666 init_vfs(sb
, SDF_NOATIME
);
668 /* Set up the buffer cache and fill in some fake block size values
669 to allow us to read-in the on-disk superblock. */
670 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
671 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
672 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
673 GFS2_BASIC_BLOCK_SHIFT
;
674 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
676 error
= init_names(sdp
, silent
);
680 gfs2_create_debugfs_file(sdp
);
682 error
= gfs2_sys_fs_add(sdp
);
686 error
= gfs2_lm_mount(sdp
, silent
);
690 error
= init_locking(sdp
, &mount_gh
, DO
);
694 error
= init_sb(sdp
, silent
, DO
);
698 error
= init_inodes(sdp
, DO
);
702 error
= init_per_node(sdp
, DO
);
706 error
= gfs2_statfs_init(sdp
);
708 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
712 error
= init_threads(sdp
, DO
);
716 if (!(sb
->s_flags
& MS_RDONLY
)) {
717 error
= gfs2_make_fs_rw(sdp
);
719 fs_err(sdp
, "can't make FS RW: %d\n", error
);
724 gfs2_glock_dq_uninit(&mount_gh
);
729 init_threads(sdp
, UNDO
);
731 init_per_node(sdp
, UNDO
);
733 init_inodes(sdp
, UNDO
);
735 init_sb(sdp
, 0, UNDO
);
737 init_locking(sdp
, &mount_gh
, UNDO
);
739 gfs2_gl_hash_clear(sdp
, WAIT
);
740 gfs2_lm_unmount(sdp
);
741 while (invalidate_inodes(sb
))
744 gfs2_sys_fs_del(sdp
);
746 gfs2_delete_debugfs_file(sdp
);
748 sb
->s_fs_info
= NULL
;
752 static int gfs2_get_sb(struct file_system_type
*fs_type
, int flags
,
753 const char *dev_name
, void *data
, struct vfsmount
*mnt
)
755 struct super_block
*sb
;
756 struct gfs2_sbd
*sdp
;
757 int error
= get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
, mnt
);
762 sdp
->sd_gfs2mnt
= mnt
;
767 static int fill_super_meta(struct super_block
*sb
, struct super_block
*new,
768 void *data
, int silent
)
770 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
774 new->s_fs_info
= sdp
;
775 sdp
->sd_vfs_meta
= sb
;
777 init_vfs(new, SDF_NOATIME
);
779 /* Get the master inode */
780 inode
= igrab(sdp
->sd_master_dir
);
782 new->s_root
= d_alloc_root(inode
);
784 fs_err(sdp
, "can't get root dentry\n");
788 new->s_root
->d_op
= &gfs2_dops
;
793 static int set_bdev_super(struct super_block
*s
, void *data
)
796 s
->s_dev
= s
->s_bdev
->bd_dev
;
800 static int test_bdev_super(struct super_block
*s
, void *data
)
802 return s
->s_bdev
== data
;
805 static struct super_block
* get_gfs2_sb(const char *dev_name
)
809 struct file_system_type
*fstype
;
810 struct super_block
*sb
= NULL
, *s
;
814 error
= path_lookup(dev_name
, LOOKUP_FOLLOW
, &nd
);
816 printk(KERN_WARNING
"GFS2: path_lookup on %s returned error\n",
820 error
= vfs_getattr(nd
.mnt
, nd
.dentry
, &stat
);
822 fstype
= get_fs_type("gfs2");
823 list_for_each(l
, &fstype
->fs_supers
) {
824 s
= list_entry(l
, struct super_block
, s_instances
);
825 if ((S_ISBLK(stat
.mode
) && s
->s_dev
== stat
.rdev
) ||
826 (S_ISDIR(stat
.mode
) && s
== nd
.dentry
->d_inode
->i_sb
)) {
832 printk(KERN_WARNING
"GFS2: Unrecognized block device or "
833 "mount point %s\n", dev_name
);
841 static int gfs2_get_sb_meta(struct file_system_type
*fs_type
, int flags
,
842 const char *dev_name
, void *data
, struct vfsmount
*mnt
)
845 struct super_block
*sb
= NULL
, *new;
846 struct gfs2_sbd
*sdp
;
848 sb
= get_gfs2_sb(dev_name
);
850 printk(KERN_WARNING
"GFS2: gfs2 mount does not exist\n");
854 sdp
= (struct gfs2_sbd
*) sb
->s_fs_info
;
855 if (sdp
->sd_vfs_meta
) {
856 printk(KERN_WARNING
"GFS2: gfs2meta mount already exists\n");
860 down(&sb
->s_bdev
->bd_mount_sem
);
861 new = sget(fs_type
, test_bdev_super
, set_bdev_super
, sb
->s_bdev
);
862 up(&sb
->s_bdev
->bd_mount_sem
);
864 error
= PTR_ERR(new);
867 module_put(fs_type
->owner
);
868 new->s_flags
= flags
;
869 strlcpy(new->s_id
, sb
->s_id
, sizeof(new->s_id
));
870 sb_set_blocksize(new, sb
->s_blocksize
);
871 error
= fill_super_meta(sb
, new, data
, flags
& MS_SILENT
? 1 : 0);
873 up_write(&new->s_umount
);
874 deactivate_super(new);
878 new->s_flags
|= MS_ACTIVE
;
880 /* Grab a reference to the gfs2 mount point */
881 atomic_inc(&sdp
->sd_gfs2mnt
->mnt_count
);
882 return simple_set_mnt(mnt
, new);
887 static void gfs2_kill_sb(struct super_block
*sb
)
889 gfs2_delete_debugfs_file(sb
->s_fs_info
);
890 kill_block_super(sb
);
893 static void gfs2_kill_sb_meta(struct super_block
*sb
)
895 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
896 generic_shutdown_super(sb
);
897 sdp
->sd_vfs_meta
= NULL
;
898 atomic_dec(&sdp
->sd_gfs2mnt
->mnt_count
);
901 struct file_system_type gfs2_fs_type
= {
903 .fs_flags
= FS_REQUIRES_DEV
,
904 .get_sb
= gfs2_get_sb
,
905 .kill_sb
= gfs2_kill_sb
,
906 .owner
= THIS_MODULE
,
909 struct file_system_type gfs2meta_fs_type
= {
911 .fs_flags
= FS_REQUIRES_DEV
,
912 .get_sb
= gfs2_get_sb_meta
,
913 .kill_sb
= gfs2_kill_sb_meta
,
914 .owner
= THIS_MODULE
,