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
);
107 gfs2_glock_put(sdp
->sd_rename_gl
);
108 gfs2_glock_put(sdp
->sd_trans_gl
);
110 if (!sdp
->sd_args
.ar_spectator
) {
111 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
112 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
113 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
114 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
115 gfs2_glock_dq_uninit(&sdp
->sd_ut_gh
);
116 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
117 iput(sdp
->sd_ir_inode
);
118 iput(sdp
->sd_sc_inode
);
119 iput(sdp
->sd_ut_inode
);
120 iput(sdp
->sd_qc_inode
);
123 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
125 gfs2_clear_rgrpd(sdp
);
126 gfs2_jindex_free(sdp
);
128 /* Take apart glock structures and buffer lists */
129 gfs2_gl_hash_clear(sdp
, WAIT
);
131 /* Unmount the locking protocol */
132 gfs2_lm_unmount(sdp
);
134 /* At this point, we're through participating in the lockspace */
136 gfs2_sys_fs_del(sdp
);
138 /* Get rid of any extra inodes */
139 while (invalidate_inodes(sb
))
144 sb
->s_fs_info
= NULL
;
148 * gfs2_write_super - disk commit all incore transactions
149 * @sb: the filesystem
151 * This function is called every time sync(2) is called.
152 * After this exits, all dirty buffers and synced.
155 static void gfs2_write_super(struct super_block
*sb
)
157 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
162 * gfs2_write_super_lockfs - prevent further writes to the filesystem
163 * @sb: the VFS structure for the filesystem
167 static void gfs2_write_super_lockfs(struct super_block
*sb
)
169 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
173 error
= gfs2_freeze_fs(sdp
);
179 fs_err(sdp
, "waiting for recovery before freeze\n");
183 fs_err(sdp
, "error freezing FS: %d\n", error
);
187 fs_err(sdp
, "retrying...\n");
193 * gfs2_unlockfs - reallow writes to the filesystem
194 * @sb: the VFS structure for the filesystem
198 static void gfs2_unlockfs(struct super_block
*sb
)
200 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
201 gfs2_unfreeze_fs(sdp
);
205 * gfs2_statfs - Gather and return stats about the filesystem
206 * @sb: The superblock
207 * @statfsbuf: The buffer
209 * Returns: 0 on success or error code
212 static int gfs2_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
214 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
215 struct gfs2_statfs_change sc
;
218 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
219 error
= gfs2_statfs_slow(sdp
, &sc
);
221 error
= gfs2_statfs_i(sdp
, &sc
);
226 memset(buf
, 0, sizeof(struct kstatfs
));
228 buf
->f_type
= GFS2_MAGIC
;
229 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
230 buf
->f_blocks
= sc
.sc_total
;
231 buf
->f_bfree
= sc
.sc_free
;
232 buf
->f_bavail
= sc
.sc_free
;
233 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
234 buf
->f_ffree
= sc
.sc_free
;
235 buf
->f_namelen
= GFS2_FNAMESIZE
;
241 * gfs2_remount_fs - called when the FS is remounted
242 * @sb: the filesystem
243 * @flags: the remount flags
244 * @data: extra data passed in (not used right now)
249 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
251 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
254 error
= gfs2_mount_args(sdp
, data
, 1);
258 if (sdp
->sd_args
.ar_spectator
)
261 if (*flags
& MS_RDONLY
) {
262 if (!(sb
->s_flags
& MS_RDONLY
))
263 error
= gfs2_make_fs_ro(sdp
);
264 } else if (!(*flags
& MS_RDONLY
) &&
265 (sb
->s_flags
& MS_RDONLY
)) {
266 error
= gfs2_make_fs_rw(sdp
);
270 if (*flags
& (MS_NOATIME
| MS_NODIRATIME
))
271 set_bit(SDF_NOATIME
, &sdp
->sd_flags
);
273 clear_bit(SDF_NOATIME
, &sdp
->sd_flags
);
275 /* Don't let the VFS update atimes. GFS2 handles this itself. */
276 *flags
|= MS_NOATIME
| MS_NODIRATIME
;
282 * gfs2_clear_inode - Deallocate an inode when VFS is done with it
283 * @inode: The VFS inode
287 static void gfs2_clear_inode(struct inode
*inode
)
289 struct gfs2_inode
*ip
= inode
->u
.generic_ip
;
292 spin_lock(&ip
->i_spin
);
294 inode
->u
.generic_ip
= NULL
;
295 spin_unlock(&ip
->i_spin
);
297 gfs2_glock_schedule_for_reclaim(ip
->i_gl
);
303 * gfs2_show_options - Show mount options for /proc/mounts
304 * @s: seq_file structure
307 * Returns: 0 on success or error code
310 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
312 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
313 struct gfs2_args
*args
= &sdp
->sd_args
;
315 if (args
->ar_lockproto
[0])
316 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
317 if (args
->ar_locktable
[0])
318 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
319 if (args
->ar_hostdata
[0])
320 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
321 if (args
->ar_spectator
)
322 seq_printf(s
, ",spectator");
323 if (args
->ar_ignore_local_fs
)
324 seq_printf(s
, ",ignore_local_fs");
325 if (args
->ar_localflocks
)
326 seq_printf(s
, ",localflocks");
327 if (args
->ar_localcaching
)
328 seq_printf(s
, ",localcaching");
330 seq_printf(s
, ",debug");
331 if (args
->ar_upgrade
)
332 seq_printf(s
, ",upgrade");
333 if (args
->ar_num_glockd
!= GFS2_GLOCKD_DEFAULT
)
334 seq_printf(s
, ",num_glockd=%u", args
->ar_num_glockd
);
335 if (args
->ar_posix_acl
)
336 seq_printf(s
, ",acl");
337 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
339 switch (args
->ar_quota
) {
343 case GFS2_QUOTA_ACCOUNT
:
353 seq_printf(s
, ",quota=%s", state
);
355 if (args
->ar_suiddir
)
356 seq_printf(s
, ",suiddir");
357 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
359 switch (args
->ar_data
) {
360 case GFS2_DATA_WRITEBACK
:
363 case GFS2_DATA_ORDERED
:
370 seq_printf(s
, ",data=%s", state
);
376 struct super_operations gfs2_super_ops
= {
377 .write_inode
= gfs2_write_inode
,
378 .put_super
= gfs2_put_super
,
379 .write_super
= gfs2_write_super
,
380 .write_super_lockfs
= gfs2_write_super_lockfs
,
381 .unlockfs
= gfs2_unlockfs
,
382 .statfs
= gfs2_statfs
,
383 .remount_fs
= gfs2_remount_fs
,
384 .clear_inode
= gfs2_clear_inode
,
385 .show_options
= gfs2_show_options
,