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/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 <linux/crc32.h>
25 #include "lm_interface.h"
32 #include "ops_super.h"
46 * gfs2_write_inode - Make sure the inode is stable on the disk
48 * @sync: synchronous write flag
53 static int gfs2_write_inode(struct inode
*inode
, int sync
)
55 struct gfs2_inode
*ip
= GFS2_I(inode
);
57 /* Check this is a "normal" inode */
58 if (inode
->u
.generic_ip
) {
59 if (current
->flags
& PF_MEMALLOC
)
62 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
);
69 * gfs2_put_super - Unmount the filesystem
70 * @sb: The VFS superblock
74 static void gfs2_put_super(struct super_block
*sb
)
76 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
82 /* Unfreeze the filesystem, if we need to */
84 mutex_lock(&sdp
->sd_freeze_lock
);
85 if (sdp
->sd_freeze_count
)
86 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
87 mutex_unlock(&sdp
->sd_freeze_lock
);
89 kthread_stop(sdp
->sd_quotad_process
);
90 kthread_stop(sdp
->sd_logd_process
);
91 kthread_stop(sdp
->sd_recoverd_process
);
92 while (sdp
->sd_glockd_num
--)
93 kthread_stop(sdp
->sd_glockd_process
[sdp
->sd_glockd_num
]);
94 kthread_stop(sdp
->sd_scand_process
);
96 if (!(sb
->s_flags
& MS_RDONLY
)) {
97 error
= gfs2_make_fs_ro(sdp
);
101 /* At this point, we're through modifying the disk */
105 iput(sdp
->sd_master_dir
);
106 iput(sdp
->sd_jindex
);
107 iput(sdp
->sd_inum_inode
);
108 iput(sdp
->sd_statfs_inode
);
109 iput(sdp
->sd_rindex
);
110 iput(sdp
->sd_quota_inode
);
112 gfs2_glock_put(sdp
->sd_rename_gl
);
113 gfs2_glock_put(sdp
->sd_trans_gl
);
115 if (!sdp
->sd_args
.ar_spectator
) {
116 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
117 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
118 gfs2_glock_dq_uninit(&sdp
->sd_ir_gh
);
119 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
120 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
121 iput(sdp
->sd_ir_inode
);
122 iput(sdp
->sd_sc_inode
);
123 iput(sdp
->sd_qc_inode
);
126 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
127 gfs2_clear_rgrpd(sdp
);
128 gfs2_jindex_free(sdp
);
129 /* Take apart glock structures and buffer lists */
130 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 */
135 gfs2_sys_fs_del(sdp
);
137 sb
->s_fs_info
= NULL
;
141 * gfs2_write_super - disk commit all incore transactions
142 * @sb: the filesystem
144 * This function is called every time sync(2) is called.
145 * After this exits, all dirty buffers are synced.
148 static void gfs2_write_super(struct super_block
*sb
)
150 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
151 gfs2_log_flush(sdp
, NULL
);
155 * gfs2_write_super_lockfs - prevent further writes to the filesystem
156 * @sb: the VFS structure for the filesystem
160 static void gfs2_write_super_lockfs(struct super_block
*sb
)
162 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
166 error
= gfs2_freeze_fs(sdp
);
172 fs_err(sdp
, "waiting for recovery before freeze\n");
176 fs_err(sdp
, "error freezing FS: %d\n", error
);
180 fs_err(sdp
, "retrying...\n");
186 * gfs2_unlockfs - reallow writes to the filesystem
187 * @sb: the VFS structure for the filesystem
191 static void gfs2_unlockfs(struct super_block
*sb
)
193 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
194 gfs2_unfreeze_fs(sdp
);
198 * gfs2_statfs - Gather and return stats about the filesystem
199 * @sb: The superblock
200 * @statfsbuf: The buffer
202 * Returns: 0 on success or error code
205 static int gfs2_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
207 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
208 struct gfs2_statfs_change sc
;
211 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
212 error
= gfs2_statfs_slow(sdp
, &sc
);
214 error
= gfs2_statfs_i(sdp
, &sc
);
219 memset(buf
, 0, sizeof(struct kstatfs
));
221 buf
->f_type
= GFS2_MAGIC
;
222 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
223 buf
->f_blocks
= sc
.sc_total
;
224 buf
->f_bfree
= sc
.sc_free
;
225 buf
->f_bavail
= sc
.sc_free
;
226 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
227 buf
->f_ffree
= sc
.sc_free
;
228 buf
->f_namelen
= GFS2_FNAMESIZE
;
234 * gfs2_remount_fs - called when the FS is remounted
235 * @sb: the filesystem
236 * @flags: the remount flags
237 * @data: extra data passed in (not used right now)
242 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
244 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
247 error
= gfs2_mount_args(sdp
, data
, 1);
251 if (sdp
->sd_args
.ar_spectator
)
254 if (*flags
& MS_RDONLY
) {
255 if (!(sb
->s_flags
& MS_RDONLY
))
256 error
= gfs2_make_fs_ro(sdp
);
257 } else if (!(*flags
& MS_RDONLY
) &&
258 (sb
->s_flags
& MS_RDONLY
)) {
259 error
= gfs2_make_fs_rw(sdp
);
263 if (*flags
& (MS_NOATIME
| MS_NODIRATIME
))
264 set_bit(SDF_NOATIME
, &sdp
->sd_flags
);
266 clear_bit(SDF_NOATIME
, &sdp
->sd_flags
);
268 /* Don't let the VFS update atimes. GFS2 handles this itself. */
269 *flags
|= MS_NOATIME
| MS_NODIRATIME
;
275 * gfs2_clear_inode - Deallocate an inode when VFS is done with it
276 * @inode: The VFS inode
280 static void gfs2_clear_inode(struct inode
*inode
)
282 /* This tells us its a "real" inode and not one which only
283 * serves to contain an address space (see rgrp.c, meta_io.c)
284 * which therefore doesn't have its own glocks.
286 if (inode
->u
.generic_ip
) {
287 struct gfs2_inode
*ip
= GFS2_I(inode
);
288 gfs2_glock_inode_squish(inode
);
289 gfs2_assert(inode
->i_sb
->s_fs_info
, ip
->i_gl
->gl_state
== LM_ST_UNLOCKED
);
290 ip
->i_gl
->gl_object
= NULL
;
291 gfs2_glock_schedule_for_reclaim(ip
->i_gl
);
292 gfs2_glock_put(ip
->i_gl
);
294 if (ip
->i_iopen_gh
.gh_gl
)
295 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
300 * gfs2_show_options - Show mount options for /proc/mounts
301 * @s: seq_file structure
304 * Returns: 0 on success or error code
307 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
309 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
310 struct gfs2_args
*args
= &sdp
->sd_args
;
312 if (args
->ar_lockproto
[0])
313 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
314 if (args
->ar_locktable
[0])
315 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
316 if (args
->ar_hostdata
[0])
317 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
318 if (args
->ar_spectator
)
319 seq_printf(s
, ",spectator");
320 if (args
->ar_ignore_local_fs
)
321 seq_printf(s
, ",ignore_local_fs");
322 if (args
->ar_localflocks
)
323 seq_printf(s
, ",localflocks");
324 if (args
->ar_localcaching
)
325 seq_printf(s
, ",localcaching");
327 seq_printf(s
, ",debug");
328 if (args
->ar_upgrade
)
329 seq_printf(s
, ",upgrade");
330 if (args
->ar_num_glockd
!= GFS2_GLOCKD_DEFAULT
)
331 seq_printf(s
, ",num_glockd=%u", args
->ar_num_glockd
);
332 if (args
->ar_posix_acl
)
333 seq_printf(s
, ",acl");
334 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
336 switch (args
->ar_quota
) {
340 case GFS2_QUOTA_ACCOUNT
:
350 seq_printf(s
, ",quota=%s", state
);
352 if (args
->ar_suiddir
)
353 seq_printf(s
, ",suiddir");
354 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
356 switch (args
->ar_data
) {
357 case GFS2_DATA_WRITEBACK
:
360 case GFS2_DATA_ORDERED
:
367 seq_printf(s
, ",data=%s", state
);
374 * We have to (at the moment) hold the inodes main lock to cover
375 * the gap between unlocking the shared lock on the iopen lock and
376 * taking the exclusive lock. I'd rather do a shared -> exclusive
377 * conversion on the iopen lock, but we can change that later. This
378 * is safe, just less efficient.
380 static void gfs2_delete_inode(struct inode
*inode
)
382 struct gfs2_sbd
*sdp
= inode
->i_sb
->s_fs_info
;
383 struct gfs2_inode
*ip
= GFS2_I(inode
);
384 struct gfs2_holder gh
;
387 if (!inode
->u
.generic_ip
)
390 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, &gh
);
391 if (unlikely(error
)) {
392 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
396 gfs2_glock_dq(&ip
->i_iopen_gh
);
397 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, &ip
->i_iopen_gh
);
398 error
= gfs2_glock_nq(&ip
->i_iopen_gh
);
402 if (S_ISDIR(ip
->i_di
.di_mode
) &&
403 (ip
->i_di
.di_flags
& GFS2_DIF_EXHASH
)) {
404 error
= gfs2_dir_exhash_dealloc(ip
);
409 if (ip
->i_di
.di_eattr
) {
410 error
= gfs2_ea_dealloc(ip
);
415 if (!gfs2_is_stuffed(ip
)) {
416 error
= gfs2_file_dealloc(ip
);
421 error
= gfs2_dinode_dealloc(ip
);
424 gfs2_glock_dq(&ip
->i_iopen_gh
);
426 gfs2_holder_uninit(&ip
->i_iopen_gh
);
427 gfs2_glock_dq_uninit(&gh
);
429 fs_warn(sdp
, "gfs2_delete_inode: %d\n", error
);
431 truncate_inode_pages(&inode
->i_data
, 0);
437 static struct inode
*gfs2_alloc_inode(struct super_block
*sb
)
439 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
440 struct gfs2_inode
*ip
;
442 ip
= kmem_cache_alloc(gfs2_inode_cachep
, GFP_KERNEL
);
446 ip
->i_greedy
= gfs2_tune_get(sdp
, gt_greedy_default
);
447 ip
->i_last_pfault
= jiffies
;
452 static void gfs2_destroy_inode(struct inode
*inode
)
454 kmem_cache_free(gfs2_inode_cachep
, inode
);
457 struct super_operations gfs2_super_ops
= {
458 .alloc_inode
= gfs2_alloc_inode
,
459 .destroy_inode
= gfs2_destroy_inode
,
460 .write_inode
= gfs2_write_inode
,
461 .delete_inode
= gfs2_delete_inode
,
462 .put_super
= gfs2_put_super
,
463 .write_super
= gfs2_write_super
,
464 .write_super_lockfs
= gfs2_write_super_lockfs
,
465 .unlockfs
= gfs2_unlockfs
,
466 .statfs
= gfs2_statfs
,
467 .remount_fs
= gfs2_remount_fs
,
468 .clear_inode
= gfs2_clear_inode
,
469 .show_options
= gfs2_show_options
,