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
);
91 init_waitqueue_head(&sdp
->sd_log_trans_wq
);
92 init_waitqueue_head(&sdp
->sd_log_flush_wq
);
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 INIT_LIST_HEAD(&sdp
->sd_log_blks_list
);
101 init_waitqueue_head(&sdp
->sd_log_blks_wait
);
103 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
104 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
106 mutex_init(&sdp
->sd_log_flush_lock
);
107 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
109 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
111 mutex_init(&sdp
->sd_freeze_lock
);
116 static void init_vfs(struct gfs2_sbd
*sdp
)
118 struct super_block
*sb
= sdp
->sd_vfs
;
120 sb
->s_magic
= GFS2_MAGIC
;
121 sb
->s_op
= &gfs2_super_ops
;
122 sb
->s_export_op
= &gfs2_export_ops
;
123 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
125 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
126 set_bit(SDF_NOATIME
, &sdp
->sd_flags
);
128 /* Don't let the VFS update atimes. GFS2 handles this itself. */
129 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
131 /* Set up the buffer cache and fill in some fake block size values
132 to allow us to read-in the on-disk superblock. */
133 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
134 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
135 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
136 GFS2_BASIC_BLOCK_SHIFT
;
137 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
140 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
142 struct gfs2_sb
*sb
= NULL
;
146 proto
= sdp
->sd_args
.ar_lockproto
;
147 table
= sdp
->sd_args
.ar_locktable
;
149 /* Try to autodetect */
151 if (!proto
[0] || !table
[0]) {
152 struct buffer_head
*bh
;
153 bh
= sb_getblk(sdp
->sd_vfs
,
154 GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
156 clear_buffer_uptodate(bh
);
157 clear_buffer_dirty(bh
);
159 ll_rw_block(READ
, 1, &bh
);
162 if (!buffer_uptodate(bh
)) {
167 sb
= kmalloc(sizeof(struct gfs2_sb
), GFP_KERNEL
);
172 gfs2_sb_in(sb
, bh
->b_data
);
175 error
= gfs2_check_sb(sdp
, sb
, silent
);
180 proto
= sb
->sb_lockproto
;
182 table
= sb
->sb_locktable
;
186 table
= sdp
->sd_vfs
->s_id
;
188 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
189 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
197 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
200 struct task_struct
*p
;
206 p
= kthread_run(gfs2_scand
, sdp
, "gfs2_scand");
209 fs_err(sdp
, "can't start scand thread: %d\n", error
);
212 sdp
->sd_scand_process
= p
;
214 for (sdp
->sd_glockd_num
= 0;
215 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
216 sdp
->sd_glockd_num
++) {
217 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
220 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
223 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
226 error
= gfs2_glock_nq_num(sdp
,
227 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
228 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
231 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
235 error
= gfs2_glock_nq_num(sdp
,
236 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
238 LM_FLAG_NOEXP
| GL_EXACT
| GL_NEVER_RECURSE
,
241 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
245 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
246 CREATE
, &sdp
->sd_rename_gl
);
248 fs_err(sdp
, "can't create rename glock: %d\n", error
);
252 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
253 CREATE
, &sdp
->sd_trans_gl
);
255 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
258 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
263 gfs2_glock_put(sdp
->sd_trans_gl
);
266 gfs2_glock_put(sdp
->sd_rename_gl
);
269 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
272 gfs2_glock_dq_uninit(mount_gh
);
275 while (sdp
->sd_glockd_num
--)
276 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
278 kthread_stop(sdp
->sd_scand_process
);
283 static struct inode
*gfs2_lookup_root(struct gfs2_sbd
*sdp
,
284 const struct gfs2_inum
*inum
)
287 struct gfs2_glock
*gl
;
288 struct gfs2_inode
*ip
;
291 error
= gfs2_glock_get(sdp
, inum
->no_addr
,
292 &gfs2_inode_glops
, CREATE
, &gl
);
294 error
= gfs2_inode_get(gl
, inum
,
298 gfs2_inode_min_init(ip
, DT_DIR
);
299 inode
= gfs2_ip2v(ip
);
306 return ERR_PTR(error
);
309 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
311 struct super_block
*sb
= sdp
->sd_vfs
;
312 struct gfs2_holder sb_gh
;
320 error
= gfs2_glock_nq_num(sdp
,
321 GFS2_SB_LOCK
, &gfs2_meta_glops
,
322 LM_ST_SHARED
, 0, &sb_gh
);
324 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
328 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
330 fs_err(sdp
, "can't read superblock: %d\n", error
);
334 /* Set up the buffer cache and SB for real */
336 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
337 fs_err(sdp
, "FS block size (%u) is too small for device "
339 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
342 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
343 fs_err(sdp
, "FS block size (%u) is too big for machine "
345 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
349 /* Get rid of buffers from the original block size */
350 sb_gh
.gh_gl
->gl_ops
->go_inval(sb_gh
.gh_gl
, DIO_METADATA
| DIO_DATA
);
351 sb_gh
.gh_gl
->gl_aspace
->i_blkbits
= sdp
->sd_sb
.sb_bsize_shift
;
353 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
355 /* Get the root inode */
356 inode
= gfs2_lookup_root(sdp
, &sdp
->sd_sb
.sb_root_dir
);
358 error
= PTR_ERR(inode
);
359 fs_err(sdp
, "can't read in root inode: %d\n", error
);
363 sb
->s_root
= d_alloc_root(inode
);
365 fs_err(sdp
, "can't get root dentry\n");
371 gfs2_glock_dq_uninit(&sb_gh
);
376 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
378 struct gfs2_holder ji_gh
;
379 struct task_struct
*p
;
380 struct gfs2_inode
*ip
;
389 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex",
392 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
395 ip
= sdp
->sd_jindex
->u
.generic_ip
;
396 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
398 /* Load in the journal index special file */
400 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
402 fs_err(sdp
, "can't read journal index: %d\n", error
);
407 if (!gfs2_jindex_size(sdp
)) {
408 fs_err(sdp
, "no journals!\n");
412 if (sdp
->sd_args
.ar_spectator
) {
413 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
414 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
416 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
417 fs_err(sdp
, "can't mount journal #%u\n",
418 sdp
->sd_lockstruct
.ls_jid
);
419 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
420 gfs2_jindex_size(sdp
),
421 gfs2_jindex_size(sdp
) - 1);
424 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
426 error
= gfs2_glock_nq_num(sdp
,
427 sdp
->sd_lockstruct
.ls_jid
,
429 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
430 &sdp
->sd_journal_gh
);
432 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
436 ip
= sdp
->sd_jdesc
->jd_inode
->u
.generic_ip
;
437 error
= gfs2_glock_nq_init(ip
->i_gl
,
439 LM_FLAG_NOEXP
| GL_EXACT
,
442 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
444 goto fail_journal_gh
;
447 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
449 fs_err(sdp
, "my journal (%u) is bad: %d\n",
450 sdp
->sd_jdesc
->jd_jid
, error
);
453 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
456 if (sdp
->sd_lockstruct
.ls_first
) {
458 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
459 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
),
462 fs_err(sdp
, "error recovering journal %u: %d\n",
468 gfs2_lm_others_may_mount(sdp
);
469 } else if (!sdp
->sd_args
.ar_spectator
) {
470 error
= gfs2_recover_journal(sdp
->sd_jdesc
, WAIT
);
472 fs_err(sdp
, "error recovering my journal: %d\n", error
);
477 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
478 gfs2_glock_dq_uninit(&ji_gh
);
481 /* Disown my Journal glock */
483 sdp
->sd_journal_gh
.gh_owner
= NULL
;
484 sdp
->sd_jinode_gh
.gh_owner
= NULL
;
486 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
489 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
492 sdp
->sd_recoverd_process
= p
;
497 kthread_stop(sdp
->sd_recoverd_process
);
500 if (!sdp
->sd_args
.ar_spectator
)
501 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
504 if (!sdp
->sd_args
.ar_spectator
)
505 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
508 gfs2_jindex_free(sdp
);
510 gfs2_glock_dq_uninit(&ji_gh
);
513 iput(sdp
->sd_jindex
);
519 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
522 struct gfs2_inode
*ip
;
528 inode
= gfs2_lookup_root(sdp
, &sdp
->sd_sb
.sb_master_dir
);
530 error
= PTR_ERR(inode
);
531 fs_err(sdp
, "can't read in master directory: %d\n", error
);
534 sdp
->sd_master_dir
= inode
;
536 error
= init_journal(sdp
, undo
);
540 /* Read in the master inode number inode */
541 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum",
542 &sdp
->sd_inum_inode
);
544 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
549 /* Read in the master statfs inode */
550 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs",
551 &sdp
->sd_statfs_inode
);
553 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
557 /* Read in the resource index inode */
558 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex",
561 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
564 ip
= sdp
->sd_rindex
->u
.generic_ip
;
565 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
566 sdp
->sd_rindex_vn
= ip
->i_gl
->gl_vn
- 1;
568 /* Read in the quota inode */
569 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota",
570 &sdp
->sd_quota_inode
);
572 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
578 iput(sdp
->sd_quota_inode
);
581 gfs2_clear_rgrpd(sdp
);
582 iput(sdp
->sd_rindex
);
585 iput(sdp
->sd_statfs_inode
);
588 iput(sdp
->sd_inum_inode
);
590 init_journal(sdp
, UNDO
);
592 iput(sdp
->sd_master_dir
);
597 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
599 struct inode
*pn
= NULL
;
602 struct gfs2_inode
*ip
;
604 if (sdp
->sd_args
.ar_spectator
)
610 error
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node", &pn
);
612 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
616 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
617 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_ir_inode
);
619 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
623 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
624 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_sc_inode
);
626 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
630 sprintf(buf
, "unlinked_tag%u", sdp
->sd_jdesc
->jd_jid
);
631 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_ut_inode
);
633 fs_err(sdp
, "can't find local \"ut\" file: %d\n", error
);
637 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
638 error
= gfs2_lookup_simple(pn
, buf
, &sdp
->sd_qc_inode
);
640 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
647 ip
= sdp
->sd_ir_inode
->u
.generic_ip
;
648 error
= gfs2_glock_nq_init(ip
->i_gl
,
649 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
652 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
656 ip
= sdp
->sd_sc_inode
->u
.generic_ip
;
657 error
= gfs2_glock_nq_init(ip
->i_gl
,
658 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
661 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
665 ip
= sdp
->sd_ut_inode
->u
.generic_ip
;
666 error
= gfs2_glock_nq_init(ip
->i_gl
,
667 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
670 fs_err(sdp
, "can't lock local \"ut\" file: %d\n", error
);
674 ip
= sdp
->sd_qc_inode
->u
.generic_ip
;
675 error
= gfs2_glock_nq_init(ip
->i_gl
,
676 LM_ST_EXCLUSIVE
, GL_NEVER_RECURSE
,
679 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
686 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
689 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
692 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
695 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
698 iput(sdp
->sd_qc_inode
);
701 iput(sdp
->sd_ut_inode
);
704 iput(sdp
->sd_sc_inode
);
707 iput(sdp
->sd_ir_inode
);
715 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
717 struct task_struct
*p
;
723 sdp
->sd_log_flush_time
= jiffies
;
724 sdp
->sd_jindex_refresh_time
= jiffies
;
726 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
729 fs_err(sdp
, "can't start logd thread: %d\n", error
);
732 sdp
->sd_logd_process
= p
;
734 sdp
->sd_statfs_sync_time
= jiffies
;
735 sdp
->sd_quota_sync_time
= jiffies
;
737 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
740 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
743 sdp
->sd_quotad_process
= p
;
745 p
= kthread_run(gfs2_inoded
, sdp
, "gfs2_inoded");
748 fs_err(sdp
, "can't start inoded thread: %d\n", error
);
751 sdp
->sd_inoded_process
= p
;
756 kthread_stop(sdp
->sd_inoded_process
);
759 kthread_stop(sdp
->sd_quotad_process
);
762 kthread_stop(sdp
->sd_logd_process
);
768 * fill_super - Read in superblock
769 * @sb: The VFS superblock
770 * @data: Mount options
771 * @silent: Don't complain if it's not a GFS2 filesystem
776 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
778 struct gfs2_sbd
*sdp
;
779 struct gfs2_holder mount_gh
;
784 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
788 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
790 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
796 error
= init_names(sdp
, silent
);
800 error
= gfs2_sys_fs_add(sdp
);
804 error
= gfs2_lm_mount(sdp
, silent
);
808 error
= init_locking(sdp
, &mount_gh
, DO
);
812 error
= init_sb(sdp
, silent
, DO
);
816 error
= init_inodes(sdp
, DO
);
820 error
= init_per_node(sdp
, DO
);
824 error
= gfs2_statfs_init(sdp
);
826 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
830 error
= init_threads(sdp
, DO
);
834 if (!(sb
->s_flags
& MS_RDONLY
)) {
835 error
= gfs2_make_fs_rw(sdp
);
837 fs_err(sdp
, "can't make FS RW: %d\n", error
);
842 gfs2_glock_dq_uninit(&mount_gh
);
847 init_threads(sdp
, UNDO
);
850 init_per_node(sdp
, UNDO
);
853 init_inodes(sdp
, UNDO
);
856 init_sb(sdp
, 0, UNDO
);
859 init_locking(sdp
, &mount_gh
, UNDO
);
862 gfs2_gl_hash_clear(sdp
, WAIT
);
863 gfs2_lm_unmount(sdp
);
864 while (invalidate_inodes(sb
))
868 gfs2_sys_fs_del(sdp
);
872 sb
->s_fs_info
= NULL
;
877 static struct super_block
*gfs2_get_sb(struct file_system_type
*fs_type
,
878 int flags
, const char *dev_name
,
881 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
);
884 struct file_system_type gfs2_fs_type
= {
886 .fs_flags
= FS_REQUIRES_DEV
,
887 .get_sb
= gfs2_get_sb
,
888 .kill_sb
= kill_block_super
,
889 .owner
= THIS_MODULE
,