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 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>
21 #include "lm_interface.h"
29 #include "ops_export.h"
30 #include "ops_fstype.h"
31 #include "ops_super.h"
41 extern struct dentry_operations gfs2_dops
;
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 rwlock_init(&sdp
->sd_gl_hash
[x
].hb_lock
);
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_quota_list
);
83 spin_lock_init(&sdp
->sd_quota_spin
);
84 mutex_init(&sdp
->sd_quota_mutex
);
86 spin_lock_init(&sdp
->sd_log_lock
);
88 INIT_LIST_HEAD(&sdp
->sd_log_le_gl
);
89 INIT_LIST_HEAD(&sdp
->sd_log_le_buf
);
90 INIT_LIST_HEAD(&sdp
->sd_log_le_revoke
);
91 INIT_LIST_HEAD(&sdp
->sd_log_le_rg
);
92 INIT_LIST_HEAD(&sdp
->sd_log_le_databuf
);
94 mutex_init(&sdp
->sd_log_reserve_mutex
);
95 INIT_LIST_HEAD(&sdp
->sd_ail1_list
);
96 INIT_LIST_HEAD(&sdp
->sd_ail2_list
);
98 init_rwsem(&sdp
->sd_log_flush_lock
);
99 INIT_LIST_HEAD(&sdp
->sd_log_flush_list
);
101 INIT_LIST_HEAD(&sdp
->sd_revoke_list
);
103 mutex_init(&sdp
->sd_freeze_lock
);
108 static void init_vfs(struct super_block
*sb
, unsigned noatime
)
110 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
112 sb
->s_magic
= GFS2_MAGIC
;
113 sb
->s_op
= &gfs2_super_ops
;
114 sb
->s_export_op
= &gfs2_export_ops
;
115 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
117 if (sb
->s_flags
& (MS_NOATIME
| MS_NODIRATIME
))
118 set_bit(noatime
, &sdp
->sd_flags
);
120 /* Don't let the VFS update atimes. GFS2 handles this itself. */
121 sb
->s_flags
|= MS_NOATIME
| MS_NODIRATIME
;
124 static int init_names(struct gfs2_sbd
*sdp
, int silent
)
126 struct gfs2_sb
*sb
= NULL
;
130 proto
= sdp
->sd_args
.ar_lockproto
;
131 table
= sdp
->sd_args
.ar_locktable
;
133 /* Try to autodetect */
135 if (!proto
[0] || !table
[0]) {
136 struct buffer_head
*bh
;
137 bh
= sb_getblk(sdp
->sd_vfs
,
138 GFS2_SB_ADDR
>> sdp
->sd_fsb2bb_shift
);
140 clear_buffer_uptodate(bh
);
141 clear_buffer_dirty(bh
);
143 ll_rw_block(READ
, 1, &bh
);
146 if (!buffer_uptodate(bh
)) {
151 sb
= kmalloc(sizeof(struct gfs2_sb
), GFP_KERNEL
);
156 gfs2_sb_in(sb
, bh
->b_data
);
159 error
= gfs2_check_sb(sdp
, sb
, silent
);
164 proto
= sb
->sb_lockproto
;
166 table
= sb
->sb_locktable
;
170 table
= sdp
->sd_vfs
->s_id
;
172 snprintf(sdp
->sd_proto_name
, GFS2_FSNAME_LEN
, "%s", proto
);
173 snprintf(sdp
->sd_table_name
, GFS2_FSNAME_LEN
, "%s", table
);
181 static int init_locking(struct gfs2_sbd
*sdp
, struct gfs2_holder
*mount_gh
,
184 struct task_struct
*p
;
190 p
= kthread_run(gfs2_scand
, sdp
, "gfs2_scand");
193 fs_err(sdp
, "can't start scand thread: %d\n", error
);
196 sdp
->sd_scand_process
= p
;
198 for (sdp
->sd_glockd_num
= 0;
199 sdp
->sd_glockd_num
< sdp
->sd_args
.ar_num_glockd
;
200 sdp
->sd_glockd_num
++) {
201 p
= kthread_run(gfs2_glockd
, sdp
, "gfs2_glockd");
204 fs_err(sdp
, "can't start glockd thread: %d\n", error
);
207 sdp
->sd_glockd_process
[sdp
->sd_glockd_num
] = p
;
210 error
= gfs2_glock_nq_num(sdp
,
211 GFS2_MOUNT_LOCK
, &gfs2_nondisk_glops
,
212 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
| GL_NOCACHE
,
215 fs_err(sdp
, "can't acquire mount glock: %d\n", error
);
219 error
= gfs2_glock_nq_num(sdp
,
220 GFS2_LIVE_LOCK
, &gfs2_nondisk_glops
,
222 LM_FLAG_NOEXP
| GL_EXACT
,
225 fs_err(sdp
, "can't acquire live glock: %d\n", error
);
229 error
= gfs2_glock_get(sdp
, GFS2_RENAME_LOCK
, &gfs2_nondisk_glops
,
230 CREATE
, &sdp
->sd_rename_gl
);
232 fs_err(sdp
, "can't create rename glock: %d\n", error
);
236 error
= gfs2_glock_get(sdp
, GFS2_TRANS_LOCK
, &gfs2_trans_glops
,
237 CREATE
, &sdp
->sd_trans_gl
);
239 fs_err(sdp
, "can't create transaction glock: %d\n", error
);
242 set_bit(GLF_STICKY
, &sdp
->sd_trans_gl
->gl_flags
);
247 gfs2_glock_put(sdp
->sd_trans_gl
);
250 gfs2_glock_put(sdp
->sd_rename_gl
);
253 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
256 gfs2_glock_dq_uninit(mount_gh
);
259 while (sdp
->sd_glockd_num
--)
260 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
262 kthread_stop(sdp
->sd_scand_process
);
267 static struct inode
*gfs2_lookup_root(struct super_block
*sb
,
268 struct gfs2_inum
*inum
)
270 return gfs2_inode_lookup(sb
, inum
, DT_DIR
);
273 static int init_sb(struct gfs2_sbd
*sdp
, int silent
, int undo
)
275 struct super_block
*sb
= sdp
->sd_vfs
;
276 struct gfs2_holder sb_gh
;
277 struct gfs2_inum
*inum
;
285 error
= gfs2_glock_nq_num(sdp
, GFS2_SB_LOCK
, &gfs2_meta_glops
,
286 LM_ST_SHARED
, 0, &sb_gh
);
288 fs_err(sdp
, "can't acquire superblock glock: %d\n", error
);
292 error
= gfs2_read_sb(sdp
, sb_gh
.gh_gl
, silent
);
294 fs_err(sdp
, "can't read superblock: %d\n", error
);
298 /* Set up the buffer cache and SB for real */
299 if (sdp
->sd_sb
.sb_bsize
< bdev_hardsect_size(sb
->s_bdev
)) {
301 fs_err(sdp
, "FS block size (%u) is too small for device "
303 sdp
->sd_sb
.sb_bsize
, bdev_hardsect_size(sb
->s_bdev
));
306 if (sdp
->sd_sb
.sb_bsize
> PAGE_SIZE
) {
308 fs_err(sdp
, "FS block size (%u) is too big for machine "
310 sdp
->sd_sb
.sb_bsize
, (unsigned int)PAGE_SIZE
);
314 /* Get rid of buffers from the original block size */
315 sb_gh
.gh_gl
->gl_ops
->go_inval(sb_gh
.gh_gl
, DIO_METADATA
| DIO_DATA
);
316 sb_gh
.gh_gl
->gl_aspace
->i_blkbits
= sdp
->sd_sb
.sb_bsize_shift
;
318 sb_set_blocksize(sb
, sdp
->sd_sb
.sb_bsize
);
320 /* Get the root inode */
321 inum
= &sdp
->sd_sb
.sb_root_dir
;
322 if (sb
->s_type
== &gfs2meta_fs_type
)
323 inum
= &sdp
->sd_sb
.sb_master_dir
;
324 inode
= gfs2_lookup_root(sb
, inum
);
326 error
= PTR_ERR(inode
);
327 fs_err(sdp
, "can't read in root inode: %d\n", error
);
331 sb
->s_root
= d_alloc_root(inode
);
333 fs_err(sdp
, "can't get root dentry\n");
337 sb
->s_root
->d_op
= &gfs2_dops
;
339 gfs2_glock_dq_uninit(&sb_gh
);
343 static int init_journal(struct gfs2_sbd
*sdp
, int undo
)
345 struct gfs2_holder ji_gh
;
346 struct task_struct
*p
;
347 struct gfs2_inode
*ip
;
356 sdp
->sd_jindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "jindex");
357 if (IS_ERR(sdp
->sd_jindex
)) {
358 fs_err(sdp
, "can't lookup journal index: %d\n", error
);
359 return PTR_ERR(sdp
->sd_jindex
);
361 ip
= GFS2_I(sdp
->sd_jindex
);
362 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
364 /* Load in the journal index special file */
366 error
= gfs2_jindex_hold(sdp
, &ji_gh
);
368 fs_err(sdp
, "can't read journal index: %d\n", error
);
373 if (!gfs2_jindex_size(sdp
)) {
374 fs_err(sdp
, "no journals!\n");
378 if (sdp
->sd_args
.ar_spectator
) {
379 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, 0);
380 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
382 if (sdp
->sd_lockstruct
.ls_jid
>= gfs2_jindex_size(sdp
)) {
383 fs_err(sdp
, "can't mount journal #%u\n",
384 sdp
->sd_lockstruct
.ls_jid
);
385 fs_err(sdp
, "there are only %u journals (0 - %u)\n",
386 gfs2_jindex_size(sdp
),
387 gfs2_jindex_size(sdp
) - 1);
390 sdp
->sd_jdesc
= gfs2_jdesc_find(sdp
, sdp
->sd_lockstruct
.ls_jid
);
392 error
= gfs2_glock_nq_num(sdp
, sdp
->sd_lockstruct
.ls_jid
,
394 LM_ST_EXCLUSIVE
, LM_FLAG_NOEXP
,
395 &sdp
->sd_journal_gh
);
397 fs_err(sdp
, "can't acquire journal glock: %d\n", error
);
401 ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
402 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
403 LM_FLAG_NOEXP
| GL_EXACT
,
406 fs_err(sdp
, "can't acquire journal inode glock: %d\n",
408 goto fail_journal_gh
;
411 error
= gfs2_jdesc_check(sdp
->sd_jdesc
);
413 fs_err(sdp
, "my journal (%u) is bad: %d\n",
414 sdp
->sd_jdesc
->jd_jid
, error
);
417 sdp
->sd_log_blks_free
= sdp
->sd_jdesc
->jd_blocks
;
420 if (sdp
->sd_lockstruct
.ls_first
) {
422 for (x
= 0; x
< sdp
->sd_journals
; x
++) {
423 error
= gfs2_recover_journal(gfs2_jdesc_find(sdp
, x
));
425 fs_err(sdp
, "error recovering journal %u: %d\n",
431 gfs2_lm_others_may_mount(sdp
);
432 } else if (!sdp
->sd_args
.ar_spectator
) {
433 error
= gfs2_recover_journal(sdp
->sd_jdesc
);
435 fs_err(sdp
, "error recovering my journal: %d\n", error
);
440 set_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
);
441 gfs2_glock_dq_uninit(&ji_gh
);
444 p
= kthread_run(gfs2_recoverd
, sdp
, "gfs2_recoverd");
447 fs_err(sdp
, "can't start recoverd thread: %d\n", error
);
450 sdp
->sd_recoverd_process
= p
;
455 kthread_stop(sdp
->sd_recoverd_process
);
458 if (!sdp
->sd_args
.ar_spectator
)
459 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
462 if (!sdp
->sd_args
.ar_spectator
)
463 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
466 gfs2_jindex_free(sdp
);
468 gfs2_glock_dq_uninit(&ji_gh
);
471 iput(sdp
->sd_jindex
);
477 static int init_inodes(struct gfs2_sbd
*sdp
, int undo
)
480 struct gfs2_inode
*ip
;
486 inode
= gfs2_lookup_root(sdp
->sd_vfs
, &sdp
->sd_sb
.sb_master_dir
);
488 error
= PTR_ERR(inode
);
489 fs_err(sdp
, "can't read in master directory: %d\n", error
);
492 sdp
->sd_master_dir
= inode
;
494 error
= init_journal(sdp
, undo
);
498 /* Read in the master inode number inode */
499 sdp
->sd_inum_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "inum");
500 if (IS_ERR(sdp
->sd_inum_inode
)) {
501 error
= PTR_ERR(sdp
->sd_inum_inode
);
502 fs_err(sdp
, "can't read in inum inode: %d\n", error
);
507 /* Read in the master statfs inode */
508 sdp
->sd_statfs_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "statfs");
509 if (IS_ERR(sdp
->sd_statfs_inode
)) {
510 error
= PTR_ERR(sdp
->sd_statfs_inode
);
511 fs_err(sdp
, "can't read in statfs inode: %d\n", error
);
515 /* Read in the resource index inode */
516 sdp
->sd_rindex
= gfs2_lookup_simple(sdp
->sd_master_dir
, "rindex");
517 if (IS_ERR(sdp
->sd_rindex
)) {
518 error
= PTR_ERR(sdp
->sd_rindex
);
519 fs_err(sdp
, "can't get resource index inode: %d\n", error
);
522 ip
= GFS2_I(sdp
->sd_rindex
);
523 set_bit(GLF_STICKY
, &ip
->i_gl
->gl_flags
);
524 sdp
->sd_rindex_vn
= ip
->i_gl
->gl_vn
- 1;
526 /* Read in the quota inode */
527 sdp
->sd_quota_inode
= gfs2_lookup_simple(sdp
->sd_master_dir
, "quota");
528 if (IS_ERR(sdp
->sd_quota_inode
)) {
529 error
= PTR_ERR(sdp
->sd_quota_inode
);
530 fs_err(sdp
, "can't get quota file inode: %d\n", error
);
536 iput(sdp
->sd_quota_inode
);
539 gfs2_clear_rgrpd(sdp
);
540 iput(sdp
->sd_rindex
);
543 iput(sdp
->sd_statfs_inode
);
546 iput(sdp
->sd_inum_inode
);
548 init_journal(sdp
, UNDO
);
550 iput(sdp
->sd_master_dir
);
555 static int init_per_node(struct gfs2_sbd
*sdp
, int undo
)
557 struct inode
*pn
= NULL
;
560 struct gfs2_inode
*ip
;
562 if (sdp
->sd_args
.ar_spectator
)
568 pn
= gfs2_lookup_simple(sdp
->sd_master_dir
, "per_node");
571 fs_err(sdp
, "can't find per_node directory: %d\n", error
);
575 sprintf(buf
, "inum_range%u", sdp
->sd_jdesc
->jd_jid
);
576 sdp
->sd_ir_inode
= gfs2_lookup_simple(pn
, buf
);
577 if (IS_ERR(sdp
->sd_ir_inode
)) {
578 error
= PTR_ERR(sdp
->sd_ir_inode
);
579 fs_err(sdp
, "can't find local \"ir\" file: %d\n", error
);
583 sprintf(buf
, "statfs_change%u", sdp
->sd_jdesc
->jd_jid
);
584 sdp
->sd_sc_inode
= gfs2_lookup_simple(pn
, buf
);
585 if (IS_ERR(sdp
->sd_sc_inode
)) {
586 error
= PTR_ERR(sdp
->sd_sc_inode
);
587 fs_err(sdp
, "can't find local \"sc\" file: %d\n", error
);
591 sprintf(buf
, "quota_change%u", sdp
->sd_jdesc
->jd_jid
);
592 sdp
->sd_qc_inode
= gfs2_lookup_simple(pn
, buf
);
593 if (IS_ERR(sdp
->sd_qc_inode
)) {
594 error
= PTR_ERR(sdp
->sd_qc_inode
);
595 fs_err(sdp
, "can't find local \"qc\" file: %d\n", error
);
602 ip
= GFS2_I(sdp
->sd_ir_inode
);
603 error
= gfs2_glock_nq_init(ip
->i_gl
,
607 fs_err(sdp
, "can't lock local \"ir\" file: %d\n", error
);
611 ip
= GFS2_I(sdp
->sd_sc_inode
);
612 error
= gfs2_glock_nq_init(ip
->i_gl
,
616 fs_err(sdp
, "can't lock local \"sc\" file: %d\n", error
);
620 ip
= GFS2_I(sdp
->sd_qc_inode
);
621 error
= gfs2_glock_nq_init(ip
->i_gl
,
625 fs_err(sdp
, "can't lock local \"qc\" file: %d\n", error
);
632 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
636 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
639 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
642 iput(sdp
->sd_qc_inode
);
646 iput(sdp
->sd_sc_inode
);
649 iput(sdp
->sd_ir_inode
);
657 static int init_threads(struct gfs2_sbd
*sdp
, int undo
)
659 struct task_struct
*p
;
665 sdp
->sd_log_flush_time
= jiffies
;
666 sdp
->sd_jindex_refresh_time
= jiffies
;
668 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
671 fs_err(sdp
, "can't start logd thread: %d\n", error
);
674 sdp
->sd_logd_process
= p
;
676 sdp
->sd_statfs_sync_time
= jiffies
;
677 sdp
->sd_quota_sync_time
= jiffies
;
679 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
682 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
685 sdp
->sd_quotad_process
= p
;
691 kthread_stop(sdp
->sd_quotad_process
);
693 kthread_stop(sdp
->sd_logd_process
);
698 * fill_super - Read in superblock
699 * @sb: The VFS superblock
700 * @data: Mount options
701 * @silent: Don't complain if it's not a GFS2 filesystem
706 static int fill_super(struct super_block
*sb
, void *data
, int silent
)
708 struct gfs2_sbd
*sdp
;
709 struct gfs2_holder mount_gh
;
714 printk(KERN_WARNING
"GFS2: can't alloc struct gfs2_sbd\n");
718 error
= gfs2_mount_args(sdp
, (char *)data
, 0);
720 printk(KERN_WARNING
"GFS2: can't parse mount arguments\n");
724 init_vfs(sb
, SDF_NOATIME
);
726 /* Set up the buffer cache and fill in some fake block size values
727 to allow us to read-in the on-disk superblock. */
728 sdp
->sd_sb
.sb_bsize
= sb_min_blocksize(sb
, GFS2_BASIC_BLOCK
);
729 sdp
->sd_sb
.sb_bsize_shift
= sb
->s_blocksize_bits
;
730 sdp
->sd_fsb2bb_shift
= sdp
->sd_sb
.sb_bsize_shift
-
731 GFS2_BASIC_BLOCK_SHIFT
;
732 sdp
->sd_fsb2bb
= 1 << sdp
->sd_fsb2bb_shift
;
734 error
= init_names(sdp
, silent
);
738 error
= gfs2_sys_fs_add(sdp
);
742 error
= gfs2_lm_mount(sdp
, silent
);
746 error
= init_locking(sdp
, &mount_gh
, DO
);
750 error
= init_sb(sdp
, silent
, DO
);
754 error
= init_inodes(sdp
, DO
);
758 error
= init_per_node(sdp
, DO
);
762 error
= gfs2_statfs_init(sdp
);
764 fs_err(sdp
, "can't initialize statfs subsystem: %d\n", error
);
768 error
= init_threads(sdp
, DO
);
772 if (!(sb
->s_flags
& MS_RDONLY
)) {
773 error
= gfs2_make_fs_rw(sdp
);
775 fs_err(sdp
, "can't make FS RW: %d\n", error
);
780 gfs2_glock_dq_uninit(&mount_gh
);
785 init_threads(sdp
, UNDO
);
788 init_per_node(sdp
, UNDO
);
791 init_inodes(sdp
, UNDO
);
794 init_sb(sdp
, 0, UNDO
);
797 init_locking(sdp
, &mount_gh
, UNDO
);
800 gfs2_gl_hash_clear(sdp
, WAIT
);
801 gfs2_lm_unmount(sdp
);
802 while (invalidate_inodes(sb
))
806 gfs2_sys_fs_del(sdp
);
810 sb
->s_fs_info
= NULL
;
815 static int gfs2_get_sb(struct file_system_type
*fs_type
, int flags
,
816 const char *dev_name
, void *data
, struct vfsmount
*mnt
)
818 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, fill_super
, mnt
);
821 static void gfs2_kill_sb(struct super_block
*sb
)
823 kill_block_super(sb
);
826 struct file_system_type gfs2_fs_type
= {
828 .fs_flags
= FS_REQUIRES_DEV
,
829 .get_sb
= gfs2_get_sb
,
830 .kill_sb
= gfs2_kill_sb
,
831 .owner
= THIS_MODULE
,
834 struct file_system_type gfs2meta_fs_type
= {
836 .fs_flags
= FS_REQUIRES_DEV
,
837 .get_sb
= gfs2_get_sb
,
838 .kill_sb
= gfs2_kill_sb
,
839 .owner
= THIS_MODULE
,