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 extern struct dentry_operations gfs2_dops
;
45 static struct gfs2_sbd
*init_sbd(struct super_block
*sb
)
50 sdp
= vmalloc(sizeof(struct gfs2_sbd
));
54 memset(sdp
, 0, sizeof(struct gfs2_sbd
));
59 gfs2_tune_init(&sdp
->sd_tune
);
61 for (x
= 0; x
< GFS2_GL_HASH_SIZE
; x
++) {
62 sdp
->sd_gl_hash
[x
].hb_lock
= RW_LOCK_UNLOCKED
;
63 INIT_LIST_HEAD(&sdp
->sd_gl_hash
[x
].hb_list
);
65 INIT_LIST_HEAD(&sdp
->sd_reclaim_list
);
66 spin_lock_init(&sdp
->sd_reclaim_lock
);
67 init_waitqueue_head(&sdp
->sd_reclaim_wq
);
68 mutex_init(&sdp
->sd_invalidate_inodes_mutex
);
70 mutex_init(&sdp
->sd_inum_mutex
);
71 spin_lock_init(&sdp
->sd_statfs_spin
);
72 mutex_init(&sdp
->sd_statfs_mutex
);
74 spin_lock_init(&sdp
->sd_rindex_spin
);
75 mutex_init(&sdp
->sd_rindex_mutex
);
76 INIT_LIST_HEAD(&sdp
->sd_rindex_list
);
77 INIT_LIST_HEAD(&sdp
->sd_rindex_mru_list
);
78 INIT_LIST_HEAD(&sdp
->sd_rindex_recent_list
);
80 INIT_LIST_HEAD(&sdp
->sd_jindex_list
);
81 spin_lock_init(&sdp
->sd_jindex_spin
);
82 mutex_init(&sdp
->sd_jindex_mutex
);
84 INIT_LIST_HEAD(&sdp
->sd_unlinked_list
);
85 spin_lock_init(&sdp
->sd_unlinked_spin
);
86 mutex_init(&sdp
->sd_unlinked_mutex
);
88 INIT_LIST_HEAD(&sdp
->sd_quota_list
);
89 spin_lock_init(&sdp
->sd_quota_spin
);
90 mutex_init(&sdp
->sd_quota_mutex
);
92 spin_lock_init(&sdp
->sd_log_lock
);
94 INIT_LIST_HEAD(&sdp
->sd_log_le_gl
);
95 INIT_LIST_HEAD(&sdp
->sd_log_le_buf
);
96 INIT_LIST_HEAD(&sdp
->sd_log_le_revoke
);
97 INIT_LIST_HEAD(&sdp
->sd_log_le_rg
);
98 INIT_LIST_HEAD(&sdp
->sd_log_le_databuf
);
100 mutex_init(&sdp
->sd_log_reserve_mutex
);
101 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
102 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
104 init_rwsem(&sdp
->sd_log_flush_lock
);
105 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
107 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
109 mutex_init(&sdp
->sd_freeze_lock
);
114 static void init_vfs(struct super_block
*sb
, unsigned noatime
)
116 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
118 sb
->s_magic
= GFS2_MAGIC
;
119 sb
->s_op
= &gfs2_super_ops
;
120 sb
->s_export_op
= &gfs2_export_ops
;
121 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
123 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
124 set_bit(noatime
, &sdp
->sd_flags
);
126 /* Don't let the VFS update atimes. GFS2 handles this itself. */
127 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
130 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
132 struct gfs2_sb
*sb
= NULL
;
136 proto
= sdp
->sd_args
.ar_lockproto
;
137 table
= sdp
->sd_args
.ar_locktable
;
139 /* Try to autodetect */
141 if (!proto
[0] || !table
[0]) {
142 struct buffer_head
*bh
;
143 bh
= sb_getblk(sdp
->sd_vfs
,
144 GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
146 clear_buffer_uptodate(bh
);
147 clear_buffer_dirty(bh
);
149 ll_rw_block(READ
, 1, &bh
);
152 if (!buffer_uptodate(bh
)) {
157 sb
= kmalloc(sizeof(struct gfs2_sb
), GFP_KERNEL
);
162 gfs2_sb_in(sb
, bh
->b_data
);
165 error
= gfs2_check_sb(sdp
, sb
, silent
);
170 proto
= sb
->sb_lockproto
;
172 table
= sb
->sb_locktable
;
176 table
= sdp
->sd_vfs
->s_id
;
178 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
179 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
187 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
190 struct task_struct
*p
;
196 p
= kthread_run(gfs2_scand
, sdp
, "gfs2_scand");
199 fs_err(sdp
, "can't start scand thread: %d\n", error
);
202 sdp
->sd_scand_process
= p
;
204 for (sdp
->sd_glockd_num
= 0;
205 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
206 sdp
->sd_glockd_num
++) {
207 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
210 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
213 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
216 error
= gfs2_glock_nq_num(sdp
,
217 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
218 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
221 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
225 error
= gfs2_glock_nq_num(sdp
,
226 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
228 LM_FLAG_NOEXP
| GL_EXACT
,
231 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
235 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
236 CREATE
, &sdp
->sd_rename_gl
);
238 fs_err(sdp
, "can't create rename glock: %d\n", error
);
242 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
243 CREATE
, &sdp
->sd_trans_gl
);
245 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
248 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
253 gfs2_glock_put(sdp
->sd_trans_gl
);
256 gfs2_glock_put(sdp
->sd_rename_gl
);
259 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
262 gfs2_glock_dq_uninit(mount_gh
);
265 while (sdp
->sd_glockd_num
--)
266 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
268 kthread_stop(sdp
->sd_scand_process
);
273 static struct inode
*gfs2_lookup_root(struct gfs2_sbd
*sdp
,
274 const struct gfs2_inum
*inum
)
277 struct gfs2_glock
*gl
;
278 struct gfs2_inode
*ip
;
281 error
= gfs2_glock_get(sdp
, inum
->no_addr
, &gfs2_inode_glops
,
284 error
= gfs2_inode_get(gl
, inum
, CREATE
, &ip
);
286 gfs2_inode_min_init(ip
, DT_DIR
);
287 inode
= gfs2_ip2v(ip
);
294 return ERR_PTR(error
);
297 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
299 struct super_block
*sb
= sdp
->sd_vfs
;
300 struct gfs2_holder sb_gh
;
301 struct gfs2_inum
*inum
;
309 error
= gfs2_glock_nq_num(sdp
,
310 GFS2_SB_LOCK
, &gfs2_meta_glops
,
311 LM_ST_SHARED
, 0, &sb_gh
);
313 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
317 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
319 fs_err(sdp
, "can't read superblock: %d\n", error
);
323 /* Set up the buffer cache and SB for real */
324 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
326 fs_err(sdp
, "FS block size (%u) is too small for device "
328 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
331 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
333 fs_err(sdp
, "FS block size (%u) is too big for machine "
335 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
339 /* Get rid of buffers from the original block size */
340 sb_gh
.gh_gl
->gl_ops
->go_inval(sb_gh
.gh_gl
, DIO_METADATA
| DIO_DATA
);
341 sb_gh
.gh_gl
->gl_aspace
->i_blkbits
= sdp
->sd_sb
.sb_bsize_shift
;
343 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
345 /* Get the root inode */
346 inum
= &sdp
->sd_sb
.sb_root_dir
;
347 if (sb
->s_type
== &gfs2meta_fs_type
)
348 inum
= &sdp
->sd_sb
.sb_master_dir
;
349 inode
= gfs2_lookup_root(sdp
, inum
);
351 error
= PTR_ERR(inode
);
352 fs_err(sdp
, "can't read in root inode: %d\n", error
);
356 sb
->s_root
= d_alloc_root(inode
);
358 fs_err(sdp
, "can't get root dentry\n");
362 sb
->s_root
->d_op
= &gfs2_dops
;
364 gfs2_glock_dq_uninit(&sb_gh
);
368 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
370 struct gfs2_holder ji_gh
;
371 struct task_struct
*p
;
372 struct gfs2_inode
*ip
;
381 sdp
->sd_jindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex");
382 if (IS_ERR(sdp
->sd_jindex
)) {
383 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
384 return PTR_ERR(sdp
->sd_jindex
);
386 ip
= sdp
->sd_jindex
->u
.generic_ip
;
387 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
389 /* Load in the journal index special file */
391 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
393 fs_err(sdp
, "can't read journal index: %d\n", error
);
398 if (!gfs2_jindex_size(sdp
)) {
399 fs_err(sdp
, "no journals!\n");
403 if (sdp
->sd_args
.ar_spectator
) {
404 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
405 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
407 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
408 fs_err(sdp
, "can't mount journal #%u\n",
409 sdp
->sd_lockstruct
.ls_jid
);
410 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
411 gfs2_jindex_size(sdp
),
412 gfs2_jindex_size(sdp
) - 1);
415 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
417 error
= gfs2_glock_nq_num(sdp
,
418 sdp
->sd_lockstruct
.ls_jid
,
420 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
421 &sdp
->sd_journal_gh
);
423 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
427 ip
= sdp
->sd_jdesc
->jd_inode
->u
.generic_ip
;
428 error
= gfs2_glock_nq_init(ip
->i_gl
,
430 LM_FLAG_NOEXP
| GL_EXACT
,
433 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
435 goto fail_journal_gh
;
438 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
440 fs_err(sdp
, "my journal (%u) is bad: %d\n",
441 sdp
->sd_jdesc
->jd_jid
, error
);
444 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
447 if (sdp
->sd_lockstruct
.ls_first
) {
449 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
450 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
));
452 fs_err(sdp
, "error recovering journal %u: %d\n",
458 gfs2_lm_others_may_mount(sdp
);
459 } else if (!sdp
->sd_args
.ar_spectator
) {
460 error
= gfs2_recover_journal(sdp
->sd_jdesc
);
462 fs_err(sdp
, "error recovering my journal: %d\n", error
);
467 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
468 gfs2_glock_dq_uninit(&ji_gh
);
471 /* Disown my Journal glock */
473 sdp
->sd_journal_gh
.gh_owner
= NULL
;
474 sdp
->sd_jinode_gh
.gh_owner
= NULL
;
476 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
479 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
482 sdp
->sd_recoverd_process
= p
;
487 kthread_stop(sdp
->sd_recoverd_process
);
490 if (!sdp
->sd_args
.ar_spectator
)
491 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
494 if (!sdp
->sd_args
.ar_spectator
)
495 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
498 gfs2_jindex_free(sdp
);
500 gfs2_glock_dq_uninit(&ji_gh
);
503 iput(sdp
->sd_jindex
);
509 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
512 struct gfs2_inode
*ip
;
518 inode
= gfs2_lookup_root(sdp
, &sdp
->sd_sb
.sb_master_dir
);
520 error
= PTR_ERR(inode
);
521 fs_err(sdp
, "can't read in master directory: %d\n", error
);
524 sdp
->sd_master_dir
= inode
;
526 error
= init_journal(sdp
, undo
);
530 /* Read in the master inode number inode */
531 sdp
->sd_inum_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum");
532 if (IS_ERR(sdp
->sd_inum_inode
)) {
533 error
= PTR_ERR(sdp
->sd_inum_inode
);
534 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
539 /* Read in the master statfs inode */
540 sdp
->sd_statfs_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs");
541 if (IS_ERR(sdp
->sd_statfs_inode
)) {
542 error
= PTR_ERR(sdp
->sd_statfs_inode
);
543 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
547 /* Read in the resource index inode */
548 sdp
->sd_rindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex");
549 if (IS_ERR(sdp
->sd_rindex
)) {
550 error
= PTR_ERR(sdp
->sd_rindex
);
551 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
554 ip
= sdp
->sd_rindex
->u
.generic_ip
;
555 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
556 sdp
->sd_rindex_vn
= ip
->i_gl
->gl_vn
- 1;
558 /* Read in the quota inode */
559 sdp
->sd_quota_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota");
560 if (IS_ERR(sdp
->sd_quota_inode
)) {
561 error
= PTR_ERR(sdp
->sd_quota_inode
);
562 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
568 iput(sdp
->sd_quota_inode
);
571 gfs2_clear_rgrpd(sdp
);
572 iput(sdp
->sd_rindex
);
575 iput(sdp
->sd_statfs_inode
);
578 iput(sdp
->sd_inum_inode
);
580 init_journal(sdp
, UNDO
);
582 iput(sdp
->sd_master_dir
);
587 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
589 struct inode
*pn
= NULL
;
592 struct gfs2_inode
*ip
;
594 if (sdp
->sd_args
.ar_spectator
)
600 pn
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node");
603 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
607 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
608 sdp
->sd_ir_inode
= gfs2_lookup_simple(pn
, buf
);
609 if (IS_ERR(sdp
->sd_ir_inode
)) {
610 error
= PTR_ERR(sdp
->sd_ir_inode
);
611 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
615 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
616 sdp
->sd_sc_inode
= gfs2_lookup_simple(pn
, buf
);
617 if (IS_ERR(sdp
->sd_sc_inode
)) {
618 error
= PTR_ERR(sdp
->sd_sc_inode
);
619 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
623 sprintf(buf
, "unlinked_tag%u", sdp
->sd_jdesc
->jd_jid
);
624 sdp
->sd_ut_inode
= gfs2_lookup_simple(pn
, buf
);
625 if (IS_ERR(sdp
->sd_ut_inode
)) {
626 error
= PTR_ERR(sdp
->sd_ut_inode
);
627 fs_err(sdp
, "can't find local \"ut\" file: %d\n", error
);
631 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
632 sdp
->sd_qc_inode
= gfs2_lookup_simple(pn
, buf
);
633 if (IS_ERR(sdp
->sd_qc_inode
)) {
634 error
= PTR_ERR(sdp
->sd_qc_inode
);
635 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
642 ip
= sdp
->sd_ir_inode
->u
.generic_ip
;
643 error
= gfs2_glock_nq_init(ip
->i_gl
,
647 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
651 ip
= sdp
->sd_sc_inode
->u
.generic_ip
;
652 error
= gfs2_glock_nq_init(ip
->i_gl
,
656 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
660 ip
= sdp
->sd_ut_inode
->u
.generic_ip
;
661 error
= gfs2_glock_nq_init(ip
->i_gl
,
665 fs_err(sdp
, "can't lock local \"ut\" file: %d\n", error
);
669 ip
= sdp
->sd_qc_inode
->u
.generic_ip
;
670 error
= gfs2_glock_nq_init(ip
->i_gl
,
674 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
681 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
684 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
687 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
690 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
693 iput(sdp
->sd_qc_inode
);
696 iput(sdp
->sd_ut_inode
);
699 iput(sdp
->sd_sc_inode
);
702 iput(sdp
->sd_ir_inode
);
710 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
712 struct task_struct
*p
;
718 sdp
->sd_log_flush_time
= jiffies
;
719 sdp
->sd_jindex_refresh_time
= jiffies
;
721 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
724 fs_err(sdp
, "can't start logd thread: %d\n", error
);
727 sdp
->sd_logd_process
= p
;
729 sdp
->sd_statfs_sync_time
= jiffies
;
730 sdp
->sd_quota_sync_time
= jiffies
;
732 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
735 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
738 sdp
->sd_quotad_process
= p
;
740 p
= kthread_run(gfs2_inoded
, sdp
, "gfs2_inoded");
743 fs_err(sdp
, "can't start inoded thread: %d\n", error
);
746 sdp
->sd_inoded_process
= p
;
751 kthread_stop(sdp
->sd_inoded_process
);
754 kthread_stop(sdp
->sd_quotad_process
);
757 kthread_stop(sdp
->sd_logd_process
);
763 * fill_super - Read in superblock
764 * @sb: The VFS superblock
765 * @data: Mount options
766 * @silent: Don't complain if it's not a GFS2 filesystem
771 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
773 struct gfs2_sbd
*sdp
;
774 struct gfs2_holder mount_gh
;
779 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
783 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
785 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
789 init_vfs(sb
, SDF_NOATIME
);
791 /* Set up the buffer cache and fill in some fake block size values
792 to allow us to read-in the on-disk superblock. */
793 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
794 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
795 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
796 GFS2_BASIC_BLOCK_SHIFT
;
797 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
799 error
= init_names(sdp
, silent
);
803 error
= gfs2_sys_fs_add(sdp
);
807 error
= gfs2_lm_mount(sdp
, silent
);
811 error
= init_locking(sdp
, &mount_gh
, DO
);
815 error
= init_sb(sdp
, silent
, DO
);
819 error
= init_inodes(sdp
, DO
);
823 error
= init_per_node(sdp
, DO
);
827 error
= gfs2_statfs_init(sdp
);
829 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
833 error
= init_threads(sdp
, DO
);
837 if (!(sb
->s_flags
& MS_RDONLY
)) {
838 error
= gfs2_make_fs_rw(sdp
);
840 fs_err(sdp
, "can't make FS RW: %d\n", error
);
845 gfs2_glock_dq_uninit(&mount_gh
);
850 init_threads(sdp
, UNDO
);
853 init_per_node(sdp
, UNDO
);
856 init_inodes(sdp
, UNDO
);
859 init_sb(sdp
, 0, UNDO
);
862 init_locking(sdp
, &mount_gh
, UNDO
);
865 gfs2_gl_hash_clear(sdp
, WAIT
);
866 gfs2_lm_unmount(sdp
);
867 while (invalidate_inodes(sb
))
871 gfs2_sys_fs_del(sdp
);
875 sb
->s_fs_info
= NULL
;
880 static struct super_block
*gfs2_get_sb(struct file_system_type
*fs_type
,
881 int flags
, const char *dev_name
,
884 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
);
887 static void gfs2_kill_sb(struct super_block
*sb
)
889 kill_block_super(sb
);
892 struct file_system_type gfs2_fs_type
= {
894 .fs_flags
= FS_REQUIRES_DEV
,
895 .get_sb
= gfs2_get_sb
,
896 .kill_sb
= gfs2_kill_sb
,
897 .owner
= THIS_MODULE
,
900 struct file_system_type gfs2meta_fs_type
= {
902 .fs_flags
= FS_REQUIRES_DEV
,
903 .get_sb
= gfs2_get_sb
,
904 .kill_sb
= gfs2_kill_sb
,
905 .owner
= THIS_MODULE
,