2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2007 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 version 2.
10 #include <linux/bio.h>
11 #include <linux/sched.h>
12 #include <linux/slab.h>
13 #include <linux/spinlock.h>
14 #include <linux/completion.h>
15 #include <linux/buffer_head.h>
16 #include <linux/statfs.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>
23 #include <linux/time.h>
24 #include <linux/wait.h>
25 #include <linux/writeback.h>
26 #include <linux/backing-dev.h>
46 #define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)
84 static const match_table_t tokens
= {
85 {Opt_lockproto
, "lockproto=%s"},
86 {Opt_locktable
, "locktable=%s"},
87 {Opt_hostdata
, "hostdata=%s"},
88 {Opt_spectator
, "spectator"},
89 {Opt_spectator
, "norecovery"},
90 {Opt_ignore_local_fs
, "ignore_local_fs"},
91 {Opt_localflocks
, "localflocks"},
92 {Opt_localcaching
, "localcaching"},
94 {Opt_nodebug
, "nodebug"},
95 {Opt_upgrade
, "upgrade"},
98 {Opt_quota_off
, "quota=off"},
99 {Opt_quota_account
, "quota=account"},
100 {Opt_quota_on
, "quota=on"},
101 {Opt_quota
, "quota"},
102 {Opt_noquota
, "noquota"},
103 {Opt_suiddir
, "suiddir"},
104 {Opt_nosuiddir
, "nosuiddir"},
105 {Opt_data_writeback
, "data=writeback"},
106 {Opt_data_ordered
, "data=ordered"},
108 {Opt_discard
, "discard"},
109 {Opt_nodiscard
, "nodiscard"},
110 {Opt_commit
, "commit=%d"},
111 {Opt_err_withdraw
, "errors=withdraw"},
112 {Opt_err_panic
, "errors=panic"},
113 {Opt_statfs_quantum
, "statfs_quantum=%d"},
114 {Opt_statfs_percent
, "statfs_percent=%d"},
115 {Opt_quota_quantum
, "quota_quantum=%d"},
116 {Opt_barrier
, "barrier"},
117 {Opt_nobarrier
, "nobarrier"},
122 * gfs2_mount_args - Parse mount options
123 * @args: The structure into which the parsed options will be written
124 * @options: The options to parse
129 int gfs2_mount_args(struct gfs2_args
*args
, char *options
)
133 substring_t tmp
[MAX_OPT_ARGS
];
136 /* Split the options into tokens with the "," character and
140 o
= strsep(&options
, ",");
146 token
= match_token(o
, tokens
, tmp
);
149 match_strlcpy(args
->ar_lockproto
, &tmp
[0],
153 match_strlcpy(args
->ar_locktable
, &tmp
[0],
157 match_strlcpy(args
->ar_hostdata
, &tmp
[0],
161 args
->ar_spectator
= 1;
163 case Opt_ignore_local_fs
:
164 /* Retained for backwards compat only */
166 case Opt_localflocks
:
167 args
->ar_localflocks
= 1;
169 case Opt_localcaching
:
170 /* Retained for backwards compat only */
173 if (args
->ar_errors
== GFS2_ERRORS_PANIC
) {
174 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
175 "are mutually exclusive.\n");
184 /* Retained for backwards compat only */
187 args
->ar_posix_acl
= 1;
190 args
->ar_posix_acl
= 0;
194 args
->ar_quota
= GFS2_QUOTA_OFF
;
196 case Opt_quota_account
:
197 args
->ar_quota
= GFS2_QUOTA_ACCOUNT
;
201 args
->ar_quota
= GFS2_QUOTA_ON
;
204 args
->ar_suiddir
= 1;
207 args
->ar_suiddir
= 0;
209 case Opt_data_writeback
:
210 args
->ar_data
= GFS2_DATA_WRITEBACK
;
212 case Opt_data_ordered
:
213 args
->ar_data
= GFS2_DATA_ORDERED
;
219 args
->ar_discard
= 1;
222 args
->ar_discard
= 0;
225 rv
= match_int(&tmp
[0], &args
->ar_commit
);
226 if (rv
|| args
->ar_commit
<= 0) {
227 printk(KERN_WARNING
"GFS2: commit mount option requires a positive numeric argument\n");
228 return rv
? rv
: -EINVAL
;
231 case Opt_statfs_quantum
:
232 rv
= match_int(&tmp
[0], &args
->ar_statfs_quantum
);
233 if (rv
|| args
->ar_statfs_quantum
< 0) {
234 printk(KERN_WARNING
"GFS2: statfs_quantum mount option requires a non-negative numeric argument\n");
235 return rv
? rv
: -EINVAL
;
238 case Opt_quota_quantum
:
239 rv
= match_int(&tmp
[0], &args
->ar_quota_quantum
);
240 if (rv
|| args
->ar_quota_quantum
<= 0) {
241 printk(KERN_WARNING
"GFS2: quota_quantum mount option requires a positive numeric argument\n");
242 return rv
? rv
: -EINVAL
;
245 case Opt_statfs_percent
:
246 rv
= match_int(&tmp
[0], &args
->ar_statfs_percent
);
247 if (rv
|| args
->ar_statfs_percent
< 0 ||
248 args
->ar_statfs_percent
> 100) {
249 printk(KERN_WARNING
"statfs_percent mount option requires a numeric argument between 0 and 100\n");
250 return rv
? rv
: -EINVAL
;
253 case Opt_err_withdraw
:
254 args
->ar_errors
= GFS2_ERRORS_WITHDRAW
;
257 if (args
->ar_debug
) {
258 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
259 "are mutually exclusive.\n");
262 args
->ar_errors
= GFS2_ERRORS_PANIC
;
265 args
->ar_nobarrier
= 0;
268 args
->ar_nobarrier
= 1;
272 printk(KERN_WARNING
"GFS2: invalid mount option: %s\n", o
);
281 * gfs2_jindex_free - Clear all the journal index information
282 * @sdp: The GFS2 superblock
286 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
288 struct list_head list
, *head
;
289 struct gfs2_jdesc
*jd
;
290 struct gfs2_journal_extent
*jext
;
292 spin_lock(&sdp
->sd_jindex_spin
);
293 list_add(&list
, &sdp
->sd_jindex_list
);
294 list_del_init(&sdp
->sd_jindex_list
);
295 sdp
->sd_journals
= 0;
296 spin_unlock(&sdp
->sd_jindex_spin
);
298 while (!list_empty(&list
)) {
299 jd
= list_entry(list
.next
, struct gfs2_jdesc
, jd_list
);
300 head
= &jd
->extent_list
;
301 while (!list_empty(head
)) {
302 jext
= list_entry(head
->next
,
303 struct gfs2_journal_extent
,
305 list_del(&jext
->extent_list
);
308 list_del(&jd
->jd_list
);
314 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
316 struct gfs2_jdesc
*jd
;
319 list_for_each_entry(jd
, head
, jd_list
) {
320 if (jd
->jd_jid
== jid
) {
332 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
334 struct gfs2_jdesc
*jd
;
336 spin_lock(&sdp
->sd_jindex_spin
);
337 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
338 spin_unlock(&sdp
->sd_jindex_spin
);
343 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
345 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
346 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
347 u64 size
= i_size_read(jd
->jd_inode
);
349 if (gfs2_check_internal_file_size(jd
->jd_inode
, 8 << 20, 1 << 30))
352 jd
->jd_blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
354 if (gfs2_write_alloc_required(ip
, 0, size
)) {
355 gfs2_consist_inode(ip
);
363 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
364 * @sdp: the filesystem
369 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
371 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
372 struct gfs2_glock
*j_gl
= ip
->i_gl
;
373 struct gfs2_holder t_gh
;
374 struct gfs2_log_header_host head
;
377 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, 0, &t_gh
);
381 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
383 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
387 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
393 /* Initialize some head of the log stuff */
394 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
395 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
397 error
= gfs2_quota_init(sdp
);
401 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
403 gfs2_glock_dq_uninit(&t_gh
);
408 t_gh
.gh_flags
|= GL_NOCACHE
;
409 gfs2_glock_dq_uninit(&t_gh
);
414 void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
416 const struct gfs2_statfs_change
*str
= buf
;
418 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
419 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
420 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
423 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
425 struct gfs2_statfs_change
*str
= buf
;
427 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
428 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
429 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
432 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
434 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
435 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
436 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
437 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
438 struct buffer_head
*m_bh
, *l_bh
;
439 struct gfs2_holder gh
;
442 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
447 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
451 if (sdp
->sd_args
.ar_spectator
) {
452 spin_lock(&sdp
->sd_statfs_spin
);
453 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
454 sizeof(struct gfs2_dinode
));
455 spin_unlock(&sdp
->sd_statfs_spin
);
457 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
461 spin_lock(&sdp
->sd_statfs_spin
);
462 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
463 sizeof(struct gfs2_dinode
));
464 gfs2_statfs_change_in(l_sc
, l_bh
->b_data
+
465 sizeof(struct gfs2_dinode
));
466 spin_unlock(&sdp
->sd_statfs_spin
);
474 gfs2_glock_dq_uninit(&gh
);
478 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
481 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
482 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
483 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
484 struct buffer_head
*l_bh
;
489 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
493 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
495 spin_lock(&sdp
->sd_statfs_spin
);
496 l_sc
->sc_total
+= total
;
497 l_sc
->sc_free
+= free
;
498 l_sc
->sc_dinodes
+= dinodes
;
499 gfs2_statfs_change_out(l_sc
, l_bh
->b_data
+ sizeof(struct gfs2_dinode
));
500 if (sdp
->sd_args
.ar_statfs_percent
) {
501 x
= 100 * l_sc
->sc_free
;
502 y
= m_sc
->sc_free
* sdp
->sd_args
.ar_statfs_percent
;
503 if (x
>= y
|| x
<= -y
)
506 spin_unlock(&sdp
->sd_statfs_spin
);
510 gfs2_wake_up_statfs(sdp
);
513 void update_statfs(struct gfs2_sbd
*sdp
, struct buffer_head
*m_bh
,
514 struct buffer_head
*l_bh
)
516 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
517 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
518 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
519 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
521 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
523 spin_lock(&sdp
->sd_statfs_spin
);
524 m_sc
->sc_total
+= l_sc
->sc_total
;
525 m_sc
->sc_free
+= l_sc
->sc_free
;
526 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
527 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
528 memset(l_bh
->b_data
+ sizeof(struct gfs2_dinode
),
529 0, sizeof(struct gfs2_statfs_change
));
530 spin_unlock(&sdp
->sd_statfs_spin
);
532 gfs2_trans_add_bh(m_ip
->i_gl
, m_bh
, 1);
533 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
536 int gfs2_statfs_sync(struct super_block
*sb
, int type
)
538 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
539 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
540 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
541 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
542 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
543 struct gfs2_holder gh
;
544 struct buffer_head
*m_bh
, *l_bh
;
547 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
552 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
556 spin_lock(&sdp
->sd_statfs_spin
);
557 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
558 sizeof(struct gfs2_dinode
));
559 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
560 spin_unlock(&sdp
->sd_statfs_spin
);
563 spin_unlock(&sdp
->sd_statfs_spin
);
565 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
569 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
573 update_statfs(sdp
, m_bh
, l_bh
);
574 sdp
->sd_statfs_force_sync
= 0;
583 gfs2_glock_dq_uninit(&gh
);
588 struct list_head list
;
589 struct gfs2_holder gh
;
593 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
595 * @sdp: the file system
596 * @state: the state to put the transaction lock into
597 * @t_gh: the hold on the transaction lock
602 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
,
603 struct gfs2_holder
*t_gh
)
605 struct gfs2_inode
*ip
;
606 struct gfs2_jdesc
*jd
;
609 struct gfs2_log_header_host lh
;
612 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
613 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
618 ip
= GFS2_I(jd
->jd_inode
);
619 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
624 list_add(&lfcc
->list
, &list
);
627 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_DEFERRED
,
630 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
631 error
= gfs2_jdesc_check(jd
);
634 error
= gfs2_find_jhead(jd
, &lh
);
637 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
644 gfs2_glock_dq_uninit(t_gh
);
647 while (!list_empty(&list
)) {
648 lfcc
= list_entry(list
.next
, struct lfcc
, list
);
649 list_del(&lfcc
->list
);
650 gfs2_glock_dq_uninit(&lfcc
->gh
);
657 * gfs2_freeze_fs - freezes the file system
658 * @sdp: the file system
660 * This function flushes data and meta data for all machines by
661 * acquiring the transaction log exclusively. All journals are
662 * ensured to be in a clean state as well.
667 int gfs2_freeze_fs(struct gfs2_sbd
*sdp
)
671 mutex_lock(&sdp
->sd_freeze_lock
);
673 if (!sdp
->sd_freeze_count
++) {
674 error
= gfs2_lock_fs_check_clean(sdp
, &sdp
->sd_freeze_gh
);
676 sdp
->sd_freeze_count
--;
679 mutex_unlock(&sdp
->sd_freeze_lock
);
685 * gfs2_unfreeze_fs - unfreezes the file system
686 * @sdp: the file system
688 * This function allows the file system to proceed by unlocking
689 * the exclusively held transaction lock. Other GFS2 nodes are
690 * now free to acquire the lock shared and go on with their lives.
694 void gfs2_unfreeze_fs(struct gfs2_sbd
*sdp
)
696 mutex_lock(&sdp
->sd_freeze_lock
);
698 if (sdp
->sd_freeze_count
&& !--sdp
->sd_freeze_count
)
699 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
701 mutex_unlock(&sdp
->sd_freeze_lock
);
706 * gfs2_write_inode - Make sure the inode is stable on the disk
708 * @wbc: The writeback control structure
713 static int gfs2_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
715 struct gfs2_inode
*ip
= GFS2_I(inode
);
716 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
717 struct address_space
*metamapping
= gfs2_glock2aspace(ip
->i_gl
);
718 struct backing_dev_info
*bdi
= metamapping
->backing_dev_info
;
719 struct gfs2_holder gh
;
720 struct buffer_head
*bh
;
721 struct timespec atime
;
722 struct gfs2_dinode
*di
;
725 /* Skip timestamp update, if this is from a memalloc */
726 if (current
->flags
& PF_MEMALLOC
)
728 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
731 ret
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
734 ret
= gfs2_meta_inode_buffer(ip
, &bh
);
736 di
= (struct gfs2_dinode
*)bh
->b_data
;
737 atime
.tv_sec
= be64_to_cpu(di
->di_atime
);
738 atime
.tv_nsec
= be32_to_cpu(di
->di_atime_nsec
);
739 if (timespec_compare(&inode
->i_atime
, &atime
) > 0) {
740 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
741 gfs2_dinode_out(ip
, bh
->b_data
);
747 gfs2_glock_dq_uninit(&gh
);
749 if (wbc
->sync_mode
== WB_SYNC_ALL
)
750 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
);
751 filemap_fdatawrite(metamapping
);
752 if (bdi
->dirty_exceeded
)
753 gfs2_ail1_flush(sdp
, wbc
);
754 if (!ret
&& (wbc
->sync_mode
== WB_SYNC_ALL
))
755 ret
= filemap_fdatawait(metamapping
);
757 mark_inode_dirty_sync(inode
);
762 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
763 * @sdp: the filesystem
768 static int gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
770 struct gfs2_holder t_gh
;
773 flush_workqueue(gfs2_delete_workqueue
);
774 gfs2_quota_sync(sdp
->sd_vfs
, 0, 1);
775 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
777 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, GL_NOCACHE
,
779 if (error
&& !test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
782 gfs2_meta_syncfs(sdp
);
783 gfs2_log_shutdown(sdp
);
785 clear_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
788 gfs2_glock_dq_uninit(&t_gh
);
790 gfs2_quota_cleanup(sdp
);
795 static int gfs2_umount_recovery_wait(void *word
)
802 * gfs2_put_super - Unmount the filesystem
803 * @sb: The VFS superblock
807 static void gfs2_put_super(struct super_block
*sb
)
809 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
811 struct gfs2_jdesc
*jd
;
813 /* Unfreeze the filesystem, if we need to */
815 mutex_lock(&sdp
->sd_freeze_lock
);
816 if (sdp
->sd_freeze_count
)
817 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
818 mutex_unlock(&sdp
->sd_freeze_lock
);
820 /* No more recovery requests */
821 set_bit(SDF_NORECOVERY
, &sdp
->sd_flags
);
824 /* Wait on outstanding recovery */
826 spin_lock(&sdp
->sd_jindex_spin
);
827 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
828 if (!test_bit(JDF_RECOVERY
, &jd
->jd_flags
))
830 spin_unlock(&sdp
->sd_jindex_spin
);
831 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
832 gfs2_umount_recovery_wait
, TASK_UNINTERRUPTIBLE
);
835 spin_unlock(&sdp
->sd_jindex_spin
);
837 kthread_stop(sdp
->sd_quotad_process
);
838 kthread_stop(sdp
->sd_logd_process
);
840 if (!(sb
->s_flags
& MS_RDONLY
)) {
841 error
= gfs2_make_fs_ro(sdp
);
845 /* At this point, we're through modifying the disk */
849 iput(sdp
->sd_jindex
);
850 iput(sdp
->sd_statfs_inode
);
851 iput(sdp
->sd_rindex
);
852 iput(sdp
->sd_quota_inode
);
854 gfs2_glock_put(sdp
->sd_rename_gl
);
855 gfs2_glock_put(sdp
->sd_trans_gl
);
857 if (!sdp
->sd_args
.ar_spectator
) {
858 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
859 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
860 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
861 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
862 iput(sdp
->sd_sc_inode
);
863 iput(sdp
->sd_qc_inode
);
866 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
867 gfs2_clear_rgrpd(sdp
);
868 gfs2_jindex_free(sdp
);
869 /* Take apart glock structures and buffer lists */
870 gfs2_gl_hash_clear(sdp
);
871 /* Unmount the locking protocol */
872 gfs2_lm_unmount(sdp
);
874 /* At this point, we're through participating in the lockspace */
875 gfs2_sys_fs_del(sdp
);
879 * gfs2_sync_fs - sync the filesystem
880 * @sb: the superblock
882 * Flushes the log to disk.
885 static int gfs2_sync_fs(struct super_block
*sb
, int wait
)
887 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
889 gfs2_log_flush(sdp
, NULL
);
894 * gfs2_freeze - prevent further writes to the filesystem
895 * @sb: the VFS structure for the filesystem
899 static int gfs2_freeze(struct super_block
*sb
)
901 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
904 if (test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
908 error
= gfs2_freeze_fs(sdp
);
914 fs_err(sdp
, "waiting for recovery before freeze\n");
918 fs_err(sdp
, "error freezing FS: %d\n", error
);
922 fs_err(sdp
, "retrying...\n");
929 * gfs2_unfreeze - reallow writes to the filesystem
930 * @sb: the VFS structure for the filesystem
934 static int gfs2_unfreeze(struct super_block
*sb
)
936 gfs2_unfreeze_fs(sb
->s_fs_info
);
941 * statfs_fill - fill in the sg for a given RG
943 * @sc: the sc structure
945 * Returns: 0 on success, -ESTALE if the LVB is invalid
948 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
949 struct gfs2_statfs_change_host
*sc
)
951 gfs2_rgrp_verify(rgd
);
952 sc
->sc_total
+= rgd
->rd_data
;
953 sc
->sc_free
+= rgd
->rd_free
;
954 sc
->sc_dinodes
+= rgd
->rd_dinodes
;
959 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
960 * @sdp: the filesystem
961 * @sc: the sc info that will be returned
963 * Any error (other than a signal) will cause this routine to fall back
964 * to the synchronous version.
966 * FIXME: This really shouldn't busy wait like this.
971 static int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
973 struct gfs2_holder ri_gh
;
974 struct gfs2_rgrpd
*rgd_next
;
975 struct gfs2_holder
*gha
, *gh
;
976 unsigned int slots
= 64;
981 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
982 gha
= kcalloc(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
986 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
990 rgd_next
= gfs2_rgrpd_get_first(sdp
);
995 for (x
= 0; x
< slots
; x
++) {
998 if (gh
->gh_gl
&& gfs2_glock_poll(gh
)) {
999 err
= gfs2_glock_wait(gh
);
1001 gfs2_holder_uninit(gh
);
1005 error
= statfs_slow_fill(
1006 gh
->gh_gl
->gl_object
, sc
);
1007 gfs2_glock_dq_uninit(gh
);
1013 else if (rgd_next
&& !error
) {
1014 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
1018 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
1022 if (signal_pending(current
))
1023 error
= -ERESTARTSYS
;
1032 gfs2_glock_dq_uninit(&ri_gh
);
1040 * gfs2_statfs_i - Do a statfs
1041 * @sdp: the filesystem
1042 * @sg: the sg structure
1047 static int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
1049 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
1050 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
1052 spin_lock(&sdp
->sd_statfs_spin
);
1055 sc
->sc_total
+= l_sc
->sc_total
;
1056 sc
->sc_free
+= l_sc
->sc_free
;
1057 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
1059 spin_unlock(&sdp
->sd_statfs_spin
);
1061 if (sc
->sc_free
< 0)
1063 if (sc
->sc_free
> sc
->sc_total
)
1064 sc
->sc_free
= sc
->sc_total
;
1065 if (sc
->sc_dinodes
< 0)
1072 * gfs2_statfs - Gather and return stats about the filesystem
1073 * @sb: The superblock
1074 * @statfsbuf: The buffer
1076 * Returns: 0 on success or error code
1079 static int gfs2_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1081 struct super_block
*sb
= dentry
->d_inode
->i_sb
;
1082 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1083 struct gfs2_statfs_change_host sc
;
1086 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
1087 error
= gfs2_statfs_slow(sdp
, &sc
);
1089 error
= gfs2_statfs_i(sdp
, &sc
);
1094 buf
->f_type
= GFS2_MAGIC
;
1095 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
1096 buf
->f_blocks
= sc
.sc_total
;
1097 buf
->f_bfree
= sc
.sc_free
;
1098 buf
->f_bavail
= sc
.sc_free
;
1099 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
1100 buf
->f_ffree
= sc
.sc_free
;
1101 buf
->f_namelen
= GFS2_FNAMESIZE
;
1107 * gfs2_remount_fs - called when the FS is remounted
1108 * @sb: the filesystem
1109 * @flags: the remount flags
1110 * @data: extra data passed in (not used right now)
1115 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
1117 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1118 struct gfs2_args args
= sdp
->sd_args
; /* Default to current settings */
1119 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
1122 spin_lock(>
->gt_spin
);
1123 args
.ar_commit
= gt
->gt_logd_secs
;
1124 args
.ar_quota_quantum
= gt
->gt_quota_quantum
;
1125 if (gt
->gt_statfs_slow
)
1126 args
.ar_statfs_quantum
= 0;
1128 args
.ar_statfs_quantum
= gt
->gt_statfs_quantum
;
1129 spin_unlock(>
->gt_spin
);
1130 error
= gfs2_mount_args(&args
, data
);
1134 /* Not allowed to change locking details */
1135 if (strcmp(args
.ar_lockproto
, sdp
->sd_args
.ar_lockproto
) ||
1136 strcmp(args
.ar_locktable
, sdp
->sd_args
.ar_locktable
) ||
1137 strcmp(args
.ar_hostdata
, sdp
->sd_args
.ar_hostdata
))
1140 /* Some flags must not be changed */
1141 if (args_neq(&args
, &sdp
->sd_args
, spectator
) ||
1142 args_neq(&args
, &sdp
->sd_args
, localflocks
) ||
1143 args_neq(&args
, &sdp
->sd_args
, meta
))
1146 if (sdp
->sd_args
.ar_spectator
)
1147 *flags
|= MS_RDONLY
;
1149 if ((sb
->s_flags
^ *flags
) & MS_RDONLY
) {
1150 if (*flags
& MS_RDONLY
)
1151 error
= gfs2_make_fs_ro(sdp
);
1153 error
= gfs2_make_fs_rw(sdp
);
1158 sdp
->sd_args
= args
;
1159 if (sdp
->sd_args
.ar_posix_acl
)
1160 sb
->s_flags
|= MS_POSIXACL
;
1162 sb
->s_flags
&= ~MS_POSIXACL
;
1163 if (sdp
->sd_args
.ar_nobarrier
)
1164 set_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1166 clear_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1167 spin_lock(>
->gt_spin
);
1168 gt
->gt_logd_secs
= args
.ar_commit
;
1169 gt
->gt_quota_quantum
= args
.ar_quota_quantum
;
1170 if (args
.ar_statfs_quantum
) {
1171 gt
->gt_statfs_slow
= 0;
1172 gt
->gt_statfs_quantum
= args
.ar_statfs_quantum
;
1175 gt
->gt_statfs_slow
= 1;
1176 gt
->gt_statfs_quantum
= 30;
1178 spin_unlock(>
->gt_spin
);
1180 gfs2_online_uevent(sdp
);
1185 * gfs2_drop_inode - Drop an inode (test for remote unlink)
1186 * @inode: The inode to drop
1188 * If we've received a callback on an iopen lock then its because a
1189 * remote node tried to deallocate the inode but failed due to this node
1190 * still having the inode open. Here we mark the link count zero
1191 * since we know that it must have reached zero if the GLF_DEMOTE flag
1192 * is set on the iopen glock. If we didn't do a disk read since the
1193 * remote node removed the final link then we might otherwise miss
1194 * this event. This check ensures that this node will deallocate the
1195 * inode's blocks, or alternatively pass the baton on to another
1196 * node for later deallocation.
1199 static int gfs2_drop_inode(struct inode
*inode
)
1201 struct gfs2_inode
*ip
= GFS2_I(inode
);
1203 if (inode
->i_nlink
) {
1204 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1205 if (gl
&& test_bit(GLF_DEMOTE
, &gl
->gl_flags
))
1208 return generic_drop_inode(inode
);
1211 static int is_ancestor(const struct dentry
*d1
, const struct dentry
*d2
)
1217 } while (!IS_ROOT(d1
));
1222 * gfs2_show_options - Show mount options for /proc/mounts
1223 * @s: seq_file structure
1226 * Returns: 0 on success or error code
1229 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
1231 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
1232 struct gfs2_args
*args
= &sdp
->sd_args
;
1235 if (is_ancestor(mnt
->mnt_root
, sdp
->sd_master_dir
))
1236 seq_printf(s
, ",meta");
1237 if (args
->ar_lockproto
[0])
1238 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
1239 if (args
->ar_locktable
[0])
1240 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
1241 if (args
->ar_hostdata
[0])
1242 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
1243 if (args
->ar_spectator
)
1244 seq_printf(s
, ",spectator");
1245 if (args
->ar_localflocks
)
1246 seq_printf(s
, ",localflocks");
1248 seq_printf(s
, ",debug");
1249 if (args
->ar_posix_acl
)
1250 seq_printf(s
, ",acl");
1251 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
1253 switch (args
->ar_quota
) {
1254 case GFS2_QUOTA_OFF
:
1257 case GFS2_QUOTA_ACCOUNT
:
1267 seq_printf(s
, ",quota=%s", state
);
1269 if (args
->ar_suiddir
)
1270 seq_printf(s
, ",suiddir");
1271 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
1273 switch (args
->ar_data
) {
1274 case GFS2_DATA_WRITEBACK
:
1275 state
= "writeback";
1277 case GFS2_DATA_ORDERED
:
1284 seq_printf(s
, ",data=%s", state
);
1286 if (args
->ar_discard
)
1287 seq_printf(s
, ",discard");
1288 val
= sdp
->sd_tune
.gt_logd_secs
;
1290 seq_printf(s
, ",commit=%d", val
);
1291 val
= sdp
->sd_tune
.gt_statfs_quantum
;
1293 seq_printf(s
, ",statfs_quantum=%d", val
);
1294 val
= sdp
->sd_tune
.gt_quota_quantum
;
1296 seq_printf(s
, ",quota_quantum=%d", val
);
1297 if (args
->ar_statfs_percent
)
1298 seq_printf(s
, ",statfs_percent=%d", args
->ar_statfs_percent
);
1299 if (args
->ar_errors
!= GFS2_ERRORS_DEFAULT
) {
1302 switch (args
->ar_errors
) {
1303 case GFS2_ERRORS_WITHDRAW
:
1306 case GFS2_ERRORS_PANIC
:
1313 seq_printf(s
, ",errors=%s", state
);
1315 if (test_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
))
1316 seq_printf(s
, ",nobarrier");
1317 if (test_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
1318 seq_printf(s
, ",demote_interface_used");
1322 static void gfs2_final_release_pages(struct gfs2_inode
*ip
)
1324 struct inode
*inode
= &ip
->i_inode
;
1325 struct gfs2_glock
*gl
= ip
->i_gl
;
1327 truncate_inode_pages(gfs2_glock2aspace(ip
->i_gl
), 0);
1328 truncate_inode_pages(&inode
->i_data
, 0);
1330 if (atomic_read(&gl
->gl_revokes
) == 0) {
1331 clear_bit(GLF_LFLUSH
, &gl
->gl_flags
);
1332 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
1336 static int gfs2_dinode_dealloc(struct gfs2_inode
*ip
)
1338 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1339 struct gfs2_alloc
*al
;
1340 struct gfs2_rgrpd
*rgd
;
1343 if (gfs2_get_inode_blocks(&ip
->i_inode
) != 1) {
1344 if (gfs2_consist_inode(ip
))
1345 gfs2_dinode_print(ip
);
1349 al
= gfs2_alloc_get(ip
);
1353 error
= gfs2_quota_hold(ip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
1357 error
= gfs2_rindex_hold(sdp
, &al
->al_ri_gh
);
1361 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_no_addr
);
1363 gfs2_consist_inode(ip
);
1365 goto out_rindex_relse
;
1368 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0,
1371 goto out_rindex_relse
;
1373 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_STATFS
+ RES_QUOTA
,
1374 sdp
->sd_jdesc
->jd_blocks
);
1376 goto out_rg_gunlock
;
1378 gfs2_free_di(rgd
, ip
);
1380 gfs2_final_release_pages(ip
);
1382 gfs2_trans_end(sdp
);
1385 gfs2_glock_dq_uninit(&al
->al_rgd_gh
);
1387 gfs2_glock_dq_uninit(&al
->al_ri_gh
);
1389 gfs2_quota_unhold(ip
);
1396 * We have to (at the moment) hold the inodes main lock to cover
1397 * the gap between unlocking the shared lock on the iopen lock and
1398 * taking the exclusive lock. I'd rather do a shared -> exclusive
1399 * conversion on the iopen lock, but we can change that later. This
1400 * is safe, just less efficient.
1403 static void gfs2_evict_inode(struct inode
*inode
)
1405 struct super_block
*sb
= inode
->i_sb
;
1406 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1407 struct gfs2_inode
*ip
= GFS2_I(inode
);
1408 struct gfs2_holder gh
;
1411 if (inode
->i_nlink
|| (sb
->s_flags
& MS_RDONLY
))
1414 /* Must not read inode block until block type has been verified */
1415 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_SKIP
, &gh
);
1416 if (unlikely(error
)) {
1417 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1421 error
= gfs2_check_blk_type(sdp
, ip
->i_no_addr
, GFS2_BLKST_UNLINKED
);
1425 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
1426 error
= gfs2_inode_refresh(ip
);
1431 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1432 gfs2_glock_dq_wait(&ip
->i_iopen_gh
);
1433 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, &ip
->i_iopen_gh
);
1434 error
= gfs2_glock_nq(&ip
->i_iopen_gh
);
1438 if (S_ISDIR(inode
->i_mode
) &&
1439 (ip
->i_diskflags
& GFS2_DIF_EXHASH
)) {
1440 error
= gfs2_dir_exhash_dealloc(ip
);
1446 error
= gfs2_ea_dealloc(ip
);
1451 if (!gfs2_is_stuffed(ip
)) {
1452 error
= gfs2_file_dealloc(ip
);
1457 error
= gfs2_dinode_dealloc(ip
);
1461 error
= gfs2_trans_begin(sdp
, 0, sdp
->sd_jdesc
->jd_blocks
);
1464 gfs2_final_release_pages(ip
);
1465 gfs2_trans_end(sdp
);
1468 if (test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
))
1469 gfs2_glock_dq(&ip
->i_iopen_gh
);
1470 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1471 gfs2_glock_dq_uninit(&gh
);
1472 if (error
&& error
!= GLR_TRYFAILED
&& error
!= -EROFS
)
1473 fs_warn(sdp
, "gfs2_evict_inode: %d\n", error
);
1475 truncate_inode_pages(&inode
->i_data
, 0);
1476 end_writeback(inode
);
1478 ip
->i_gl
->gl_object
= NULL
;
1479 gfs2_glock_add_to_lru(ip
->i_gl
);
1480 gfs2_glock_put(ip
->i_gl
);
1482 if (ip
->i_iopen_gh
.gh_gl
) {
1483 ip
->i_iopen_gh
.gh_gl
->gl_object
= NULL
;
1484 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1488 static struct inode
*gfs2_alloc_inode(struct super_block
*sb
)
1490 struct gfs2_inode
*ip
;
1492 ip
= kmem_cache_alloc(gfs2_inode_cachep
, GFP_KERNEL
);
1497 return &ip
->i_inode
;
1500 static void gfs2_i_callback(struct rcu_head
*head
)
1502 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
1503 INIT_LIST_HEAD(&inode
->i_dentry
);
1504 kmem_cache_free(gfs2_inode_cachep
, inode
);
1507 static void gfs2_destroy_inode(struct inode
*inode
)
1509 call_rcu(&inode
->i_rcu
, gfs2_i_callback
);
1512 const struct super_operations gfs2_super_ops
= {
1513 .alloc_inode
= gfs2_alloc_inode
,
1514 .destroy_inode
= gfs2_destroy_inode
,
1515 .write_inode
= gfs2_write_inode
,
1516 .evict_inode
= gfs2_evict_inode
,
1517 .put_super
= gfs2_put_super
,
1518 .sync_fs
= gfs2_sync_fs
,
1519 .freeze_fs
= gfs2_freeze
,
1520 .unfreeze_fs
= gfs2_unfreeze
,
1521 .statfs
= gfs2_statfs
,
1522 .remount_fs
= gfs2_remount_fs
,
1523 .drop_inode
= gfs2_drop_inode
,
1524 .show_options
= gfs2_show_options
,