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/statfs.h>
16 #include <linux/vmalloc.h>
17 #include <linux/seq_file.h>
18 #include <linux/mount.h>
19 #include <linux/kthread.h>
20 #include <linux/delay.h>
21 #include <linux/gfs2_ondisk.h>
22 #include <asm/semaphore.h>
25 #include "lm_interface.h"
32 #include "ops_super.h"
42 * gfs2_write_inode - Make sure the inode is stable on the disk
44 * @sync: synchronous write flag
49 static int gfs2_write_inode(struct inode
*inode
, int sync
)
51 struct gfs2_inode
*ip
= inode
->u
.generic_ip
;
53 if (current
->flags
& PF_MEMALLOC
)
56 gfs2_log_flush_glock(ip
->i_gl
);
62 * gfs2_put_super - Unmount the filesystem
63 * @sb: The VFS superblock
67 static void gfs2_put_super(struct super_block
*sb
)
69 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
75 /* Unfreeze the filesystem, if we need to */
77 mutex_lock(&sdp
->sd_freeze_lock
);
78 if (sdp
->sd_freeze_count
)
79 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
80 mutex_unlock(&sdp
->sd_freeze_lock
);
82 kthread_stop(sdp
->sd_inoded_process
);
83 kthread_stop(sdp
->sd_quotad_process
);
84 kthread_stop(sdp
->sd_logd_process
);
85 kthread_stop(sdp
->sd_recoverd_process
);
86 while (sdp
->sd_glockd_num
--)
87 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
88 kthread_stop(sdp
->sd_scand_process
);
90 if (!(sb
->s_flags
& MS_RDONLY
)) {
91 error
= gfs2_make_fs_ro(sdp
);
96 /* At this point, we're through modifying the disk */
100 iput(sdp
->sd_master_dir
);
101 iput(sdp
->sd_jindex
);
102 iput(sdp
->sd_inum_inode
);
103 iput(sdp
->sd_statfs_inode
);
104 iput(sdp
->sd_rindex
);
105 iput(sdp
->sd_quota_inode
);
106 iput(sdp
->sd_root_dir
);
108 gfs2_glock_put(sdp
->sd_rename_gl
);
109 gfs2_glock_put(sdp
->sd_trans_gl
);
111 if (!sdp
->sd_args
.ar_spectator
) {
112 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
113 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
114 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
115 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
116 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
117 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
118 iput(sdp
->sd_ir_inode
);
119 iput(sdp
->sd_sc_inode
);
120 iput(sdp
->sd_ut_inode
);
121 iput(sdp
->sd_qc_inode
);
124 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
126 gfs2_clear_rgrpd(sdp
);
127 gfs2_jindex_free(sdp
);
129 /* Take apart glock structures and buffer lists */
130 gfs2_gl_hash_clear(sdp
, WAIT
);
132 /* Unmount the locking protocol */
133 gfs2_lm_unmount(sdp
);
135 /* At this point, we're through participating in the lockspace */
137 gfs2_sys_fs_del(sdp
);
139 /* Get rid of any extra inodes */
140 while (invalidate_inodes(sb
))
145 sb
->s_fs_info
= NULL
;
149 * gfs2_write_super - disk commit all incore transactions
150 * @sb: the filesystem
152 * This function is called every time sync(2) is called.
153 * After this exits, all dirty buffers and synced.
156 static void gfs2_write_super(struct super_block
*sb
)
158 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
163 * gfs2_write_super_lockfs - prevent further writes to the filesystem
164 * @sb: the VFS structure for the filesystem
168 static void gfs2_write_super_lockfs(struct super_block
*sb
)
170 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
174 error
= gfs2_freeze_fs(sdp
);
180 fs_err(sdp
, "waiting for recovery before freeze\n");
184 fs_err(sdp
, "error freezing FS: %d\n", error
);
188 fs_err(sdp
, "retrying...\n");
194 * gfs2_unlockfs - reallow writes to the filesystem
195 * @sb: the VFS structure for the filesystem
199 static void gfs2_unlockfs(struct super_block
*sb
)
201 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
202 gfs2_unfreeze_fs(sdp
);
206 * gfs2_statfs - Gather and return stats about the filesystem
207 * @sb: The superblock
208 * @statfsbuf: The buffer
210 * Returns: 0 on success or error code
213 static int gfs2_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
215 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
216 struct gfs2_statfs_change sc
;
219 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
220 error
= gfs2_statfs_slow(sdp
, &sc
);
222 error
= gfs2_statfs_i(sdp
, &sc
);
227 memset(buf
, 0, sizeof(struct kstatfs
));
229 buf
->f_type
= GFS2_MAGIC
;
230 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
231 buf
->f_blocks
= sc
.sc_total
;
232 buf
->f_bfree
= sc
.sc_free
;
233 buf
->f_bavail
= sc
.sc_free
;
234 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
235 buf
->f_ffree
= sc
.sc_free
;
236 buf
->f_namelen
= GFS2_FNAMESIZE
;
242 * gfs2_remount_fs - called when the FS is remounted
243 * @sb: the filesystem
244 * @flags: the remount flags
245 * @data: extra data passed in (not used right now)
250 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
252 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
255 error
= gfs2_mount_args(sdp
, data
, 1);
259 if (sdp
->sd_args
.ar_spectator
)
262 if (*flags
& MS_RDONLY
) {
263 if (!(sb
->s_flags
& MS_RDONLY
))
264 error
= gfs2_make_fs_ro(sdp
);
265 } else if (!(*flags
& MS_RDONLY
) &&
266 (sb
->s_flags
& MS_RDONLY
)) {
267 error
= gfs2_make_fs_rw(sdp
);
271 if (*flags
& (MS_NOATIME
| MS_NODIRATIME
))
272 set_bit(SDF_NOATIME
, &sdp
->sd_flags
);
274 clear_bit(SDF_NOATIME
, &sdp
->sd_flags
);
276 /* Don't let the VFS update atimes. GFS2 handles this itself. */
277 *flags
|= MS_NOATIME
| MS_NODIRATIME
;
283 * gfs2_clear_inode - Deallocate an inode when VFS is done with it
284 * @inode: The VFS inode
288 static void gfs2_clear_inode(struct inode
*inode
)
290 struct gfs2_inode
*ip
= inode
->u
.generic_ip
;
293 spin_lock(&ip
->i_spin
);
295 inode
->u
.generic_ip
= NULL
;
296 spin_unlock(&ip
->i_spin
);
298 gfs2_glock_schedule_for_reclaim(ip
->i_gl
);
304 * gfs2_show_options - Show mount options for /proc/mounts
305 * @s: seq_file structure
308 * Returns: 0 on success or error code
311 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
313 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
314 struct gfs2_args
*args
= &sdp
->sd_args
;
316 if (args
->ar_lockproto
[0])
317 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
318 if (args
->ar_locktable
[0])
319 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
320 if (args
->ar_hostdata
[0])
321 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
322 if (args
->ar_spectator
)
323 seq_printf(s
, ",spectator");
324 if (args
->ar_ignore_local_fs
)
325 seq_printf(s
, ",ignore_local_fs");
326 if (args
->ar_localflocks
)
327 seq_printf(s
, ",localflocks");
328 if (args
->ar_localcaching
)
329 seq_printf(s
, ",localcaching");
331 seq_printf(s
, ",debug");
332 if (args
->ar_upgrade
)
333 seq_printf(s
, ",upgrade");
334 if (args
->ar_num_glockd
!= GFS2_GLOCKD_DEFAULT
)
335 seq_printf(s
, ",num_glockd=%u", args
->ar_num_glockd
);
336 if (args
->ar_posix_acl
)
337 seq_printf(s
, ",acl");
338 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
340 switch (args
->ar_quota
) {
344 case GFS2_QUOTA_ACCOUNT
:
354 seq_printf(s
, ",quota=%s", state
);
356 if (args
->ar_suiddir
)
357 seq_printf(s
, ",suiddir");
358 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
360 switch (args
->ar_data
) {
361 case GFS2_DATA_WRITEBACK
:
364 case GFS2_DATA_ORDERED
:
371 seq_printf(s
, ",data=%s", state
);
377 struct super_operations gfs2_super_ops
= {
378 .write_inode
= gfs2_write_inode
,
379 .put_super
= gfs2_put_super
,
380 .write_super
= gfs2_write_super
,
381 .write_super_lockfs
= gfs2_write_super_lockfs
,
382 .unlockfs
= gfs2_unlockfs
,
383 .statfs
= gfs2_statfs
,
384 .remount_fs
= gfs2_remount_fs
,
385 .clear_inode
= gfs2_clear_inode
,
386 .show_options
= gfs2_show_options
,