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_ignore_local_fs
, "ignore_local_fs"},
89 {Opt_localflocks
, "localflocks"},
90 {Opt_localcaching
, "localcaching"},
92 {Opt_nodebug
, "nodebug"},
93 {Opt_upgrade
, "upgrade"},
96 {Opt_quota_off
, "quota=off"},
97 {Opt_quota_account
, "quota=account"},
98 {Opt_quota_on
, "quota=on"},
100 {Opt_noquota
, "noquota"},
101 {Opt_suiddir
, "suiddir"},
102 {Opt_nosuiddir
, "nosuiddir"},
103 {Opt_data_writeback
, "data=writeback"},
104 {Opt_data_ordered
, "data=ordered"},
106 {Opt_discard
, "discard"},
107 {Opt_nodiscard
, "nodiscard"},
108 {Opt_commit
, "commit=%d"},
109 {Opt_err_withdraw
, "errors=withdraw"},
110 {Opt_err_panic
, "errors=panic"},
111 {Opt_statfs_quantum
, "statfs_quantum=%d"},
112 {Opt_statfs_percent
, "statfs_percent=%d"},
113 {Opt_quota_quantum
, "quota_quantum=%d"},
114 {Opt_barrier
, "barrier"},
115 {Opt_nobarrier
, "nobarrier"},
120 * gfs2_mount_args - Parse mount options
121 * @args: The structure into which the parsed options will be written
122 * @options: The options to parse
127 int gfs2_mount_args(struct gfs2_args
*args
, char *options
)
131 substring_t tmp
[MAX_OPT_ARGS
];
134 /* Split the options into tokens with the "," character and
138 o
= strsep(&options
, ",");
144 token
= match_token(o
, tokens
, tmp
);
147 match_strlcpy(args
->ar_lockproto
, &tmp
[0],
151 match_strlcpy(args
->ar_locktable
, &tmp
[0],
155 match_strlcpy(args
->ar_hostdata
, &tmp
[0],
159 args
->ar_spectator
= 1;
161 case Opt_ignore_local_fs
:
162 args
->ar_ignore_local_fs
= 1;
164 case Opt_localflocks
:
165 args
->ar_localflocks
= 1;
167 case Opt_localcaching
:
168 args
->ar_localcaching
= 1;
171 if (args
->ar_errors
== GFS2_ERRORS_PANIC
) {
172 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
173 "are mutually exclusive.\n");
182 args
->ar_upgrade
= 1;
185 args
->ar_posix_acl
= 1;
188 args
->ar_posix_acl
= 0;
192 args
->ar_quota
= GFS2_QUOTA_OFF
;
194 case Opt_quota_account
:
195 args
->ar_quota
= GFS2_QUOTA_ACCOUNT
;
199 args
->ar_quota
= GFS2_QUOTA_ON
;
202 args
->ar_suiddir
= 1;
205 args
->ar_suiddir
= 0;
207 case Opt_data_writeback
:
208 args
->ar_data
= GFS2_DATA_WRITEBACK
;
210 case Opt_data_ordered
:
211 args
->ar_data
= GFS2_DATA_ORDERED
;
217 args
->ar_discard
= 1;
220 args
->ar_discard
= 0;
223 rv
= match_int(&tmp
[0], &args
->ar_commit
);
224 if (rv
|| args
->ar_commit
<= 0) {
225 printk(KERN_WARNING
"GFS2: commit mount option requires a positive numeric argument\n");
226 return rv
? rv
: -EINVAL
;
229 case Opt_statfs_quantum
:
230 rv
= match_int(&tmp
[0], &args
->ar_statfs_quantum
);
231 if (rv
|| args
->ar_statfs_quantum
< 0) {
232 printk(KERN_WARNING
"GFS2: statfs_quantum mount option requires a non-negative numeric argument\n");
233 return rv
? rv
: -EINVAL
;
236 case Opt_quota_quantum
:
237 rv
= match_int(&tmp
[0], &args
->ar_quota_quantum
);
238 if (rv
|| args
->ar_quota_quantum
<= 0) {
239 printk(KERN_WARNING
"GFS2: quota_quantum mount option requires a positive numeric argument\n");
240 return rv
? rv
: -EINVAL
;
243 case Opt_statfs_percent
:
244 rv
= match_int(&tmp
[0], &args
->ar_statfs_percent
);
245 if (rv
|| args
->ar_statfs_percent
< 0 ||
246 args
->ar_statfs_percent
> 100) {
247 printk(KERN_WARNING
"statfs_percent mount option requires a numeric argument between 0 and 100\n");
248 return rv
? rv
: -EINVAL
;
251 case Opt_err_withdraw
:
252 args
->ar_errors
= GFS2_ERRORS_WITHDRAW
;
255 if (args
->ar_debug
) {
256 printk(KERN_WARNING
"GFS2: -o debug and -o errors=panic "
257 "are mutually exclusive.\n");
260 args
->ar_errors
= GFS2_ERRORS_PANIC
;
263 args
->ar_nobarrier
= 0;
266 args
->ar_nobarrier
= 1;
270 printk(KERN_WARNING
"GFS2: invalid mount option: %s\n", o
);
279 * gfs2_jindex_free - Clear all the journal index information
280 * @sdp: The GFS2 superblock
284 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
286 struct list_head list
, *head
;
287 struct gfs2_jdesc
*jd
;
288 struct gfs2_journal_extent
*jext
;
290 spin_lock(&sdp
->sd_jindex_spin
);
291 list_add(&list
, &sdp
->sd_jindex_list
);
292 list_del_init(&sdp
->sd_jindex_list
);
293 sdp
->sd_journals
= 0;
294 spin_unlock(&sdp
->sd_jindex_spin
);
296 while (!list_empty(&list
)) {
297 jd
= list_entry(list
.next
, struct gfs2_jdesc
, jd_list
);
298 head
= &jd
->extent_list
;
299 while (!list_empty(head
)) {
300 jext
= list_entry(head
->next
,
301 struct gfs2_journal_extent
,
303 list_del(&jext
->extent_list
);
306 list_del(&jd
->jd_list
);
312 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
314 struct gfs2_jdesc
*jd
;
317 list_for_each_entry(jd
, head
, jd_list
) {
318 if (jd
->jd_jid
== jid
) {
330 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
332 struct gfs2_jdesc
*jd
;
334 spin_lock(&sdp
->sd_jindex_spin
);
335 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
336 spin_unlock(&sdp
->sd_jindex_spin
);
341 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
343 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
344 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
345 u64 size
= i_size_read(jd
->jd_inode
);
347 if (gfs2_check_internal_file_size(jd
->jd_inode
, 8 << 20, 1 << 30))
350 jd
->jd_blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
352 if (gfs2_write_alloc_required(ip
, 0, size
)) {
353 gfs2_consist_inode(ip
);
361 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
362 * @sdp: the filesystem
367 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
369 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
370 struct gfs2_glock
*j_gl
= ip
->i_gl
;
371 struct gfs2_holder t_gh
;
372 struct gfs2_log_header_host head
;
375 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, 0, &t_gh
);
379 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
381 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
);
385 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
391 /* Initialize some head of the log stuff */
392 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
393 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
395 error
= gfs2_quota_init(sdp
);
399 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
401 gfs2_glock_dq_uninit(&t_gh
);
406 t_gh
.gh_flags
|= GL_NOCACHE
;
407 gfs2_glock_dq_uninit(&t_gh
);
412 void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
414 const struct gfs2_statfs_change
*str
= buf
;
416 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
417 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
418 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
421 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
423 struct gfs2_statfs_change
*str
= buf
;
425 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
426 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
427 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
430 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
432 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
433 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
434 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
435 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
436 struct buffer_head
*m_bh
, *l_bh
;
437 struct gfs2_holder gh
;
440 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
445 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
449 if (sdp
->sd_args
.ar_spectator
) {
450 spin_lock(&sdp
->sd_statfs_spin
);
451 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
452 sizeof(struct gfs2_dinode
));
453 spin_unlock(&sdp
->sd_statfs_spin
);
455 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
459 spin_lock(&sdp
->sd_statfs_spin
);
460 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
461 sizeof(struct gfs2_dinode
));
462 gfs2_statfs_change_in(l_sc
, l_bh
->b_data
+
463 sizeof(struct gfs2_dinode
));
464 spin_unlock(&sdp
->sd_statfs_spin
);
472 gfs2_glock_dq_uninit(&gh
);
476 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
479 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
480 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
481 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
482 struct buffer_head
*l_bh
;
487 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
491 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
493 spin_lock(&sdp
->sd_statfs_spin
);
494 l_sc
->sc_total
+= total
;
495 l_sc
->sc_free
+= free
;
496 l_sc
->sc_dinodes
+= dinodes
;
497 gfs2_statfs_change_out(l_sc
, l_bh
->b_data
+ sizeof(struct gfs2_dinode
));
498 if (sdp
->sd_args
.ar_statfs_percent
) {
499 x
= 100 * l_sc
->sc_free
;
500 y
= m_sc
->sc_free
* sdp
->sd_args
.ar_statfs_percent
;
501 if (x
>= y
|| x
<= -y
)
504 spin_unlock(&sdp
->sd_statfs_spin
);
508 gfs2_wake_up_statfs(sdp
);
511 void update_statfs(struct gfs2_sbd
*sdp
, struct buffer_head
*m_bh
,
512 struct buffer_head
*l_bh
)
514 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
515 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
516 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
517 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
519 gfs2_trans_add_bh(l_ip
->i_gl
, l_bh
, 1);
521 spin_lock(&sdp
->sd_statfs_spin
);
522 m_sc
->sc_total
+= l_sc
->sc_total
;
523 m_sc
->sc_free
+= l_sc
->sc_free
;
524 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
525 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
526 memset(l_bh
->b_data
+ sizeof(struct gfs2_dinode
),
527 0, sizeof(struct gfs2_statfs_change
));
528 spin_unlock(&sdp
->sd_statfs_spin
);
530 gfs2_trans_add_bh(m_ip
->i_gl
, m_bh
, 1);
531 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
534 int gfs2_statfs_sync(struct super_block
*sb
, int type
)
536 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
537 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
538 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
539 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
540 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
541 struct gfs2_holder gh
;
542 struct buffer_head
*m_bh
, *l_bh
;
545 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
550 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
554 spin_lock(&sdp
->sd_statfs_spin
);
555 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
556 sizeof(struct gfs2_dinode
));
557 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
558 spin_unlock(&sdp
->sd_statfs_spin
);
561 spin_unlock(&sdp
->sd_statfs_spin
);
563 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
567 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
571 update_statfs(sdp
, m_bh
, l_bh
);
572 sdp
->sd_statfs_force_sync
= 0;
581 gfs2_glock_dq_uninit(&gh
);
586 struct list_head list
;
587 struct gfs2_holder gh
;
591 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
593 * @sdp: the file system
594 * @state: the state to put the transaction lock into
595 * @t_gh: the hold on the transaction lock
600 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
,
601 struct gfs2_holder
*t_gh
)
603 struct gfs2_inode
*ip
;
604 struct gfs2_jdesc
*jd
;
607 struct gfs2_log_header_host lh
;
610 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
611 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
616 ip
= GFS2_I(jd
->jd_inode
);
617 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
622 list_add(&lfcc
->list
, &list
);
625 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_DEFERRED
,
628 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
629 error
= gfs2_jdesc_check(jd
);
632 error
= gfs2_find_jhead(jd
, &lh
);
635 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
642 gfs2_glock_dq_uninit(t_gh
);
645 while (!list_empty(&list
)) {
646 lfcc
= list_entry(list
.next
, struct lfcc
, list
);
647 list_del(&lfcc
->list
);
648 gfs2_glock_dq_uninit(&lfcc
->gh
);
655 * gfs2_freeze_fs - freezes the file system
656 * @sdp: the file system
658 * This function flushes data and meta data for all machines by
659 * aquiring the transaction log exclusively. All journals are
660 * ensured to be in a clean state as well.
665 int gfs2_freeze_fs(struct gfs2_sbd
*sdp
)
669 mutex_lock(&sdp
->sd_freeze_lock
);
671 if (!sdp
->sd_freeze_count
++) {
672 error
= gfs2_lock_fs_check_clean(sdp
, &sdp
->sd_freeze_gh
);
674 sdp
->sd_freeze_count
--;
677 mutex_unlock(&sdp
->sd_freeze_lock
);
683 * gfs2_unfreeze_fs - unfreezes the file system
684 * @sdp: the file system
686 * This function allows the file system to proceed by unlocking
687 * the exclusively held transaction lock. Other GFS2 nodes are
688 * now free to acquire the lock shared and go on with their lives.
692 void gfs2_unfreeze_fs(struct gfs2_sbd
*sdp
)
694 mutex_lock(&sdp
->sd_freeze_lock
);
696 if (sdp
->sd_freeze_count
&& !--sdp
->sd_freeze_count
)
697 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
699 mutex_unlock(&sdp
->sd_freeze_lock
);
704 * gfs2_write_inode - Make sure the inode is stable on the disk
706 * @sync: synchronous write flag
711 static int gfs2_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
713 struct gfs2_inode
*ip
= GFS2_I(inode
);
714 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
715 struct gfs2_holder gh
;
716 struct buffer_head
*bh
;
717 struct timespec atime
;
718 struct gfs2_dinode
*di
;
721 /* Check this is a "normal" inode, etc */
722 if (current
->flags
& PF_MEMALLOC
)
724 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
727 ret
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
730 ret
= gfs2_meta_inode_buffer(ip
, &bh
);
732 di
= (struct gfs2_dinode
*)bh
->b_data
;
733 atime
.tv_sec
= be64_to_cpu(di
->di_atime
);
734 atime
.tv_nsec
= be32_to_cpu(di
->di_atime_nsec
);
735 if (timespec_compare(&inode
->i_atime
, &atime
) > 0) {
736 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
737 gfs2_dinode_out(ip
, bh
->b_data
);
743 gfs2_glock_dq_uninit(&gh
);
745 if (wbc
->sync_mode
== WB_SYNC_ALL
)
746 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
);
751 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
752 * @sdp: the filesystem
757 static int gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
759 struct gfs2_holder t_gh
;
762 flush_workqueue(gfs2_delete_workqueue
);
763 gfs2_quota_sync(sdp
->sd_vfs
, 0, 1);
764 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
766 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
, GL_NOCACHE
,
768 if (error
&& !test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
771 gfs2_meta_syncfs(sdp
);
772 gfs2_log_shutdown(sdp
);
774 clear_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
777 gfs2_glock_dq_uninit(&t_gh
);
779 gfs2_quota_cleanup(sdp
);
784 static int gfs2_umount_recovery_wait(void *word
)
791 * gfs2_put_super - Unmount the filesystem
792 * @sb: The VFS superblock
796 static void gfs2_put_super(struct super_block
*sb
)
798 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
800 struct gfs2_jdesc
*jd
;
802 /* Unfreeze the filesystem, if we need to */
804 mutex_lock(&sdp
->sd_freeze_lock
);
805 if (sdp
->sd_freeze_count
)
806 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
807 mutex_unlock(&sdp
->sd_freeze_lock
);
809 /* No more recovery requests */
810 set_bit(SDF_NORECOVERY
, &sdp
->sd_flags
);
813 /* Wait on outstanding recovery */
815 spin_lock(&sdp
->sd_jindex_spin
);
816 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
817 if (!test_bit(JDF_RECOVERY
, &jd
->jd_flags
))
819 spin_unlock(&sdp
->sd_jindex_spin
);
820 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
821 gfs2_umount_recovery_wait
, TASK_UNINTERRUPTIBLE
);
824 spin_unlock(&sdp
->sd_jindex_spin
);
826 kthread_stop(sdp
->sd_quotad_process
);
827 kthread_stop(sdp
->sd_logd_process
);
829 if (!(sb
->s_flags
& MS_RDONLY
)) {
830 error
= gfs2_make_fs_ro(sdp
);
834 /* At this point, we're through modifying the disk */
838 iput(sdp
->sd_jindex
);
839 iput(sdp
->sd_statfs_inode
);
840 iput(sdp
->sd_rindex
);
841 iput(sdp
->sd_quota_inode
);
843 gfs2_glock_put(sdp
->sd_rename_gl
);
844 gfs2_glock_put(sdp
->sd_trans_gl
);
846 if (!sdp
->sd_args
.ar_spectator
) {
847 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
848 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
849 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
850 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
851 iput(sdp
->sd_sc_inode
);
852 iput(sdp
->sd_qc_inode
);
855 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
856 gfs2_clear_rgrpd(sdp
);
857 gfs2_jindex_free(sdp
);
858 /* Take apart glock structures and buffer lists */
859 invalidate_inodes(sdp
->sd_vfs
);
860 gfs2_gl_hash_clear(sdp
);
861 /* Unmount the locking protocol */
862 gfs2_lm_unmount(sdp
);
864 /* At this point, we're through participating in the lockspace */
865 gfs2_sys_fs_del(sdp
);
869 * gfs2_sync_fs - sync the filesystem
870 * @sb: the superblock
872 * Flushes the log to disk.
875 static int gfs2_sync_fs(struct super_block
*sb
, int wait
)
877 if (wait
&& sb
->s_fs_info
)
878 gfs2_log_flush(sb
->s_fs_info
, NULL
);
883 * gfs2_freeze - prevent further writes to the filesystem
884 * @sb: the VFS structure for the filesystem
888 static int gfs2_freeze(struct super_block
*sb
)
890 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
893 if (test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
))
897 error
= gfs2_freeze_fs(sdp
);
903 fs_err(sdp
, "waiting for recovery before freeze\n");
907 fs_err(sdp
, "error freezing FS: %d\n", error
);
911 fs_err(sdp
, "retrying...\n");
918 * gfs2_unfreeze - reallow writes to the filesystem
919 * @sb: the VFS structure for the filesystem
923 static int gfs2_unfreeze(struct super_block
*sb
)
925 gfs2_unfreeze_fs(sb
->s_fs_info
);
930 * statfs_fill - fill in the sg for a given RG
932 * @sc: the sc structure
934 * Returns: 0 on success, -ESTALE if the LVB is invalid
937 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
938 struct gfs2_statfs_change_host
*sc
)
940 gfs2_rgrp_verify(rgd
);
941 sc
->sc_total
+= rgd
->rd_data
;
942 sc
->sc_free
+= rgd
->rd_free
;
943 sc
->sc_dinodes
+= rgd
->rd_dinodes
;
948 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
949 * @sdp: the filesystem
950 * @sc: the sc info that will be returned
952 * Any error (other than a signal) will cause this routine to fall back
953 * to the synchronous version.
955 * FIXME: This really shouldn't busy wait like this.
960 static int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
962 struct gfs2_holder ri_gh
;
963 struct gfs2_rgrpd
*rgd_next
;
964 struct gfs2_holder
*gha
, *gh
;
965 unsigned int slots
= 64;
970 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
971 gha
= kcalloc(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
975 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
979 rgd_next
= gfs2_rgrpd_get_first(sdp
);
984 for (x
= 0; x
< slots
; x
++) {
987 if (gh
->gh_gl
&& gfs2_glock_poll(gh
)) {
988 err
= gfs2_glock_wait(gh
);
990 gfs2_holder_uninit(gh
);
994 error
= statfs_slow_fill(
995 gh
->gh_gl
->gl_object
, sc
);
996 gfs2_glock_dq_uninit(gh
);
1002 else if (rgd_next
&& !error
) {
1003 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
1007 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
1011 if (signal_pending(current
))
1012 error
= -ERESTARTSYS
;
1021 gfs2_glock_dq_uninit(&ri_gh
);
1029 * gfs2_statfs_i - Do a statfs
1030 * @sdp: the filesystem
1031 * @sg: the sg structure
1036 static int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
1038 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
1039 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
1041 spin_lock(&sdp
->sd_statfs_spin
);
1044 sc
->sc_total
+= l_sc
->sc_total
;
1045 sc
->sc_free
+= l_sc
->sc_free
;
1046 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
1048 spin_unlock(&sdp
->sd_statfs_spin
);
1050 if (sc
->sc_free
< 0)
1052 if (sc
->sc_free
> sc
->sc_total
)
1053 sc
->sc_free
= sc
->sc_total
;
1054 if (sc
->sc_dinodes
< 0)
1061 * gfs2_statfs - Gather and return stats about the filesystem
1062 * @sb: The superblock
1063 * @statfsbuf: The buffer
1065 * Returns: 0 on success or error code
1068 static int gfs2_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1070 struct super_block
*sb
= dentry
->d_inode
->i_sb
;
1071 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1072 struct gfs2_statfs_change_host sc
;
1075 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
1076 error
= gfs2_statfs_slow(sdp
, &sc
);
1078 error
= gfs2_statfs_i(sdp
, &sc
);
1083 buf
->f_type
= GFS2_MAGIC
;
1084 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
1085 buf
->f_blocks
= sc
.sc_total
;
1086 buf
->f_bfree
= sc
.sc_free
;
1087 buf
->f_bavail
= sc
.sc_free
;
1088 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
1089 buf
->f_ffree
= sc
.sc_free
;
1090 buf
->f_namelen
= GFS2_FNAMESIZE
;
1096 * gfs2_remount_fs - called when the FS is remounted
1097 * @sb: the filesystem
1098 * @flags: the remount flags
1099 * @data: extra data passed in (not used right now)
1104 static int gfs2_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
1106 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1107 struct gfs2_args args
= sdp
->sd_args
; /* Default to current settings */
1108 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
1111 spin_lock(>
->gt_spin
);
1112 args
.ar_commit
= gt
->gt_logd_secs
;
1113 args
.ar_quota_quantum
= gt
->gt_quota_quantum
;
1114 if (gt
->gt_statfs_slow
)
1115 args
.ar_statfs_quantum
= 0;
1117 args
.ar_statfs_quantum
= gt
->gt_statfs_quantum
;
1118 spin_unlock(>
->gt_spin
);
1119 error
= gfs2_mount_args(&args
, data
);
1123 /* Not allowed to change locking details */
1124 if (strcmp(args
.ar_lockproto
, sdp
->sd_args
.ar_lockproto
) ||
1125 strcmp(args
.ar_locktable
, sdp
->sd_args
.ar_locktable
) ||
1126 strcmp(args
.ar_hostdata
, sdp
->sd_args
.ar_hostdata
))
1129 /* Some flags must not be changed */
1130 if (args_neq(&args
, &sdp
->sd_args
, spectator
) ||
1131 args_neq(&args
, &sdp
->sd_args
, ignore_local_fs
) ||
1132 args_neq(&args
, &sdp
->sd_args
, localflocks
) ||
1133 args_neq(&args
, &sdp
->sd_args
, localcaching
) ||
1134 args_neq(&args
, &sdp
->sd_args
, meta
))
1137 if (sdp
->sd_args
.ar_spectator
)
1138 *flags
|= MS_RDONLY
;
1140 if ((sb
->s_flags
^ *flags
) & MS_RDONLY
) {
1141 if (*flags
& MS_RDONLY
)
1142 error
= gfs2_make_fs_ro(sdp
);
1144 error
= gfs2_make_fs_rw(sdp
);
1149 sdp
->sd_args
= args
;
1150 if (sdp
->sd_args
.ar_posix_acl
)
1151 sb
->s_flags
|= MS_POSIXACL
;
1153 sb
->s_flags
&= ~MS_POSIXACL
;
1154 if (sdp
->sd_args
.ar_nobarrier
)
1155 set_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1157 clear_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
);
1158 spin_lock(>
->gt_spin
);
1159 gt
->gt_logd_secs
= args
.ar_commit
;
1160 gt
->gt_quota_quantum
= args
.ar_quota_quantum
;
1161 if (args
.ar_statfs_quantum
) {
1162 gt
->gt_statfs_slow
= 0;
1163 gt
->gt_statfs_quantum
= args
.ar_statfs_quantum
;
1166 gt
->gt_statfs_slow
= 1;
1167 gt
->gt_statfs_quantum
= 30;
1169 spin_unlock(>
->gt_spin
);
1171 gfs2_online_uevent(sdp
);
1176 * gfs2_drop_inode - Drop an inode (test for remote unlink)
1177 * @inode: The inode to drop
1179 * If we've received a callback on an iopen lock then its because a
1180 * remote node tried to deallocate the inode but failed due to this node
1181 * still having the inode open. Here we mark the link count zero
1182 * since we know that it must have reached zero if the GLF_DEMOTE flag
1183 * is set on the iopen glock. If we didn't do a disk read since the
1184 * remote node removed the final link then we might otherwise miss
1185 * this event. This check ensures that this node will deallocate the
1186 * inode's blocks, or alternatively pass the baton on to another
1187 * node for later deallocation.
1190 static int gfs2_drop_inode(struct inode
*inode
)
1192 struct gfs2_inode
*ip
= GFS2_I(inode
);
1194 if (inode
->i_nlink
) {
1195 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1196 if (gl
&& test_bit(GLF_DEMOTE
, &gl
->gl_flags
))
1199 return generic_drop_inode(inode
);
1202 static int is_ancestor(const struct dentry
*d1
, const struct dentry
*d2
)
1208 } while (!IS_ROOT(d1
));
1213 * gfs2_show_options - Show mount options for /proc/mounts
1214 * @s: seq_file structure
1217 * Returns: 0 on success or error code
1220 static int gfs2_show_options(struct seq_file
*s
, struct vfsmount
*mnt
)
1222 struct gfs2_sbd
*sdp
= mnt
->mnt_sb
->s_fs_info
;
1223 struct gfs2_args
*args
= &sdp
->sd_args
;
1226 if (is_ancestor(mnt
->mnt_root
, sdp
->sd_master_dir
))
1227 seq_printf(s
, ",meta");
1228 if (args
->ar_lockproto
[0])
1229 seq_printf(s
, ",lockproto=%s", args
->ar_lockproto
);
1230 if (args
->ar_locktable
[0])
1231 seq_printf(s
, ",locktable=%s", args
->ar_locktable
);
1232 if (args
->ar_hostdata
[0])
1233 seq_printf(s
, ",hostdata=%s", args
->ar_hostdata
);
1234 if (args
->ar_spectator
)
1235 seq_printf(s
, ",spectator");
1236 if (args
->ar_ignore_local_fs
)
1237 seq_printf(s
, ",ignore_local_fs");
1238 if (args
->ar_localflocks
)
1239 seq_printf(s
, ",localflocks");
1240 if (args
->ar_localcaching
)
1241 seq_printf(s
, ",localcaching");
1243 seq_printf(s
, ",debug");
1244 if (args
->ar_upgrade
)
1245 seq_printf(s
, ",upgrade");
1246 if (args
->ar_posix_acl
)
1247 seq_printf(s
, ",acl");
1248 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
1250 switch (args
->ar_quota
) {
1251 case GFS2_QUOTA_OFF
:
1254 case GFS2_QUOTA_ACCOUNT
:
1264 seq_printf(s
, ",quota=%s", state
);
1266 if (args
->ar_suiddir
)
1267 seq_printf(s
, ",suiddir");
1268 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
1270 switch (args
->ar_data
) {
1271 case GFS2_DATA_WRITEBACK
:
1272 state
= "writeback";
1274 case GFS2_DATA_ORDERED
:
1281 seq_printf(s
, ",data=%s", state
);
1283 if (args
->ar_discard
)
1284 seq_printf(s
, ",discard");
1285 val
= sdp
->sd_tune
.gt_logd_secs
;
1287 seq_printf(s
, ",commit=%d", val
);
1288 val
= sdp
->sd_tune
.gt_statfs_quantum
;
1290 seq_printf(s
, ",statfs_quantum=%d", val
);
1291 val
= sdp
->sd_tune
.gt_quota_quantum
;
1293 seq_printf(s
, ",quota_quantum=%d", val
);
1294 if (args
->ar_statfs_percent
)
1295 seq_printf(s
, ",statfs_percent=%d", args
->ar_statfs_percent
);
1296 if (args
->ar_errors
!= GFS2_ERRORS_DEFAULT
) {
1299 switch (args
->ar_errors
) {
1300 case GFS2_ERRORS_WITHDRAW
:
1303 case GFS2_ERRORS_PANIC
:
1310 seq_printf(s
, ",errors=%s", state
);
1312 if (test_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
))
1313 seq_printf(s
, ",nobarrier");
1314 if (test_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
1315 seq_printf(s
, ",demote_interface_used");
1320 * We have to (at the moment) hold the inodes main lock to cover
1321 * the gap between unlocking the shared lock on the iopen lock and
1322 * taking the exclusive lock. I'd rather do a shared -> exclusive
1323 * conversion on the iopen lock, but we can change that later. This
1324 * is safe, just less efficient.
1327 static void gfs2_evict_inode(struct inode
*inode
)
1329 struct gfs2_sbd
*sdp
= inode
->i_sb
->s_fs_info
;
1330 struct gfs2_inode
*ip
= GFS2_I(inode
);
1331 struct gfs2_holder gh
;
1337 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1338 if (unlikely(error
)) {
1339 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1343 error
= gfs2_check_blk_type(sdp
, ip
->i_no_addr
, GFS2_BLKST_UNLINKED
);
1347 gfs2_glock_dq_wait(&ip
->i_iopen_gh
);
1348 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, &ip
->i_iopen_gh
);
1349 error
= gfs2_glock_nq(&ip
->i_iopen_gh
);
1353 if (S_ISDIR(inode
->i_mode
) &&
1354 (ip
->i_diskflags
& GFS2_DIF_EXHASH
)) {
1355 error
= gfs2_dir_exhash_dealloc(ip
);
1361 error
= gfs2_ea_dealloc(ip
);
1366 if (!gfs2_is_stuffed(ip
)) {
1367 error
= gfs2_file_dealloc(ip
);
1372 error
= gfs2_dinode_dealloc(ip
);
1377 error
= gfs2_trans_begin(sdp
, 0, sdp
->sd_jdesc
->jd_blocks
);
1380 /* Needs to be done before glock release & also in a transaction */
1381 truncate_inode_pages(&inode
->i_data
, 0);
1382 gfs2_trans_end(sdp
);
1385 if (test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
))
1386 gfs2_glock_dq(&ip
->i_iopen_gh
);
1387 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1388 gfs2_glock_dq_uninit(&gh
);
1389 if (error
&& error
!= GLR_TRYFAILED
&& error
!= -EROFS
)
1390 fs_warn(sdp
, "gfs2_evict_inode: %d\n", error
);
1392 truncate_inode_pages(&inode
->i_data
, 0);
1393 end_writeback(inode
);
1395 ip
->i_gl
->gl_object
= NULL
;
1396 gfs2_glock_put(ip
->i_gl
);
1398 if (ip
->i_iopen_gh
.gh_gl
) {
1399 ip
->i_iopen_gh
.gh_gl
->gl_object
= NULL
;
1400 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1404 static struct inode
*gfs2_alloc_inode(struct super_block
*sb
)
1406 struct gfs2_inode
*ip
;
1408 ip
= kmem_cache_alloc(gfs2_inode_cachep
, GFP_KERNEL
);
1413 return &ip
->i_inode
;
1416 static void gfs2_destroy_inode(struct inode
*inode
)
1418 kmem_cache_free(gfs2_inode_cachep
, inode
);
1421 const struct super_operations gfs2_super_ops
= {
1422 .alloc_inode
= gfs2_alloc_inode
,
1423 .destroy_inode
= gfs2_destroy_inode
,
1424 .write_inode
= gfs2_write_inode
,
1425 .evict_inode
= gfs2_evict_inode
,
1426 .put_super
= gfs2_put_super
,
1427 .sync_fs
= gfs2_sync_fs
,
1428 .freeze_fs
= gfs2_freeze
,
1429 .unfreeze_fs
= gfs2_unfreeze
,
1430 .statfs
= gfs2_statfs
,
1431 .remount_fs
= gfs2_remount_fs
,
1432 .drop_inode
= gfs2_drop_inode
,
1433 .show_options
= gfs2_show_options
,