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>
45 #define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)
83 static const match_table_t tokens
= {
84 {Opt_lockproto
, "lockproto=%s"},
85 {Opt_locktable
, "locktable=%s"},
86 {Opt_hostdata
, "hostdata=%s"},
87 {Opt_spectator
, "spectator"},
88 {Opt_spectator
, "norecovery"},
89 {Opt_ignore_local_fs
, "ignore_local_fs"},
90 {Opt_localflocks
, "localflocks"},
91 {Opt_localcaching
, "localcaching"},
93 {Opt_nodebug
, "nodebug"},
94 {Opt_upgrade
, "upgrade"},
97 {Opt_quota_off
, "quota=off"},
98 {Opt_quota_account
, "quota=account"},
99 {Opt_quota_on
, "quota=on"},
100 {Opt_quota
, "quota"},
101 {Opt_noquota
, "noquota"},
102 {Opt_suiddir
, "suiddir"},
103 {Opt_nosuiddir
, "nosuiddir"},
104 {Opt_data_writeback
, "data=writeback"},
105 {Opt_data_ordered
, "data=ordered"},
107 {Opt_discard
, "discard"},
108 {Opt_nodiscard
, "nodiscard"},
109 {Opt_commit
, "commit=%d"},
110 {Opt_err_withdraw
, "errors=withdraw"},
111 {Opt_err_panic
, "errors=panic"},
112 {Opt_statfs_quantum
, "statfs_quantum=%d"},
113 {Opt_statfs_percent
, "statfs_percent=%d"},
114 {Opt_quota_quantum
, "quota_quantum=%d"},
115 {Opt_barrier
, "barrier"},
116 {Opt_nobarrier
, "nobarrier"},
121 * gfs2_mount_args - Parse mount options
122 * @args: The structure into which the parsed options will be written
123 * @options: The options to parse
128 int gfs2_mount_args(struct gfs2_args
*args
, char *options
)
132 substring_t tmp
[MAX_OPT_ARGS
];
135 /* Split the options into tokens with the "," character and
139 o
= strsep(&options
, ",");
145 token
= match_token(o
, tokens
, tmp
);
148 match_strlcpy(args
->ar_lockproto
, &tmp
[0],
152 match_strlcpy(args
->ar_locktable
, &tmp
[0],
156 match_strlcpy(args
->ar_hostdata
, &tmp
[0],
160 args
->ar_spectator
= 1;
162 case Opt_ignore_local_fs
:
163 /* Retained for backwards compat only */
165 case Opt_localflocks
:
166 args
->ar_localflocks
= 1;
168 case Opt_localcaching
:
169 /* Retained for backwards compat only */
172 if (args
->ar_errors
== GFS2_ERRORS_PANIC
) {
173 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
174 "are mutually exclusive.\n");
183 /* Retained for backwards compat only */
186 args
->ar_posix_acl
= 1;
189 args
->ar_posix_acl
= 0;
193 args
->ar_quota
= GFS2_QUOTA_OFF
;
195 case Opt_quota_account
:
196 args
->ar_quota
= GFS2_QUOTA_ACCOUNT
;
200 args
->ar_quota
= GFS2_QUOTA_ON
;
203 args
->ar_suiddir
= 1;
206 args
->ar_suiddir
= 0;
208 case Opt_data_writeback
:
209 args
->ar_data
= GFS2_DATA_WRITEBACK
;
211 case Opt_data_ordered
:
212 args
->ar_data
= GFS2_DATA_ORDERED
;
218 args
->ar_discard
= 1;
221 args
->ar_discard
= 0;
224 rv
= match_int(&tmp
[0], &args
->ar_commit
);
225 if (rv
|| args
->ar_commit
<= 0) {
226 printk(KERN_WARNING
"GFS2: commit mount option requires a positive numeric argument\n");
227 return rv
? rv
: -EINVAL
;
230 case Opt_statfs_quantum
:
231 rv
= match_int(&tmp
[0], &args
->ar_statfs_quantum
);
232 if (rv
|| args
->ar_statfs_quantum
< 0) {
233 printk(KERN_WARNING
"GFS2: statfs_quantum mount option requires a non-negative numeric argument\n");
234 return rv
? rv
: -EINVAL
;
237 case Opt_quota_quantum
:
238 rv
= match_int(&tmp
[0], &args
->ar_quota_quantum
);
239 if (rv
|| args
->ar_quota_quantum
<= 0) {
240 printk(KERN_WARNING
"GFS2: quota_quantum mount option requires a positive numeric argument\n");
241 return rv
? rv
: -EINVAL
;
244 case Opt_statfs_percent
:
245 rv
= match_int(&tmp
[0], &args
->ar_statfs_percent
);
246 if (rv
|| args
->ar_statfs_percent
< 0 ||
247 args
->ar_statfs_percent
> 100) {
248 printk(KERN_WARNING
"statfs_percent mount option requires a numeric argument between 0 and 100\n");
249 return rv
? rv
: -EINVAL
;
252 case Opt_err_withdraw
:
253 args
->ar_errors
= GFS2_ERRORS_WITHDRAW
;
256 if (args
->ar_debug
) {
257 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
258 "are mutually exclusive.\n");
261 args
->ar_errors
= GFS2_ERRORS_PANIC
;
264 args
->ar_nobarrier
= 0;
267 args
->ar_nobarrier
= 1;
271 printk(KERN_WARNING
"GFS2: invalid mount option: %s\n", o
);
280 * gfs2_jindex_free - Clear all the journal index information
281 * @sdp: The GFS2 superblock
285 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
287 struct list_head list
, *head
;
288 struct gfs2_jdesc
*jd
;
289 struct gfs2_journal_extent
*jext
;
291 spin_lock(&sdp
->sd_jindex_spin
);
292 list_add(&list
, &sdp
->sd_jindex_list
);
293 list_del_init(&sdp
->sd_jindex_list
);
294 sdp
->sd_journals
= 0;
295 spin_unlock(&sdp
->sd_jindex_spin
);
297 while (!list_empty(&list
)) {
298 jd
= list_entry(list
.next
, struct gfs2_jdesc
, jd_list
);
299 head
= &jd
->extent_list
;
300 while (!list_empty(head
)) {
301 jext
= list_entry(head
->next
,
302 struct gfs2_journal_extent
,
304 list_del(&jext
->extent_list
);
307 list_del(&jd
->jd_list
);
313 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
315 struct gfs2_jdesc
*jd
;
318 list_for_each_entry(jd
, head
, jd_list
) {
319 if (jd
->jd_jid
== jid
) {
331 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
333 struct gfs2_jdesc
*jd
;
335 spin_lock(&sdp
->sd_jindex_spin
);
336 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
337 spin_unlock(&sdp
->sd_jindex_spin
);
342 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
344 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
345 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
346 u64 size
= i_size_read(jd
->jd_inode
);
348 if (gfs2_check_internal_file_size(jd
->jd_inode
, 8 << 20, 1 << 30))
351 jd
->jd_blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
353 if (gfs2_write_alloc_required(ip
, 0, size
)) {
354 gfs2_consist_inode(ip
);
362 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
363 * @sdp: the filesystem
368 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
370 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
371 struct gfs2_glock
*j_gl
= ip
->i_gl
;
372 struct gfs2_holder t_gh
;
373 struct gfs2_log_header_host head
;
376 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, 0, &t_gh
);
380 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
382 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
386 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
392 /* Initialize some head of the log stuff */
393 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
394 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
396 error
= gfs2_quota_init(sdp
);
400 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
402 gfs2_glock_dq_uninit(&t_gh
);
407 t_gh
.gh_flags
|= GL_NOCACHE
;
408 gfs2_glock_dq_uninit(&t_gh
);
413 void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
415 const struct gfs2_statfs_change
*str
= buf
;
417 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
418 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
419 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
422 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
424 struct gfs2_statfs_change
*str
= buf
;
426 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
427 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
428 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
431 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
433 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
434 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
435 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
436 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
437 struct buffer_head
*m_bh
, *l_bh
;
438 struct gfs2_holder gh
;
441 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
446 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
450 if (sdp
->sd_args
.ar_spectator
) {
451 spin_lock(&sdp
->sd_statfs_spin
);
452 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
453 sizeof(struct gfs2_dinode
));
454 spin_unlock(&sdp
->sd_statfs_spin
);
456 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
460 spin_lock(&sdp
->sd_statfs_spin
);
461 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
462 sizeof(struct gfs2_dinode
));
463 gfs2_statfs_change_in(l_sc
, l_bh
->b_data
+
464 sizeof(struct gfs2_dinode
));
465 spin_unlock(&sdp
->sd_statfs_spin
);
473 gfs2_glock_dq_uninit(&gh
);
477 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
480 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
481 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
482 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
483 struct buffer_head
*l_bh
;
488 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
492 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
494 spin_lock(&sdp
->sd_statfs_spin
);
495 l_sc
->sc_total
+= total
;
496 l_sc
->sc_free
+= free
;
497 l_sc
->sc_dinodes
+= dinodes
;
498 gfs2_statfs_change_out(l_sc
, l_bh
->b_data
+ sizeof(struct gfs2_dinode
));
499 if (sdp
->sd_args
.ar_statfs_percent
) {
500 x
= 100 * l_sc
->sc_free
;
501 y
= m_sc
->sc_free
* sdp
->sd_args
.ar_statfs_percent
;
502 if (x
>= y
|| x
<= -y
)
505 spin_unlock(&sdp
->sd_statfs_spin
);
509 gfs2_wake_up_statfs(sdp
);
512 void update_statfs(struct gfs2_sbd
*sdp
, struct buffer_head
*m_bh
,
513 struct buffer_head
*l_bh
)
515 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
516 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
517 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
518 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
520 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
522 spin_lock(&sdp
->sd_statfs_spin
);
523 m_sc
->sc_total
+= l_sc
->sc_total
;
524 m_sc
->sc_free
+= l_sc
->sc_free
;
525 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
526 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
527 memset(l_bh
->b_data
+ sizeof(struct gfs2_dinode
),
528 0, sizeof(struct gfs2_statfs_change
));
529 spin_unlock(&sdp
->sd_statfs_spin
);
531 gfs2_trans_add_bh(m_ip
->i_gl
, m_bh
, 1);
532 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
535 int gfs2_statfs_sync(struct super_block
*sb
, int type
)
537 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
538 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
539 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
540 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
541 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
542 struct gfs2_holder gh
;
543 struct buffer_head
*m_bh
, *l_bh
;
546 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
551 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
555 spin_lock(&sdp
->sd_statfs_spin
);
556 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
557 sizeof(struct gfs2_dinode
));
558 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
559 spin_unlock(&sdp
->sd_statfs_spin
);
562 spin_unlock(&sdp
->sd_statfs_spin
);
564 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
568 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
572 update_statfs(sdp
, m_bh
, l_bh
);
573 sdp
->sd_statfs_force_sync
= 0;
582 gfs2_glock_dq_uninit(&gh
);
587 struct list_head list
;
588 struct gfs2_holder gh
;
592 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
594 * @sdp: the file system
595 * @state: the state to put the transaction lock into
596 * @t_gh: the hold on the transaction lock
601 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
,
602 struct gfs2_holder
*t_gh
)
604 struct gfs2_inode
*ip
;
605 struct gfs2_jdesc
*jd
;
608 struct gfs2_log_header_host lh
;
611 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
612 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
617 ip
= GFS2_I(jd
->jd_inode
);
618 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
623 list_add(&lfcc
->list
, &list
);
626 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_DEFERRED
,
629 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
630 error
= gfs2_jdesc_check(jd
);
633 error
= gfs2_find_jhead(jd
, &lh
);
636 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
643 gfs2_glock_dq_uninit(t_gh
);
646 while (!list_empty(&list
)) {
647 lfcc
= list_entry(list
.next
, struct lfcc
, list
);
648 list_del(&lfcc
->list
);
649 gfs2_glock_dq_uninit(&lfcc
->gh
);
656 * gfs2_freeze_fs - freezes the file system
657 * @sdp: the file system
659 * This function flushes data and meta data for all machines by
660 * acquiring the transaction log exclusively. All journals are
661 * ensured to be in a clean state as well.
666 int gfs2_freeze_fs(struct gfs2_sbd
*sdp
)
670 mutex_lock(&sdp
->sd_freeze_lock
);
672 if (!sdp
->sd_freeze_count
++) {
673 error
= gfs2_lock_fs_check_clean(sdp
, &sdp
->sd_freeze_gh
);
675 sdp
->sd_freeze_count
--;
678 mutex_unlock(&sdp
->sd_freeze_lock
);
684 * gfs2_unfreeze_fs - unfreezes the file system
685 * @sdp: the file system
687 * This function allows the file system to proceed by unlocking
688 * the exclusively held transaction lock. Other GFS2 nodes are
689 * now free to acquire the lock shared and go on with their lives.
693 void gfs2_unfreeze_fs(struct gfs2_sbd
*sdp
)
695 mutex_lock(&sdp
->sd_freeze_lock
);
697 if (sdp
->sd_freeze_count
&& !--sdp
->sd_freeze_count
)
698 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
700 mutex_unlock(&sdp
->sd_freeze_lock
);
705 * gfs2_write_inode - Make sure the inode is stable on the disk
707 * @wbc: The writeback control structure
712 static int gfs2_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
714 struct gfs2_inode
*ip
= GFS2_I(inode
);
715 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
716 struct address_space
*metamapping
= gfs2_glock2aspace(ip
->i_gl
);
717 struct gfs2_holder gh
;
718 struct buffer_head
*bh
;
719 struct timespec atime
;
720 struct gfs2_dinode
*di
;
723 /* Skip timestamp update, if this is from a memalloc */
724 if (current
->flags
& PF_MEMALLOC
)
726 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
729 ret
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
732 ret
= gfs2_meta_inode_buffer(ip
, &bh
);
734 di
= (struct gfs2_dinode
*)bh
->b_data
;
735 atime
.tv_sec
= be64_to_cpu(di
->di_atime
);
736 atime
.tv_nsec
= be32_to_cpu(di
->di_atime_nsec
);
737 if (timespec_compare(&inode
->i_atime
, &atime
) > 0) {
738 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
739 gfs2_dinode_out(ip
, bh
->b_data
);
745 gfs2_glock_dq_uninit(&gh
);
747 if (wbc
->sync_mode
== WB_SYNC_ALL
)
748 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
);
749 filemap_fdatawrite(metamapping
);
750 if (!ret
&& (wbc
->sync_mode
== WB_SYNC_ALL
))
751 ret
= filemap_fdatawait(metamapping
);
753 mark_inode_dirty_sync(inode
);
758 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
759 * @sdp: the filesystem
764 static int gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
766 struct gfs2_holder t_gh
;
769 flush_workqueue(gfs2_delete_workqueue
);
770 gfs2_quota_sync(sdp
->sd_vfs
, 0, 1);
771 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
773 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, GL_NOCACHE
,
775 if (error
&& !test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
778 gfs2_meta_syncfs(sdp
);
779 gfs2_log_shutdown(sdp
);
781 clear_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
784 gfs2_glock_dq_uninit(&t_gh
);
786 gfs2_quota_cleanup(sdp
);
791 static int gfs2_umount_recovery_wait(void *word
)
798 * gfs2_put_super - Unmount the filesystem
799 * @sb: The VFS superblock
803 static void gfs2_put_super(struct super_block
*sb
)
805 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
807 struct gfs2_jdesc
*jd
;
809 /* Unfreeze the filesystem, if we need to */
811 mutex_lock(&sdp
->sd_freeze_lock
);
812 if (sdp
->sd_freeze_count
)
813 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
814 mutex_unlock(&sdp
->sd_freeze_lock
);
816 /* No more recovery requests */
817 set_bit(SDF_NORECOVERY
, &sdp
->sd_flags
);
820 /* Wait on outstanding recovery */
822 spin_lock(&sdp
->sd_jindex_spin
);
823 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
824 if (!test_bit(JDF_RECOVERY
, &jd
->jd_flags
))
826 spin_unlock(&sdp
->sd_jindex_spin
);
827 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
828 gfs2_umount_recovery_wait
, TASK_UNINTERRUPTIBLE
);
831 spin_unlock(&sdp
->sd_jindex_spin
);
833 kthread_stop(sdp
->sd_quotad_process
);
834 kthread_stop(sdp
->sd_logd_process
);
836 if (!(sb
->s_flags
& MS_RDONLY
)) {
837 error
= gfs2_make_fs_ro(sdp
);
841 /* At this point, we're through modifying the disk */
845 iput(sdp
->sd_jindex
);
846 iput(sdp
->sd_statfs_inode
);
847 iput(sdp
->sd_rindex
);
848 iput(sdp
->sd_quota_inode
);
850 gfs2_glock_put(sdp
->sd_rename_gl
);
851 gfs2_glock_put(sdp
->sd_trans_gl
);
853 if (!sdp
->sd_args
.ar_spectator
) {
854 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
855 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
856 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
857 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
858 iput(sdp
->sd_sc_inode
);
859 iput(sdp
->sd_qc_inode
);
862 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
863 gfs2_clear_rgrpd(sdp
);
864 gfs2_jindex_free(sdp
);
865 /* Take apart glock structures and buffer lists */
866 gfs2_gl_hash_clear(sdp
);
867 /* Unmount the locking protocol */
868 gfs2_lm_unmount(sdp
);
870 /* At this point, we're through participating in the lockspace */
871 gfs2_sys_fs_del(sdp
);
875 * gfs2_sync_fs - sync the filesystem
876 * @sb: the superblock
878 * Flushes the log to disk.
881 static int gfs2_sync_fs(struct super_block
*sb
, int wait
)
883 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
885 gfs2_log_flush(sdp
, NULL
);
890 * gfs2_freeze - prevent further writes to the filesystem
891 * @sb: the VFS structure for the filesystem
895 static int gfs2_freeze(struct super_block
*sb
)
897 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
900 if (test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
904 error
= gfs2_freeze_fs(sdp
);
910 fs_err(sdp
, "waiting for recovery before freeze\n");
914 fs_err(sdp
, "error freezing FS: %d\n", error
);
918 fs_err(sdp
, "retrying...\n");
925 * gfs2_unfreeze - reallow writes to the filesystem
926 * @sb: the VFS structure for the filesystem
930 static int gfs2_unfreeze(struct super_block
*sb
)
932 gfs2_unfreeze_fs(sb
->s_fs_info
);
937 * statfs_fill - fill in the sg for a given RG
939 * @sc: the sc structure
941 * Returns: 0 on success, -ESTALE if the LVB is invalid
944 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
945 struct gfs2_statfs_change_host
*sc
)
947 gfs2_rgrp_verify(rgd
);
948 sc
->sc_total
+= rgd
->rd_data
;
949 sc
->sc_free
+= rgd
->rd_free
;
950 sc
->sc_dinodes
+= rgd
->rd_dinodes
;
955 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
956 * @sdp: the filesystem
957 * @sc: the sc info that will be returned
959 * Any error (other than a signal) will cause this routine to fall back
960 * to the synchronous version.
962 * FIXME: This really shouldn't busy wait like this.
967 static int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
969 struct gfs2_holder ri_gh
;
970 struct gfs2_rgrpd
*rgd_next
;
971 struct gfs2_holder
*gha
, *gh
;
972 unsigned int slots
= 64;
977 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
978 gha
= kcalloc(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
982 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
986 rgd_next
= gfs2_rgrpd_get_first(sdp
);
991 for (x
= 0; x
< slots
; x
++) {
994 if (gh
->gh_gl
&& gfs2_glock_poll(gh
)) {
995 err
= gfs2_glock_wait(gh
);
997 gfs2_holder_uninit(gh
);
1001 error
= statfs_slow_fill(
1002 gh
->gh_gl
->gl_object
, sc
);
1003 gfs2_glock_dq_uninit(gh
);
1009 else if (rgd_next
&& !error
) {
1010 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
1014 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
1018 if (signal_pending(current
))
1019 error
= -ERESTARTSYS
;
1028 gfs2_glock_dq_uninit(&ri_gh
);
1036 * gfs2_statfs_i - Do a statfs
1037 * @sdp: the filesystem
1038 * @sg: the sg structure
1043 static int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
1045 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
1046 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
1048 spin_lock(&sdp
->sd_statfs_spin
);
1051 sc
->sc_total
+= l_sc
->sc_total
;
1052 sc
->sc_free
+= l_sc
->sc_free
;
1053 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
1055 spin_unlock(&sdp
->sd_statfs_spin
);
1057 if (sc
->sc_free
< 0)
1059 if (sc
->sc_free
> sc
->sc_total
)
1060 sc
->sc_free
= sc
->sc_total
;
1061 if (sc
->sc_dinodes
< 0)
1068 * gfs2_statfs - Gather and return stats about the filesystem
1069 * @sb: The superblock
1070 * @statfsbuf: The buffer
1072 * Returns: 0 on success or error code
1075 static int gfs2_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1077 struct super_block
*sb
= dentry
->d_inode
->i_sb
;
1078 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1079 struct gfs2_statfs_change_host sc
;
1082 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
1083 error
= gfs2_statfs_slow(sdp
, &sc
);
1085 error
= gfs2_statfs_i(sdp
, &sc
);
1090 buf
->f_type
= GFS2_MAGIC
;
1091 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
1092 buf
->f_blocks
= sc
.sc_total
;
1093 buf
->f_bfree
= sc
.sc_free
;
1094 buf
->f_bavail
= sc
.sc_free
;
1095 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
1096 buf
->f_ffree
= sc
.sc_free
;
1097 buf
->f_namelen
= GFS2_FNAMESIZE
;
1103 * gfs2_remount_fs - called when the FS is remounted
1104 * @sb: the filesystem
1105 * @flags: the remount flags
1106 * @data: extra data passed in (not used right now)
1111 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
1113 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1114 struct gfs2_args args
= sdp
->sd_args
; /* Default to current settings */
1115 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
1118 spin_lock(>
->gt_spin
);
1119 args
.ar_commit
= gt
->gt_logd_secs
;
1120 args
.ar_quota_quantum
= gt
->gt_quota_quantum
;
1121 if (gt
->gt_statfs_slow
)
1122 args
.ar_statfs_quantum
= 0;
1124 args
.ar_statfs_quantum
= gt
->gt_statfs_quantum
;
1125 spin_unlock(>
->gt_spin
);
1126 error
= gfs2_mount_args(&args
, data
);
1130 /* Not allowed to change locking details */
1131 if (strcmp(args
.ar_lockproto
, sdp
->sd_args
.ar_lockproto
) ||
1132 strcmp(args
.ar_locktable
, sdp
->sd_args
.ar_locktable
) ||
1133 strcmp(args
.ar_hostdata
, sdp
->sd_args
.ar_hostdata
))
1136 /* Some flags must not be changed */
1137 if (args_neq(&args
, &sdp
->sd_args
, spectator
) ||
1138 args_neq(&args
, &sdp
->sd_args
, localflocks
) ||
1139 args_neq(&args
, &sdp
->sd_args
, meta
))
1142 if (sdp
->sd_args
.ar_spectator
)
1143 *flags
|= MS_RDONLY
;
1145 if ((sb
->s_flags
^ *flags
) & MS_RDONLY
) {
1146 if (*flags
& MS_RDONLY
)
1147 error
= gfs2_make_fs_ro(sdp
);
1149 error
= gfs2_make_fs_rw(sdp
);
1154 sdp
->sd_args
= args
;
1155 if (sdp
->sd_args
.ar_posix_acl
)
1156 sb
->s_flags
|= MS_POSIXACL
;
1158 sb
->s_flags
&= ~MS_POSIXACL
;
1159 if (sdp
->sd_args
.ar_nobarrier
)
1160 set_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1162 clear_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1163 spin_lock(>
->gt_spin
);
1164 gt
->gt_logd_secs
= args
.ar_commit
;
1165 gt
->gt_quota_quantum
= args
.ar_quota_quantum
;
1166 if (args
.ar_statfs_quantum
) {
1167 gt
->gt_statfs_slow
= 0;
1168 gt
->gt_statfs_quantum
= args
.ar_statfs_quantum
;
1171 gt
->gt_statfs_slow
= 1;
1172 gt
->gt_statfs_quantum
= 30;
1174 spin_unlock(>
->gt_spin
);
1176 gfs2_online_uevent(sdp
);
1181 * gfs2_drop_inode - Drop an inode (test for remote unlink)
1182 * @inode: The inode to drop
1184 * If we've received a callback on an iopen lock then its because a
1185 * remote node tried to deallocate the inode but failed due to this node
1186 * still having the inode open. Here we mark the link count zero
1187 * since we know that it must have reached zero if the GLF_DEMOTE flag
1188 * is set on the iopen glock. If we didn't do a disk read since the
1189 * remote node removed the final link then we might otherwise miss
1190 * this event. This check ensures that this node will deallocate the
1191 * inode's blocks, or alternatively pass the baton on to another
1192 * node for later deallocation.
1195 static int gfs2_drop_inode(struct inode
*inode
)
1197 struct gfs2_inode
*ip
= GFS2_I(inode
);
1199 if (inode
->i_nlink
) {
1200 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1201 if (gl
&& test_bit(GLF_DEMOTE
, &gl
->gl_flags
))
1204 return generic_drop_inode(inode
);
1207 static int is_ancestor(const struct dentry
*d1
, const struct dentry
*d2
)
1213 } while (!IS_ROOT(d1
));
1218 * gfs2_show_options - Show mount options for /proc/mounts
1219 * @s: seq_file structure
1222 * Returns: 0 on success or error code
1225 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
1227 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
1228 struct gfs2_args
*args
= &sdp
->sd_args
;
1231 if (is_ancestor(mnt
->mnt_root
, sdp
->sd_master_dir
))
1232 seq_printf(s
, ",meta");
1233 if (args
->ar_lockproto
[0])
1234 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
1235 if (args
->ar_locktable
[0])
1236 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
1237 if (args
->ar_hostdata
[0])
1238 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
1239 if (args
->ar_spectator
)
1240 seq_printf(s
, ",spectator");
1241 if (args
->ar_localflocks
)
1242 seq_printf(s
, ",localflocks");
1244 seq_printf(s
, ",debug");
1245 if (args
->ar_posix_acl
)
1246 seq_printf(s
, ",acl");
1247 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
1249 switch (args
->ar_quota
) {
1250 case GFS2_QUOTA_OFF
:
1253 case GFS2_QUOTA_ACCOUNT
:
1263 seq_printf(s
, ",quota=%s", state
);
1265 if (args
->ar_suiddir
)
1266 seq_printf(s
, ",suiddir");
1267 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
1269 switch (args
->ar_data
) {
1270 case GFS2_DATA_WRITEBACK
:
1271 state
= "writeback";
1273 case GFS2_DATA_ORDERED
:
1280 seq_printf(s
, ",data=%s", state
);
1282 if (args
->ar_discard
)
1283 seq_printf(s
, ",discard");
1284 val
= sdp
->sd_tune
.gt_logd_secs
;
1286 seq_printf(s
, ",commit=%d", val
);
1287 val
= sdp
->sd_tune
.gt_statfs_quantum
;
1289 seq_printf(s
, ",statfs_quantum=%d", val
);
1290 val
= sdp
->sd_tune
.gt_quota_quantum
;
1292 seq_printf(s
, ",quota_quantum=%d", val
);
1293 if (args
->ar_statfs_percent
)
1294 seq_printf(s
, ",statfs_percent=%d", args
->ar_statfs_percent
);
1295 if (args
->ar_errors
!= GFS2_ERRORS_DEFAULT
) {
1298 switch (args
->ar_errors
) {
1299 case GFS2_ERRORS_WITHDRAW
:
1302 case GFS2_ERRORS_PANIC
:
1309 seq_printf(s
, ",errors=%s", state
);
1311 if (test_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
))
1312 seq_printf(s
, ",nobarrier");
1313 if (test_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
1314 seq_printf(s
, ",demote_interface_used");
1318 static void gfs2_final_release_pages(struct gfs2_inode
*ip
)
1320 struct inode
*inode
= &ip
->i_inode
;
1321 struct gfs2_glock
*gl
= ip
->i_gl
;
1323 truncate_inode_pages(gfs2_glock2aspace(ip
->i_gl
), 0);
1324 truncate_inode_pages(&inode
->i_data
, 0);
1326 if (atomic_read(&gl
->gl_revokes
) == 0) {
1327 clear_bit(GLF_LFLUSH
, &gl
->gl_flags
);
1328 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
1332 static int gfs2_dinode_dealloc(struct gfs2_inode
*ip
)
1334 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1335 struct gfs2_alloc
*al
;
1336 struct gfs2_rgrpd
*rgd
;
1339 if (gfs2_get_inode_blocks(&ip
->i_inode
) != 1) {
1340 if (gfs2_consist_inode(ip
))
1341 gfs2_dinode_print(ip
);
1345 al
= gfs2_alloc_get(ip
);
1349 error
= gfs2_quota_hold(ip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
1353 error
= gfs2_rindex_hold(sdp
, &al
->al_ri_gh
);
1357 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_no_addr
);
1359 gfs2_consist_inode(ip
);
1361 goto out_rindex_relse
;
1364 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0,
1367 goto out_rindex_relse
;
1369 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_STATFS
+ RES_QUOTA
, 1);
1371 goto out_rg_gunlock
;
1373 gfs2_free_di(rgd
, ip
);
1375 gfs2_final_release_pages(ip
);
1377 gfs2_trans_end(sdp
);
1380 gfs2_glock_dq_uninit(&al
->al_rgd_gh
);
1382 gfs2_glock_dq_uninit(&al
->al_ri_gh
);
1384 gfs2_quota_unhold(ip
);
1391 * We have to (at the moment) hold the inodes main lock to cover
1392 * the gap between unlocking the shared lock on the iopen lock and
1393 * taking the exclusive lock. I'd rather do a shared -> exclusive
1394 * conversion on the iopen lock, but we can change that later. This
1395 * is safe, just less efficient.
1398 static void gfs2_evict_inode(struct inode
*inode
)
1400 struct super_block
*sb
= inode
->i_sb
;
1401 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1402 struct gfs2_inode
*ip
= GFS2_I(inode
);
1403 struct gfs2_holder gh
;
1406 if (inode
->i_nlink
|| (sb
->s_flags
& MS_RDONLY
))
1409 /* Must not read inode block until block type has been verified */
1410 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_SKIP
, &gh
);
1411 if (unlikely(error
)) {
1412 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1416 error
= gfs2_check_blk_type(sdp
, ip
->i_no_addr
, GFS2_BLKST_UNLINKED
);
1420 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
1421 error
= gfs2_inode_refresh(ip
);
1426 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1427 gfs2_glock_dq_wait(&ip
->i_iopen_gh
);
1428 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, &ip
->i_iopen_gh
);
1429 error
= gfs2_glock_nq(&ip
->i_iopen_gh
);
1433 if (S_ISDIR(inode
->i_mode
) &&
1434 (ip
->i_diskflags
& GFS2_DIF_EXHASH
)) {
1435 error
= gfs2_dir_exhash_dealloc(ip
);
1441 error
= gfs2_ea_dealloc(ip
);
1446 if (!gfs2_is_stuffed(ip
)) {
1447 error
= gfs2_file_dealloc(ip
);
1452 error
= gfs2_dinode_dealloc(ip
);
1456 error
= gfs2_trans_begin(sdp
, 0, sdp
->sd_jdesc
->jd_blocks
);
1459 gfs2_final_release_pages(ip
);
1460 gfs2_trans_end(sdp
);
1463 if (test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
))
1464 gfs2_glock_dq(&ip
->i_iopen_gh
);
1465 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1466 gfs2_glock_dq_uninit(&gh
);
1467 if (error
&& error
!= GLR_TRYFAILED
&& error
!= -EROFS
)
1468 fs_warn(sdp
, "gfs2_evict_inode: %d\n", error
);
1470 truncate_inode_pages(&inode
->i_data
, 0);
1471 end_writeback(inode
);
1473 ip
->i_gl
->gl_object
= NULL
;
1474 gfs2_glock_add_to_lru(ip
->i_gl
);
1475 gfs2_glock_put(ip
->i_gl
);
1477 if (ip
->i_iopen_gh
.gh_gl
) {
1478 ip
->i_iopen_gh
.gh_gl
->gl_object
= NULL
;
1479 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1483 static struct inode
*gfs2_alloc_inode(struct super_block
*sb
)
1485 struct gfs2_inode
*ip
;
1487 ip
= kmem_cache_alloc(gfs2_inode_cachep
, GFP_KERNEL
);
1492 return &ip
->i_inode
;
1495 static void gfs2_i_callback(struct rcu_head
*head
)
1497 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
1498 INIT_LIST_HEAD(&inode
->i_dentry
);
1499 kmem_cache_free(gfs2_inode_cachep
, inode
);
1502 static void gfs2_destroy_inode(struct inode
*inode
)
1504 call_rcu(&inode
->i_rcu
, gfs2_i_callback
);
1507 const struct super_operations gfs2_super_ops
= {
1508 .alloc_inode
= gfs2_alloc_inode
,
1509 .destroy_inode
= gfs2_destroy_inode
,
1510 .write_inode
= gfs2_write_inode
,
1511 .evict_inode
= gfs2_evict_inode
,
1512 .put_super
= gfs2_put_super
,
1513 .sync_fs
= gfs2_sync_fs
,
1514 .freeze_fs
= gfs2_freeze
,
1515 .unfreeze_fs
= gfs2_unfreeze
,
1516 .statfs
= gfs2_statfs
,
1517 .remount_fs
= gfs2_remount_fs
,
1518 .drop_inode
= gfs2_drop_inode
,
1519 .show_options
= gfs2_show_options
,