2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2005 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 v.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/vmalloc.h>
16 #include <linux/blkdev.h>
17 #include <linux/kthread.h>
18 #include <linux/gfs2_ondisk.h>
19 #include <asm/semaphore.h>
22 #include "lm_interface.h"
30 #include "ops_export.h"
31 #include "ops_fstype.h"
32 #include "ops_super.h"
43 static struct gfs2_sbd
*init_sbd(struct super_block
*sb
)
48 sdp
= vmalloc(sizeof(struct gfs2_sbd
));
52 memset(sdp
, 0, sizeof(struct gfs2_sbd
));
57 gfs2_tune_init(&sdp
->sd_tune
);
59 for (x
= 0; x
< GFS2_GL_HASH_SIZE
; x
++) {
60 sdp
->sd_gl_hash
[x
].hb_lock
= RW_LOCK_UNLOCKED
;
61 INIT_LIST_HEAD(&sdp
->sd_gl_hash
[x
].hb_list
);
63 INIT_LIST_HEAD(&sdp
->sd_reclaim_list
);
64 spin_lock_init(&sdp
->sd_reclaim_lock
);
65 init_waitqueue_head(&sdp
->sd_reclaim_wq
);
66 mutex_init(&sdp
->sd_invalidate_inodes_mutex
);
68 mutex_init(&sdp
->sd_inum_mutex
);
69 spin_lock_init(&sdp
->sd_statfs_spin
);
70 mutex_init(&sdp
->sd_statfs_mutex
);
72 spin_lock_init(&sdp
->sd_rindex_spin
);
73 mutex_init(&sdp
->sd_rindex_mutex
);
74 INIT_LIST_HEAD(&sdp
->sd_rindex_list
);
75 INIT_LIST_HEAD(&sdp
->sd_rindex_mru_list
);
76 INIT_LIST_HEAD(&sdp
->sd_rindex_recent_list
);
78 INIT_LIST_HEAD(&sdp
->sd_jindex_list
);
79 spin_lock_init(&sdp
->sd_jindex_spin
);
80 mutex_init(&sdp
->sd_jindex_mutex
);
82 INIT_LIST_HEAD(&sdp
->sd_unlinked_list
);
83 spin_lock_init(&sdp
->sd_unlinked_spin
);
84 mutex_init(&sdp
->sd_unlinked_mutex
);
86 INIT_LIST_HEAD(&sdp
->sd_quota_list
);
87 spin_lock_init(&sdp
->sd_quota_spin
);
88 mutex_init(&sdp
->sd_quota_mutex
);
90 spin_lock_init(&sdp
->sd_log_lock
);
92 INIT_LIST_HEAD(&sdp
->sd_log_le_gl
);
93 INIT_LIST_HEAD(&sdp
->sd_log_le_buf
);
94 INIT_LIST_HEAD(&sdp
->sd_log_le_revoke
);
95 INIT_LIST_HEAD(&sdp
->sd_log_le_rg
);
96 INIT_LIST_HEAD(&sdp
->sd_log_le_databuf
);
98 mutex_init(&sdp
->sd_log_reserve_mutex
);
99 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
100 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
102 init_rwsem(&sdp
->sd_log_flush_lock
);
103 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
105 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
107 mutex_init(&sdp
->sd_freeze_lock
);
112 static void init_vfs(struct super_block
*sb
, unsigned noatime
)
114 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
116 sb
->s_magic
= GFS2_MAGIC
;
117 sb
->s_op
= &gfs2_super_ops
;
118 sb
->s_export_op
= &gfs2_export_ops
;
119 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
121 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
122 set_bit(noatime
, &sdp
->sd_flags
);
124 /* Don't let the VFS update atimes. GFS2 handles this itself. */
125 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
128 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
130 struct gfs2_sb
*sb
= NULL
;
134 proto
= sdp
->sd_args
.ar_lockproto
;
135 table
= sdp
->sd_args
.ar_locktable
;
137 /* Try to autodetect */
139 if (!proto
[0] || !table
[0]) {
140 struct buffer_head
*bh
;
141 bh
= sb_getblk(sdp
->sd_vfs
,
142 GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
144 clear_buffer_uptodate(bh
);
145 clear_buffer_dirty(bh
);
147 ll_rw_block(READ
, 1, &bh
);
150 if (!buffer_uptodate(bh
)) {
155 sb
= kmalloc(sizeof(struct gfs2_sb
), GFP_KERNEL
);
160 gfs2_sb_in(sb
, bh
->b_data
);
163 error
= gfs2_check_sb(sdp
, sb
, silent
);
168 proto
= sb
->sb_lockproto
;
170 table
= sb
->sb_locktable
;
174 table
= sdp
->sd_vfs
->s_id
;
176 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
177 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
185 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
188 struct task_struct
*p
;
194 p
= kthread_run(gfs2_scand
, sdp
, "gfs2_scand");
197 fs_err(sdp
, "can't start scand thread: %d\n", error
);
200 sdp
->sd_scand_process
= p
;
202 for (sdp
->sd_glockd_num
= 0;
203 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
204 sdp
->sd_glockd_num
++) {
205 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
208 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
211 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
214 error
= gfs2_glock_nq_num(sdp
,
215 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
216 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
219 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
223 error
= gfs2_glock_nq_num(sdp
,
224 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
226 LM_FLAG_NOEXP
| GL_EXACT
| GL_NEVER_RECURSE
,
229 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
233 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
234 CREATE
, &sdp
->sd_rename_gl
);
236 fs_err(sdp
, "can't create rename glock: %d\n", error
);
240 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
241 CREATE
, &sdp
->sd_trans_gl
);
243 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
246 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
251 gfs2_glock_put(sdp
->sd_trans_gl
);
254 gfs2_glock_put(sdp
->sd_rename_gl
);
257 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
260 gfs2_glock_dq_uninit(mount_gh
);
263 while (sdp
->sd_glockd_num
--)
264 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
266 kthread_stop(sdp
->sd_scand_process
);
271 static struct inode
*gfs2_lookup_root(struct gfs2_sbd
*sdp
,
272 const struct gfs2_inum
*inum
)
275 struct gfs2_glock
*gl
;
276 struct gfs2_inode
*ip
;
279 error
= gfs2_glock_get(sdp
, inum
->no_addr
, &gfs2_inode_glops
,
282 error
= gfs2_inode_get(gl
, inum
, CREATE
, &ip
);
284 gfs2_inode_min_init(ip
, DT_DIR
);
285 inode
= gfs2_ip2v(ip
);
292 return ERR_PTR(error
);
295 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
297 struct super_block
*sb
= sdp
->sd_vfs
;
298 struct gfs2_holder sb_gh
;
299 struct gfs2_inum
*inum
;
307 error
= gfs2_glock_nq_num(sdp
,
308 GFS2_SB_LOCK
, &gfs2_meta_glops
,
309 LM_ST_SHARED
, 0, &sb_gh
);
311 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
315 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
317 fs_err(sdp
, "can't read superblock: %d\n", error
);
321 /* Set up the buffer cache and SB for real */
322 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
324 fs_err(sdp
, "FS block size (%u) is too small for device "
326 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
329 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
331 fs_err(sdp
, "FS block size (%u) is too big for machine "
333 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
337 /* Get rid of buffers from the original block size */
338 sb_gh
.gh_gl
->gl_ops
->go_inval(sb_gh
.gh_gl
, DIO_METADATA
| DIO_DATA
);
339 sb_gh
.gh_gl
->gl_aspace
->i_blkbits
= sdp
->sd_sb
.sb_bsize_shift
;
341 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
343 /* Get the root inode */
344 inum
= &sdp
->sd_sb
.sb_root_dir
;
345 if (sb
->s_type
== &gfs2meta_fs_type
)
346 inum
= &sdp
->sd_sb
.sb_master_dir
;
347 inode
= gfs2_lookup_root(sdp
, inum
);
349 error
= PTR_ERR(inode
);
350 fs_err(sdp
, "can't read in root inode: %d\n", error
);
354 sb
->s_root
= d_alloc_root(inode
);
356 fs_err(sdp
, "can't get root dentry\n");
361 gfs2_glock_dq_uninit(&sb_gh
);
365 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
367 struct gfs2_holder ji_gh
;
368 struct task_struct
*p
;
369 struct gfs2_inode
*ip
;
378 sdp
->sd_jindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex");
379 if (IS_ERR(sdp
->sd_jindex
)) {
380 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
381 return PTR_ERR(sdp
->sd_jindex
);
383 ip
= sdp
->sd_jindex
->u
.generic_ip
;
384 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
386 /* Load in the journal index special file */
388 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
390 fs_err(sdp
, "can't read journal index: %d\n", error
);
395 if (!gfs2_jindex_size(sdp
)) {
396 fs_err(sdp
, "no journals!\n");
400 if (sdp
->sd_args
.ar_spectator
) {
401 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
402 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
404 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
405 fs_err(sdp
, "can't mount journal #%u\n",
406 sdp
->sd_lockstruct
.ls_jid
);
407 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
408 gfs2_jindex_size(sdp
),
409 gfs2_jindex_size(sdp
) - 1);
412 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
414 error
= gfs2_glock_nq_num(sdp
,
415 sdp
->sd_lockstruct
.ls_jid
,
417 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
418 &sdp
->sd_journal_gh
);
420 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
424 ip
= sdp
->sd_jdesc
->jd_inode
->u
.generic_ip
;
425 error
= gfs2_glock_nq_init(ip
->i_gl
,
427 LM_FLAG_NOEXP
| GL_EXACT
,
430 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
432 goto fail_journal_gh
;
435 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
437 fs_err(sdp
, "my journal (%u) is bad: %d\n",
438 sdp
->sd_jdesc
->jd_jid
, error
);
441 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
444 if (sdp
->sd_lockstruct
.ls_first
) {
446 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
447 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
),
450 fs_err(sdp
, "error recovering journal %u: %d\n",
456 gfs2_lm_others_may_mount(sdp
);
457 } else if (!sdp
->sd_args
.ar_spectator
) {
458 error
= gfs2_recover_journal(sdp
->sd_jdesc
, WAIT
);
460 fs_err(sdp
, "error recovering my journal: %d\n", error
);
465 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
466 gfs2_glock_dq_uninit(&ji_gh
);
469 /* Disown my Journal glock */
471 sdp
->sd_journal_gh
.gh_owner
= NULL
;
472 sdp
->sd_jinode_gh
.gh_owner
= NULL
;
474 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
477 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
480 sdp
->sd_recoverd_process
= p
;
485 kthread_stop(sdp
->sd_recoverd_process
);
488 if (!sdp
->sd_args
.ar_spectator
)
489 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
492 if (!sdp
->sd_args
.ar_spectator
)
493 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
496 gfs2_jindex_free(sdp
);
498 gfs2_glock_dq_uninit(&ji_gh
);
501 iput(sdp
->sd_jindex
);
507 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
510 struct gfs2_inode
*ip
;
516 inode
= gfs2_lookup_root(sdp
, &sdp
->sd_sb
.sb_master_dir
);
518 error
= PTR_ERR(inode
);
519 fs_err(sdp
, "can't read in master directory: %d\n", error
);
522 sdp
->sd_master_dir
= inode
;
524 error
= init_journal(sdp
, undo
);
528 /* Read in the master inode number inode */
529 sdp
->sd_inum_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum");
530 if (IS_ERR(sdp
->sd_inum_inode
)) {
531 error
= PTR_ERR(sdp
->sd_inum_inode
);
532 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
537 /* Read in the master statfs inode */
538 sdp
->sd_statfs_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs");
539 if (IS_ERR(sdp
->sd_statfs_inode
)) {
540 error
= PTR_ERR(sdp
->sd_statfs_inode
);
541 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
545 /* Read in the resource index inode */
546 sdp
->sd_rindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex");
547 if (IS_ERR(sdp
->sd_rindex
)) {
548 error
= PTR_ERR(sdp
->sd_rindex
);
549 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
552 ip
= sdp
->sd_rindex
->u
.generic_ip
;
553 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
554 sdp
->sd_rindex_vn
= ip
->i_gl
->gl_vn
- 1;
556 /* Read in the quota inode */
557 sdp
->sd_quota_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota");
558 if (IS_ERR(sdp
->sd_quota_inode
)) {
559 error
= PTR_ERR(sdp
->sd_quota_inode
);
560 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
566 iput(sdp
->sd_quota_inode
);
569 gfs2_clear_rgrpd(sdp
);
570 iput(sdp
->sd_rindex
);
573 iput(sdp
->sd_statfs_inode
);
576 iput(sdp
->sd_inum_inode
);
578 init_journal(sdp
, UNDO
);
580 iput(sdp
->sd_master_dir
);
585 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
587 struct inode
*pn
= NULL
;
590 struct gfs2_inode
*ip
;
592 if (sdp
->sd_args
.ar_spectator
)
598 pn
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node");
601 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
605 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
606 sdp
->sd_ir_inode
= gfs2_lookup_simple(pn
, buf
);
607 if (IS_ERR(sdp
->sd_ir_inode
)) {
608 error
= PTR_ERR(sdp
->sd_ir_inode
);
609 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
613 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
614 sdp
->sd_sc_inode
= gfs2_lookup_simple(pn
, buf
);
615 if (IS_ERR(sdp
->sd_sc_inode
)) {
616 error
= PTR_ERR(sdp
->sd_sc_inode
);
617 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
621 sprintf(buf
, "unlinked_tag%u", sdp
->sd_jdesc
->jd_jid
);
622 sdp
->sd_ut_inode
= gfs2_lookup_simple(pn
, buf
);
623 if (IS_ERR(sdp
->sd_ut_inode
)) {
624 error
= PTR_ERR(sdp
->sd_ut_inode
);
625 fs_err(sdp
, "can't find local \"ut\" file: %d\n", error
);
629 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
630 sdp
->sd_qc_inode
= gfs2_lookup_simple(pn
, buf
);
631 if (IS_ERR(sdp
->sd_qc_inode
)) {
632 error
= PTR_ERR(sdp
->sd_qc_inode
);
633 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
640 ip
= sdp
->sd_ir_inode
->u
.generic_ip
;
641 error
= gfs2_glock_nq_init(ip
->i_gl
,
642 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
645 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
649 ip
= sdp
->sd_sc_inode
->u
.generic_ip
;
650 error
= gfs2_glock_nq_init(ip
->i_gl
,
651 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
654 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
658 ip
= sdp
->sd_ut_inode
->u
.generic_ip
;
659 error
= gfs2_glock_nq_init(ip
->i_gl
,
660 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
663 fs_err(sdp
, "can't lock local \"ut\" file: %d\n", error
);
667 ip
= sdp
->sd_qc_inode
->u
.generic_ip
;
668 error
= gfs2_glock_nq_init(ip
->i_gl
,
669 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
672 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
679 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
682 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
685 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
688 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
691 iput(sdp
->sd_qc_inode
);
694 iput(sdp
->sd_ut_inode
);
697 iput(sdp
->sd_sc_inode
);
700 iput(sdp
->sd_ir_inode
);
708 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
710 struct task_struct
*p
;
716 sdp
->sd_log_flush_time
= jiffies
;
717 sdp
->sd_jindex_refresh_time
= jiffies
;
719 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
722 fs_err(sdp
, "can't start logd thread: %d\n", error
);
725 sdp
->sd_logd_process
= p
;
727 sdp
->sd_statfs_sync_time
= jiffies
;
728 sdp
->sd_quota_sync_time
= jiffies
;
730 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
733 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
736 sdp
->sd_quotad_process
= p
;
738 p
= kthread_run(gfs2_inoded
, sdp
, "gfs2_inoded");
741 fs_err(sdp
, "can't start inoded thread: %d\n", error
);
744 sdp
->sd_inoded_process
= p
;
749 kthread_stop(sdp
->sd_inoded_process
);
752 kthread_stop(sdp
->sd_quotad_process
);
755 kthread_stop(sdp
->sd_logd_process
);
761 * fill_super - Read in superblock
762 * @sb: The VFS superblock
763 * @data: Mount options
764 * @silent: Don't complain if it's not a GFS2 filesystem
769 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
771 struct gfs2_sbd
*sdp
;
772 struct gfs2_holder mount_gh
;
777 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
781 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
783 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
787 init_vfs(sb
, SDF_NOATIME
);
789 /* Set up the buffer cache and fill in some fake block size values
790 to allow us to read-in the on-disk superblock. */
791 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
792 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
793 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
794 GFS2_BASIC_BLOCK_SHIFT
;
795 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
797 error
= init_names(sdp
, silent
);
801 error
= gfs2_sys_fs_add(sdp
);
805 error
= gfs2_lm_mount(sdp
, silent
);
809 error
= init_locking(sdp
, &mount_gh
, DO
);
813 error
= init_sb(sdp
, silent
, DO
);
817 error
= init_inodes(sdp
, DO
);
821 error
= init_per_node(sdp
, DO
);
825 error
= gfs2_statfs_init(sdp
);
827 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
831 error
= init_threads(sdp
, DO
);
835 if (!(sb
->s_flags
& MS_RDONLY
)) {
836 error
= gfs2_make_fs_rw(sdp
);
838 fs_err(sdp
, "can't make FS RW: %d\n", error
);
843 gfs2_glock_dq_uninit(&mount_gh
);
848 init_threads(sdp
, UNDO
);
851 init_per_node(sdp
, UNDO
);
854 init_inodes(sdp
, UNDO
);
857 init_sb(sdp
, 0, UNDO
);
860 init_locking(sdp
, &mount_gh
, UNDO
);
863 gfs2_gl_hash_clear(sdp
, WAIT
);
864 gfs2_lm_unmount(sdp
);
865 while (invalidate_inodes(sb
))
869 gfs2_sys_fs_del(sdp
);
873 sb
->s_fs_info
= NULL
;
878 static struct super_block
*gfs2_get_sb(struct file_system_type
*fs_type
,
879 int flags
, const char *dev_name
,
882 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
);
885 static void gfs2_kill_sb(struct super_block
*sb
)
887 kill_block_super(sb
);
890 struct file_system_type gfs2_fs_type
= {
892 .fs_flags
= FS_REQUIRES_DEV
,
893 .get_sb
= gfs2_get_sb
,
894 .kill_sb
= gfs2_kill_sb
,
895 .owner
= THIS_MODULE
,
898 struct file_system_type gfs2meta_fs_type
= {
900 .fs_flags
= FS_REQUIRES_DEV
,
901 .get_sb
= gfs2_get_sb
,
902 .kill_sb
= gfs2_kill_sb
,
903 .owner
= THIS_MODULE
,