1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/sched/signal.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/statfs.h>
16 #include <linux/seq_file.h>
17 #include <linux/mount.h>
18 #include <linux/kthread.h>
19 #include <linux/delay.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/crc32.h>
22 #include <linux/time.h>
23 #include <linux/wait.h>
24 #include <linux/writeback.h>
25 #include <linux/backing-dev.h>
26 #include <linux/kernel.h>
48 * gfs2_jindex_free - Clear all the journal index information
49 * @sdp: The GFS2 superblock
53 void gfs2_jindex_free(struct gfs2_sbd
*sdp
)
55 struct list_head list
;
56 struct gfs2_jdesc
*jd
;
58 spin_lock(&sdp
->sd_jindex_spin
);
59 list_add(&list
, &sdp
->sd_jindex_list
);
60 list_del_init(&sdp
->sd_jindex_list
);
62 spin_unlock(&sdp
->sd_jindex_spin
);
65 while (!list_empty(&list
)) {
66 jd
= list_first_entry(&list
, struct gfs2_jdesc
, jd_list
);
67 gfs2_free_journal_extents(jd
);
68 list_del(&jd
->jd_list
);
75 static struct gfs2_jdesc
*jdesc_find_i(struct list_head
*head
, unsigned int jid
)
77 struct gfs2_jdesc
*jd
;
80 list_for_each_entry(jd
, head
, jd_list
) {
81 if (jd
->jd_jid
== jid
) {
93 struct gfs2_jdesc
*gfs2_jdesc_find(struct gfs2_sbd
*sdp
, unsigned int jid
)
95 struct gfs2_jdesc
*jd
;
97 spin_lock(&sdp
->sd_jindex_spin
);
98 jd
= jdesc_find_i(&sdp
->sd_jindex_list
, jid
);
99 spin_unlock(&sdp
->sd_jindex_spin
);
104 int gfs2_jdesc_check(struct gfs2_jdesc
*jd
)
106 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
107 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
108 u64 size
= i_size_read(jd
->jd_inode
);
110 if (gfs2_check_internal_file_size(jd
->jd_inode
, 8 << 20, BIT(30)))
113 jd
->jd_blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
115 if (gfs2_write_alloc_required(ip
, 0, size
)) {
116 gfs2_consist_inode(ip
);
123 static int init_threads(struct gfs2_sbd
*sdp
)
125 struct task_struct
*p
;
128 p
= kthread_run(gfs2_logd
, sdp
, "gfs2_logd");
131 fs_err(sdp
, "can't start logd thread: %d\n", error
);
134 sdp
->sd_logd_process
= p
;
136 p
= kthread_run(gfs2_quotad
, sdp
, "gfs2_quotad");
139 fs_err(sdp
, "can't start quotad thread: %d\n", error
);
142 sdp
->sd_quotad_process
= p
;
146 kthread_stop(sdp
->sd_logd_process
);
147 sdp
->sd_logd_process
= NULL
;
152 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
153 * @sdp: the filesystem
158 int gfs2_make_fs_rw(struct gfs2_sbd
*sdp
)
160 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
161 struct gfs2_glock
*j_gl
= ip
->i_gl
;
162 struct gfs2_holder freeze_gh
;
163 struct gfs2_log_header_host head
;
166 error
= init_threads(sdp
);
170 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_SHARED
,
171 LM_FLAG_NOEXP
| GL_EXACT
,
176 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
177 if (gfs2_withdrawn(sdp
)) {
182 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
, false);
183 if (error
|| gfs2_withdrawn(sdp
))
186 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
192 /* Initialize some head of the log stuff */
193 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
194 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
196 error
= gfs2_quota_init(sdp
);
197 if (error
|| gfs2_withdrawn(sdp
))
200 set_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
202 gfs2_glock_dq_uninit(&freeze_gh
);
207 gfs2_glock_dq_uninit(&freeze_gh
);
209 if (sdp
->sd_quotad_process
)
210 kthread_stop(sdp
->sd_quotad_process
);
211 sdp
->sd_quotad_process
= NULL
;
212 if (sdp
->sd_logd_process
)
213 kthread_stop(sdp
->sd_logd_process
);
214 sdp
->sd_logd_process
= NULL
;
218 void gfs2_statfs_change_in(struct gfs2_statfs_change_host
*sc
, const void *buf
)
220 const struct gfs2_statfs_change
*str
= buf
;
222 sc
->sc_total
= be64_to_cpu(str
->sc_total
);
223 sc
->sc_free
= be64_to_cpu(str
->sc_free
);
224 sc
->sc_dinodes
= be64_to_cpu(str
->sc_dinodes
);
227 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host
*sc
, void *buf
)
229 struct gfs2_statfs_change
*str
= buf
;
231 str
->sc_total
= cpu_to_be64(sc
->sc_total
);
232 str
->sc_free
= cpu_to_be64(sc
->sc_free
);
233 str
->sc_dinodes
= cpu_to_be64(sc
->sc_dinodes
);
236 int gfs2_statfs_init(struct gfs2_sbd
*sdp
)
238 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
239 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
240 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
241 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
242 struct buffer_head
*m_bh
, *l_bh
;
243 struct gfs2_holder gh
;
246 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
251 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
255 if (sdp
->sd_args
.ar_spectator
) {
256 spin_lock(&sdp
->sd_statfs_spin
);
257 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
258 sizeof(struct gfs2_dinode
));
259 spin_unlock(&sdp
->sd_statfs_spin
);
261 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
265 spin_lock(&sdp
->sd_statfs_spin
);
266 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
267 sizeof(struct gfs2_dinode
));
268 gfs2_statfs_change_in(l_sc
, l_bh
->b_data
+
269 sizeof(struct gfs2_dinode
));
270 spin_unlock(&sdp
->sd_statfs_spin
);
278 gfs2_glock_dq_uninit(&gh
);
282 void gfs2_statfs_change(struct gfs2_sbd
*sdp
, s64 total
, s64 free
,
285 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
286 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
287 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
288 struct buffer_head
*l_bh
;
293 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
297 gfs2_trans_add_meta(l_ip
->i_gl
, l_bh
);
299 spin_lock(&sdp
->sd_statfs_spin
);
300 l_sc
->sc_total
+= total
;
301 l_sc
->sc_free
+= free
;
302 l_sc
->sc_dinodes
+= dinodes
;
303 gfs2_statfs_change_out(l_sc
, l_bh
->b_data
+ sizeof(struct gfs2_dinode
));
304 if (sdp
->sd_args
.ar_statfs_percent
) {
305 x
= 100 * l_sc
->sc_free
;
306 y
= m_sc
->sc_free
* sdp
->sd_args
.ar_statfs_percent
;
307 if (x
>= y
|| x
<= -y
)
310 spin_unlock(&sdp
->sd_statfs_spin
);
314 gfs2_wake_up_statfs(sdp
);
317 void update_statfs(struct gfs2_sbd
*sdp
, struct buffer_head
*m_bh
,
318 struct buffer_head
*l_bh
)
320 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
321 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
322 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
323 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
325 gfs2_trans_add_meta(l_ip
->i_gl
, l_bh
);
326 gfs2_trans_add_meta(m_ip
->i_gl
, m_bh
);
328 spin_lock(&sdp
->sd_statfs_spin
);
329 m_sc
->sc_total
+= l_sc
->sc_total
;
330 m_sc
->sc_free
+= l_sc
->sc_free
;
331 m_sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
332 memset(l_sc
, 0, sizeof(struct gfs2_statfs_change
));
333 memset(l_bh
->b_data
+ sizeof(struct gfs2_dinode
),
334 0, sizeof(struct gfs2_statfs_change
));
335 gfs2_statfs_change_out(m_sc
, m_bh
->b_data
+ sizeof(struct gfs2_dinode
));
336 spin_unlock(&sdp
->sd_statfs_spin
);
339 int gfs2_statfs_sync(struct super_block
*sb
, int type
)
341 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
342 struct gfs2_inode
*m_ip
= GFS2_I(sdp
->sd_statfs_inode
);
343 struct gfs2_inode
*l_ip
= GFS2_I(sdp
->sd_sc_inode
);
344 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
345 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
346 struct gfs2_holder gh
;
347 struct buffer_head
*m_bh
, *l_bh
;
351 error
= gfs2_glock_nq_init(m_ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_NOCACHE
,
356 error
= gfs2_meta_inode_buffer(m_ip
, &m_bh
);
360 spin_lock(&sdp
->sd_statfs_spin
);
361 gfs2_statfs_change_in(m_sc
, m_bh
->b_data
+
362 sizeof(struct gfs2_dinode
));
363 if (!l_sc
->sc_total
&& !l_sc
->sc_free
&& !l_sc
->sc_dinodes
) {
364 spin_unlock(&sdp
->sd_statfs_spin
);
367 spin_unlock(&sdp
->sd_statfs_spin
);
369 error
= gfs2_meta_inode_buffer(l_ip
, &l_bh
);
373 error
= gfs2_trans_begin(sdp
, 2 * RES_DINODE
, 0);
377 update_statfs(sdp
, m_bh
, l_bh
);
378 sdp
->sd_statfs_force_sync
= 0;
387 gfs2_glock_dq_uninit(&gh
);
394 struct list_head list
;
395 struct gfs2_holder gh
;
399 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
401 * @sdp: the file system
402 * @state: the state to put the transaction lock into
403 * @t_gh: the hold on the transaction lock
408 static int gfs2_lock_fs_check_clean(struct gfs2_sbd
*sdp
)
410 struct gfs2_inode
*ip
;
411 struct gfs2_jdesc
*jd
;
414 struct gfs2_log_header_host lh
;
417 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
418 lfcc
= kmalloc(sizeof(struct lfcc
), GFP_KERNEL
);
423 ip
= GFS2_I(jd
->jd_inode
);
424 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &lfcc
->gh
);
429 list_add(&lfcc
->list
, &list
);
432 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_EXCLUSIVE
,
433 LM_FLAG_NOEXP
, &sdp
->sd_freeze_gh
);
437 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
438 error
= gfs2_jdesc_check(jd
);
441 error
= gfs2_find_jhead(jd
, &lh
, false);
444 if (!(lh
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
451 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
454 while (!list_empty(&list
)) {
455 lfcc
= list_first_entry(&list
, struct lfcc
, list
);
456 list_del(&lfcc
->list
);
457 gfs2_glock_dq_uninit(&lfcc
->gh
);
463 void gfs2_dinode_out(const struct gfs2_inode
*ip
, void *buf
)
465 struct gfs2_dinode
*str
= buf
;
467 str
->di_header
.mh_magic
= cpu_to_be32(GFS2_MAGIC
);
468 str
->di_header
.mh_type
= cpu_to_be32(GFS2_METATYPE_DI
);
469 str
->di_header
.mh_format
= cpu_to_be32(GFS2_FORMAT_DI
);
470 str
->di_num
.no_addr
= cpu_to_be64(ip
->i_no_addr
);
471 str
->di_num
.no_formal_ino
= cpu_to_be64(ip
->i_no_formal_ino
);
472 str
->di_mode
= cpu_to_be32(ip
->i_inode
.i_mode
);
473 str
->di_uid
= cpu_to_be32(i_uid_read(&ip
->i_inode
));
474 str
->di_gid
= cpu_to_be32(i_gid_read(&ip
->i_inode
));
475 str
->di_nlink
= cpu_to_be32(ip
->i_inode
.i_nlink
);
476 str
->di_size
= cpu_to_be64(i_size_read(&ip
->i_inode
));
477 str
->di_blocks
= cpu_to_be64(gfs2_get_inode_blocks(&ip
->i_inode
));
478 str
->di_atime
= cpu_to_be64(ip
->i_inode
.i_atime
.tv_sec
);
479 str
->di_mtime
= cpu_to_be64(ip
->i_inode
.i_mtime
.tv_sec
);
480 str
->di_ctime
= cpu_to_be64(ip
->i_inode
.i_ctime
.tv_sec
);
482 str
->di_goal_meta
= cpu_to_be64(ip
->i_goal
);
483 str
->di_goal_data
= cpu_to_be64(ip
->i_goal
);
484 str
->di_generation
= cpu_to_be64(ip
->i_generation
);
486 str
->di_flags
= cpu_to_be32(ip
->i_diskflags
);
487 str
->di_height
= cpu_to_be16(ip
->i_height
);
488 str
->di_payload_format
= cpu_to_be32(S_ISDIR(ip
->i_inode
.i_mode
) &&
489 !(ip
->i_diskflags
& GFS2_DIF_EXHASH
) ?
491 str
->di_depth
= cpu_to_be16(ip
->i_depth
);
492 str
->di_entries
= cpu_to_be32(ip
->i_entries
);
494 str
->di_eattr
= cpu_to_be64(ip
->i_eattr
);
495 str
->di_atime_nsec
= cpu_to_be32(ip
->i_inode
.i_atime
.tv_nsec
);
496 str
->di_mtime_nsec
= cpu_to_be32(ip
->i_inode
.i_mtime
.tv_nsec
);
497 str
->di_ctime_nsec
= cpu_to_be32(ip
->i_inode
.i_ctime
.tv_nsec
);
501 * gfs2_write_inode - Make sure the inode is stable on the disk
503 * @wbc: The writeback control structure
508 static int gfs2_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
510 struct gfs2_inode
*ip
= GFS2_I(inode
);
511 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
512 struct address_space
*metamapping
= gfs2_glock2aspace(ip
->i_gl
);
513 struct backing_dev_info
*bdi
= inode_to_bdi(metamapping
->host
);
515 bool flush_all
= (wbc
->sync_mode
== WB_SYNC_ALL
|| gfs2_is_jdata(ip
));
518 gfs2_log_flush(GFS2_SB(inode
), ip
->i_gl
,
519 GFS2_LOG_HEAD_FLUSH_NORMAL
|
520 GFS2_LFC_WRITE_INODE
);
521 if (bdi
->wb
.dirty_exceeded
)
522 gfs2_ail1_flush(sdp
, wbc
);
524 filemap_fdatawrite(metamapping
);
526 ret
= filemap_fdatawait(metamapping
);
528 mark_inode_dirty_sync(inode
);
530 spin_lock(&inode
->i_lock
);
531 if (!(inode
->i_flags
& I_DIRTY
))
532 gfs2_ordered_del_inode(ip
);
533 spin_unlock(&inode
->i_lock
);
539 * gfs2_dirty_inode - check for atime updates
540 * @inode: The inode in question
541 * @flags: The type of dirty
543 * Unfortunately it can be called under any combination of inode
544 * glock and transaction lock, so we have to check carefully.
546 * At the moment this deals only with atime - it should be possible
547 * to expand that role in future, once a review of the locking has
551 static void gfs2_dirty_inode(struct inode
*inode
, int flags
)
553 struct gfs2_inode
*ip
= GFS2_I(inode
);
554 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
555 struct buffer_head
*bh
;
556 struct gfs2_holder gh
;
558 int need_endtrans
= 0;
561 if (!(flags
& I_DIRTY_INODE
))
563 if (unlikely(gfs2_withdrawn(sdp
)))
565 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
566 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
568 fs_err(sdp
, "dirty_inode: glock %d\n", ret
);
572 } else if (WARN_ON_ONCE(ip
->i_gl
->gl_state
!= LM_ST_EXCLUSIVE
))
575 if (current
->journal_info
== NULL
) {
576 ret
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
578 fs_err(sdp
, "dirty_inode: gfs2_trans_begin %d\n", ret
);
584 ret
= gfs2_meta_inode_buffer(ip
, &bh
);
586 gfs2_trans_add_meta(ip
->i_gl
, bh
);
587 gfs2_dinode_out(ip
, bh
->b_data
);
595 gfs2_glock_dq_uninit(&gh
);
599 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
600 * @sdp: the filesystem
605 int gfs2_make_fs_ro(struct gfs2_sbd
*sdp
)
607 struct gfs2_holder freeze_gh
;
609 int log_write_allowed
= test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
);
611 gfs2_holder_mark_uninitialized(&freeze_gh
);
612 if (sdp
->sd_freeze_gl
&&
613 !gfs2_glock_is_locked_by_me(sdp
->sd_freeze_gl
)) {
614 if (!log_write_allowed
) {
615 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
,
616 LM_ST_SHARED
, LM_FLAG_TRY
|
617 LM_FLAG_NOEXP
| GL_EXACT
,
619 if (error
== GLR_TRYFAILED
)
622 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
,
624 LM_FLAG_NOEXP
| GL_EXACT
,
626 if (error
&& !gfs2_withdrawn(sdp
))
631 gfs2_flush_delete_work(sdp
);
632 if (!log_write_allowed
&& current
== sdp
->sd_quotad_process
)
633 fs_warn(sdp
, "The quotad daemon is withdrawing.\n");
634 else if (sdp
->sd_quotad_process
)
635 kthread_stop(sdp
->sd_quotad_process
);
636 sdp
->sd_quotad_process
= NULL
;
638 if (!log_write_allowed
&& current
== sdp
->sd_logd_process
)
639 fs_warn(sdp
, "The logd daemon is withdrawing.\n");
640 else if (sdp
->sd_logd_process
)
641 kthread_stop(sdp
->sd_logd_process
);
642 sdp
->sd_logd_process
= NULL
;
644 if (log_write_allowed
) {
645 gfs2_quota_sync(sdp
->sd_vfs
, 0);
646 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
648 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_SHUTDOWN
|
649 GFS2_LFC_MAKE_FS_RO
);
650 wait_event(sdp
->sd_reserving_log_wait
,
651 atomic_read(&sdp
->sd_reserving_log
) == 0);
652 gfs2_assert_warn(sdp
, atomic_read(&sdp
->sd_log_blks_free
) ==
653 sdp
->sd_jdesc
->jd_blocks
);
655 wait_event_timeout(sdp
->sd_reserving_log_wait
,
656 atomic_read(&sdp
->sd_reserving_log
) == 0,
659 if (gfs2_holder_initialized(&freeze_gh
))
660 gfs2_glock_dq_uninit(&freeze_gh
);
662 gfs2_quota_cleanup(sdp
);
664 if (!log_write_allowed
)
665 sdp
->sd_vfs
->s_flags
|= SB_RDONLY
;
671 * gfs2_put_super - Unmount the filesystem
672 * @sb: The VFS superblock
676 static void gfs2_put_super(struct super_block
*sb
)
678 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
680 struct gfs2_jdesc
*jd
;
682 /* No more recovery requests */
683 set_bit(SDF_NORECOVERY
, &sdp
->sd_flags
);
686 /* Wait on outstanding recovery */
688 spin_lock(&sdp
->sd_jindex_spin
);
689 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
690 if (!test_bit(JDF_RECOVERY
, &jd
->jd_flags
))
692 spin_unlock(&sdp
->sd_jindex_spin
);
693 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
694 TASK_UNINTERRUPTIBLE
);
697 spin_unlock(&sdp
->sd_jindex_spin
);
699 if (!sb_rdonly(sb
)) {
700 error
= gfs2_make_fs_ro(sdp
);
704 /* At this point, we're through modifying the disk */
708 iput(sdp
->sd_jindex
);
709 iput(sdp
->sd_statfs_inode
);
710 iput(sdp
->sd_rindex
);
711 iput(sdp
->sd_quota_inode
);
713 gfs2_glock_put(sdp
->sd_rename_gl
);
714 gfs2_glock_put(sdp
->sd_freeze_gl
);
716 if (!sdp
->sd_args
.ar_spectator
) {
717 if (gfs2_holder_initialized(&sdp
->sd_journal_gh
))
718 gfs2_glock_dq_uninit(&sdp
->sd_journal_gh
);
719 if (gfs2_holder_initialized(&sdp
->sd_jinode_gh
))
720 gfs2_glock_dq_uninit(&sdp
->sd_jinode_gh
);
721 gfs2_glock_dq_uninit(&sdp
->sd_sc_gh
);
722 gfs2_glock_dq_uninit(&sdp
->sd_qc_gh
);
723 iput(sdp
->sd_sc_inode
);
724 iput(sdp
->sd_qc_inode
);
727 gfs2_glock_dq_uninit(&sdp
->sd_live_gh
);
728 gfs2_clear_rgrpd(sdp
);
729 gfs2_jindex_free(sdp
);
730 /* Take apart glock structures and buffer lists */
731 gfs2_gl_hash_clear(sdp
);
732 gfs2_delete_debugfs_file(sdp
);
733 /* Unmount the locking protocol */
734 gfs2_lm_unmount(sdp
);
736 /* At this point, we're through participating in the lockspace */
737 gfs2_sys_fs_del(sdp
);
741 * gfs2_sync_fs - sync the filesystem
742 * @sb: the superblock
744 * Flushes the log to disk.
747 static int gfs2_sync_fs(struct super_block
*sb
, int wait
)
749 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
751 gfs2_quota_sync(sb
, -1);
753 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
755 return sdp
->sd_log_error
;
758 void gfs2_freeze_func(struct work_struct
*work
)
761 struct gfs2_holder freeze_gh
;
762 struct gfs2_sbd
*sdp
= container_of(work
, struct gfs2_sbd
, sd_freeze_work
);
763 struct super_block
*sb
= sdp
->sd_vfs
;
765 atomic_inc(&sb
->s_active
);
766 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_SHARED
,
767 LM_FLAG_NOEXP
| GL_EXACT
, &freeze_gh
);
769 fs_info(sdp
, "GFS2: couldn't get freeze lock : %d\n", error
);
770 gfs2_assert_withdraw(sdp
, 0);
772 atomic_set(&sdp
->sd_freeze_state
, SFS_UNFROZEN
);
773 error
= thaw_super(sb
);
775 fs_info(sdp
, "GFS2: couldn't thaw filesystem: %d\n",
777 gfs2_assert_withdraw(sdp
, 0);
779 gfs2_glock_dq_uninit(&freeze_gh
);
781 deactivate_super(sb
);
782 clear_bit_unlock(SDF_FS_FROZEN
, &sdp
->sd_flags
);
783 wake_up_bit(&sdp
->sd_flags
, SDF_FS_FROZEN
);
788 * gfs2_freeze - prevent further writes to the filesystem
789 * @sb: the VFS structure for the filesystem
793 static int gfs2_freeze(struct super_block
*sb
)
795 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
798 mutex_lock(&sdp
->sd_freeze_mutex
);
799 if (atomic_read(&sdp
->sd_freeze_state
) != SFS_UNFROZEN
)
803 if (gfs2_withdrawn(sdp
)) {
808 error
= gfs2_lock_fs_check_clean(sdp
);
813 fs_err(sdp
, "waiting for recovery before freeze\n");
814 else if (error
== -EIO
) {
815 fs_err(sdp
, "Fatal IO error: cannot freeze gfs2 due "
816 "to recovery error.\n");
819 fs_err(sdp
, "error freezing FS: %d\n", error
);
821 fs_err(sdp
, "retrying...\n");
824 set_bit(SDF_FS_FROZEN
, &sdp
->sd_flags
);
826 mutex_unlock(&sdp
->sd_freeze_mutex
);
831 * gfs2_unfreeze - reallow writes to the filesystem
832 * @sb: the VFS structure for the filesystem
836 static int gfs2_unfreeze(struct super_block
*sb
)
838 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
840 mutex_lock(&sdp
->sd_freeze_mutex
);
841 if (atomic_read(&sdp
->sd_freeze_state
) != SFS_FROZEN
||
842 !gfs2_holder_initialized(&sdp
->sd_freeze_gh
)) {
843 mutex_unlock(&sdp
->sd_freeze_mutex
);
847 gfs2_glock_dq_uninit(&sdp
->sd_freeze_gh
);
848 mutex_unlock(&sdp
->sd_freeze_mutex
);
849 return wait_on_bit(&sdp
->sd_flags
, SDF_FS_FROZEN
, TASK_INTERRUPTIBLE
);
853 * statfs_fill - fill in the sg for a given RG
855 * @sc: the sc structure
857 * Returns: 0 on success, -ESTALE if the LVB is invalid
860 static int statfs_slow_fill(struct gfs2_rgrpd
*rgd
,
861 struct gfs2_statfs_change_host
*sc
)
863 gfs2_rgrp_verify(rgd
);
864 sc
->sc_total
+= rgd
->rd_data
;
865 sc
->sc_free
+= rgd
->rd_free
;
866 sc
->sc_dinodes
+= rgd
->rd_dinodes
;
871 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
872 * @sdp: the filesystem
873 * @sc: the sc info that will be returned
875 * Any error (other than a signal) will cause this routine to fall back
876 * to the synchronous version.
878 * FIXME: This really shouldn't busy wait like this.
883 static int gfs2_statfs_slow(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
885 struct gfs2_rgrpd
*rgd_next
;
886 struct gfs2_holder
*gha
, *gh
;
887 unsigned int slots
= 64;
892 memset(sc
, 0, sizeof(struct gfs2_statfs_change_host
));
893 gha
= kmalloc_array(slots
, sizeof(struct gfs2_holder
), GFP_KERNEL
);
896 for (x
= 0; x
< slots
; x
++)
897 gfs2_holder_mark_uninitialized(gha
+ x
);
899 rgd_next
= gfs2_rgrpd_get_first(sdp
);
904 for (x
= 0; x
< slots
; x
++) {
907 if (gfs2_holder_initialized(gh
) && gfs2_glock_poll(gh
)) {
908 err
= gfs2_glock_wait(gh
);
910 gfs2_holder_uninit(gh
);
914 struct gfs2_rgrpd
*rgd
=
915 gfs2_glock2rgrp(gh
->gh_gl
);
917 error
= statfs_slow_fill(rgd
, sc
);
919 gfs2_glock_dq_uninit(gh
);
923 if (gfs2_holder_initialized(gh
))
925 else if (rgd_next
&& !error
) {
926 error
= gfs2_glock_nq_init(rgd_next
->rd_gl
,
930 rgd_next
= gfs2_rgrpd_get_next(rgd_next
);
934 if (signal_pending(current
))
935 error
= -ERESTARTSYS
;
949 * gfs2_statfs_i - Do a statfs
950 * @sdp: the filesystem
951 * @sg: the sg structure
956 static int gfs2_statfs_i(struct gfs2_sbd
*sdp
, struct gfs2_statfs_change_host
*sc
)
958 struct gfs2_statfs_change_host
*m_sc
= &sdp
->sd_statfs_master
;
959 struct gfs2_statfs_change_host
*l_sc
= &sdp
->sd_statfs_local
;
961 spin_lock(&sdp
->sd_statfs_spin
);
964 sc
->sc_total
+= l_sc
->sc_total
;
965 sc
->sc_free
+= l_sc
->sc_free
;
966 sc
->sc_dinodes
+= l_sc
->sc_dinodes
;
968 spin_unlock(&sdp
->sd_statfs_spin
);
972 if (sc
->sc_free
> sc
->sc_total
)
973 sc
->sc_free
= sc
->sc_total
;
974 if (sc
->sc_dinodes
< 0)
981 * gfs2_statfs - Gather and return stats about the filesystem
982 * @sb: The superblock
983 * @statfsbuf: The buffer
985 * Returns: 0 on success or error code
988 static int gfs2_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
990 struct super_block
*sb
= dentry
->d_sb
;
991 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
992 struct gfs2_statfs_change_host sc
;
995 error
= gfs2_rindex_update(sdp
);
999 if (gfs2_tune_get(sdp
, gt_statfs_slow
))
1000 error
= gfs2_statfs_slow(sdp
, &sc
);
1002 error
= gfs2_statfs_i(sdp
, &sc
);
1007 buf
->f_type
= GFS2_MAGIC
;
1008 buf
->f_bsize
= sdp
->sd_sb
.sb_bsize
;
1009 buf
->f_blocks
= sc
.sc_total
;
1010 buf
->f_bfree
= sc
.sc_free
;
1011 buf
->f_bavail
= sc
.sc_free
;
1012 buf
->f_files
= sc
.sc_dinodes
+ sc
.sc_free
;
1013 buf
->f_ffree
= sc
.sc_free
;
1014 buf
->f_namelen
= GFS2_FNAMESIZE
;
1020 * gfs2_drop_inode - Drop an inode (test for remote unlink)
1021 * @inode: The inode to drop
1023 * If we've received a callback on an iopen lock then it's because a
1024 * remote node tried to deallocate the inode but failed due to this node
1025 * still having the inode open. Here we mark the link count zero
1026 * since we know that it must have reached zero if the GLF_DEMOTE flag
1027 * is set on the iopen glock. If we didn't do a disk read since the
1028 * remote node removed the final link then we might otherwise miss
1029 * this event. This check ensures that this node will deallocate the
1030 * inode's blocks, or alternatively pass the baton on to another
1031 * node for later deallocation.
1034 static int gfs2_drop_inode(struct inode
*inode
)
1036 struct gfs2_inode
*ip
= GFS2_I(inode
);
1038 if (!test_bit(GIF_FREE_VFS_INODE
, &ip
->i_flags
) &&
1040 gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
1041 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1042 if (test_bit(GLF_DEMOTE
, &gl
->gl_flags
))
1047 * When under memory pressure when an inode's link count has dropped to
1048 * zero, defer deleting the inode to the delete workqueue. This avoids
1049 * calling into DLM under memory pressure, which can deadlock.
1051 if (!inode
->i_nlink
&&
1052 unlikely(current
->flags
& PF_MEMALLOC
) &&
1053 gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
1054 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1056 gfs2_glock_hold(gl
);
1057 if (!gfs2_queue_delete_work(gl
, 0))
1058 gfs2_glock_queue_put(gl
);
1062 return generic_drop_inode(inode
);
1065 static int is_ancestor(const struct dentry
*d1
, const struct dentry
*d2
)
1071 } while (!IS_ROOT(d1
));
1076 * gfs2_show_options - Show mount options for /proc/mounts
1077 * @s: seq_file structure
1078 * @root: root of this (sub)tree
1080 * Returns: 0 on success or error code
1083 static int gfs2_show_options(struct seq_file
*s
, struct dentry
*root
)
1085 struct gfs2_sbd
*sdp
= root
->d_sb
->s_fs_info
;
1086 struct gfs2_args
*args
= &sdp
->sd_args
;
1089 if (is_ancestor(root
, sdp
->sd_master_dir
))
1090 seq_puts(s
, ",meta");
1091 if (args
->ar_lockproto
[0])
1092 seq_show_option(s
, "lockproto", args
->ar_lockproto
);
1093 if (args
->ar_locktable
[0])
1094 seq_show_option(s
, "locktable", args
->ar_locktable
);
1095 if (args
->ar_hostdata
[0])
1096 seq_show_option(s
, "hostdata", args
->ar_hostdata
);
1097 if (args
->ar_spectator
)
1098 seq_puts(s
, ",spectator");
1099 if (args
->ar_localflocks
)
1100 seq_puts(s
, ",localflocks");
1102 seq_puts(s
, ",debug");
1103 if (args
->ar_posix_acl
)
1104 seq_puts(s
, ",acl");
1105 if (args
->ar_quota
!= GFS2_QUOTA_DEFAULT
) {
1107 switch (args
->ar_quota
) {
1108 case GFS2_QUOTA_OFF
:
1111 case GFS2_QUOTA_ACCOUNT
:
1121 seq_printf(s
, ",quota=%s", state
);
1123 if (args
->ar_suiddir
)
1124 seq_puts(s
, ",suiddir");
1125 if (args
->ar_data
!= GFS2_DATA_DEFAULT
) {
1127 switch (args
->ar_data
) {
1128 case GFS2_DATA_WRITEBACK
:
1129 state
= "writeback";
1131 case GFS2_DATA_ORDERED
:
1138 seq_printf(s
, ",data=%s", state
);
1140 if (args
->ar_discard
)
1141 seq_puts(s
, ",discard");
1142 val
= sdp
->sd_tune
.gt_logd_secs
;
1144 seq_printf(s
, ",commit=%d", val
);
1145 val
= sdp
->sd_tune
.gt_statfs_quantum
;
1147 seq_printf(s
, ",statfs_quantum=%d", val
);
1148 else if (sdp
->sd_tune
.gt_statfs_slow
)
1149 seq_puts(s
, ",statfs_quantum=0");
1150 val
= sdp
->sd_tune
.gt_quota_quantum
;
1152 seq_printf(s
, ",quota_quantum=%d", val
);
1153 if (args
->ar_statfs_percent
)
1154 seq_printf(s
, ",statfs_percent=%d", args
->ar_statfs_percent
);
1155 if (args
->ar_errors
!= GFS2_ERRORS_DEFAULT
) {
1158 switch (args
->ar_errors
) {
1159 case GFS2_ERRORS_WITHDRAW
:
1162 case GFS2_ERRORS_PANIC
:
1169 seq_printf(s
, ",errors=%s", state
);
1171 if (test_bit(SDF_NOBARRIERS
, &sdp
->sd_flags
))
1172 seq_puts(s
, ",nobarrier");
1173 if (test_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
1174 seq_puts(s
, ",demote_interface_used");
1175 if (args
->ar_rgrplvb
)
1176 seq_puts(s
, ",rgrplvb");
1177 if (args
->ar_loccookie
)
1178 seq_puts(s
, ",loccookie");
1182 static void gfs2_final_release_pages(struct gfs2_inode
*ip
)
1184 struct inode
*inode
= &ip
->i_inode
;
1185 struct gfs2_glock
*gl
= ip
->i_gl
;
1187 truncate_inode_pages(gfs2_glock2aspace(ip
->i_gl
), 0);
1188 truncate_inode_pages(&inode
->i_data
, 0);
1190 if (atomic_read(&gl
->gl_revokes
) == 0) {
1191 clear_bit(GLF_LFLUSH
, &gl
->gl_flags
);
1192 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
1196 static int gfs2_dinode_dealloc(struct gfs2_inode
*ip
)
1198 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1199 struct gfs2_rgrpd
*rgd
;
1200 struct gfs2_holder gh
;
1203 if (gfs2_get_inode_blocks(&ip
->i_inode
) != 1) {
1204 gfs2_consist_inode(ip
);
1208 error
= gfs2_rindex_update(sdp
);
1212 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
1216 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_no_addr
, 1);
1218 gfs2_consist_inode(ip
);
1223 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1227 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_STATFS
+ RES_QUOTA
,
1228 sdp
->sd_jdesc
->jd_blocks
);
1230 goto out_rg_gunlock
;
1232 gfs2_free_di(rgd
, ip
);
1234 gfs2_final_release_pages(ip
);
1236 gfs2_trans_end(sdp
);
1239 gfs2_glock_dq_uninit(&gh
);
1241 gfs2_quota_unhold(ip
);
1246 * gfs2_glock_put_eventually
1247 * @gl: The glock to put
1249 * When under memory pressure, trigger a deferred glock put to make sure we
1250 * won't call into DLM and deadlock. Otherwise, put the glock directly.
1253 static void gfs2_glock_put_eventually(struct gfs2_glock
*gl
)
1255 if (current
->flags
& PF_MEMALLOC
)
1256 gfs2_glock_queue_put(gl
);
1261 static bool gfs2_upgrade_iopen_glock(struct inode
*inode
)
1263 struct gfs2_inode
*ip
= GFS2_I(inode
);
1264 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1265 struct gfs2_holder
*gh
= &ip
->i_iopen_gh
;
1266 long timeout
= 5 * HZ
;
1269 gh
->gh_flags
|= GL_NOCACHE
;
1270 gfs2_glock_dq_wait(gh
);
1273 * If there are no other lock holders, we'll get the lock immediately.
1274 * Otherwise, the other nodes holding the lock will be notified about
1275 * our locking request. If they don't have the inode open, they'll
1276 * evict the cached inode and release the lock. Otherwise, if they
1277 * poke the inode glock, we'll take this as an indication that they
1278 * still need the iopen glock and that they'll take care of deleting
1279 * the inode when they're done. As a last resort, if another node
1280 * keeps holding the iopen glock without showing any activity on the
1281 * inode glock, we'll eventually time out.
1283 * Note that we're passing the LM_FLAG_TRY_1CB flag to the first
1284 * locking request as an optimization to notify lock holders as soon as
1285 * possible. Without that flag, they'd be notified implicitly by the
1286 * second locking request.
1289 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, LM_FLAG_TRY_1CB
| GL_NOCACHE
, gh
);
1290 error
= gfs2_glock_nq(gh
);
1291 if (error
!= GLR_TRYFAILED
)
1294 gfs2_holder_reinit(LM_ST_EXCLUSIVE
, GL_ASYNC
| GL_NOCACHE
, gh
);
1295 error
= gfs2_glock_nq(gh
);
1299 timeout
= wait_event_interruptible_timeout(sdp
->sd_async_glock_wait
,
1300 !test_bit(HIF_WAIT
, &gh
->gh_iflags
) ||
1301 test_bit(GLF_DEMOTE
, &ip
->i_gl
->gl_flags
),
1303 if (!test_bit(HIF_HOLDER
, &gh
->gh_iflags
)) {
1311 * gfs2_evict_inode - Remove an inode from cache
1312 * @inode: The inode to evict
1314 * There are three cases to consider:
1315 * 1. i_nlink == 0, we are final opener (and must deallocate)
1316 * 2. i_nlink == 0, we are not the final opener (and cannot deallocate)
1319 * If the fs is read only, then we have to treat all cases as per #3
1320 * since we are unable to do any deallocation. The inode will be
1321 * deallocated by the next read/write node to attempt an allocation
1322 * in the same resource group
1324 * We have to (at the moment) hold the inodes main lock to cover
1325 * the gap between unlocking the shared lock on the iopen lock and
1326 * taking the exclusive lock. I'd rather do a shared -> exclusive
1327 * conversion on the iopen lock, but we can change that later. This
1328 * is safe, just less efficient.
1331 static void gfs2_evict_inode(struct inode
*inode
)
1333 struct super_block
*sb
= inode
->i_sb
;
1334 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1335 struct gfs2_inode
*ip
= GFS2_I(inode
);
1336 struct gfs2_holder gh
;
1337 struct address_space
*metamapping
;
1340 if (test_bit(GIF_FREE_VFS_INODE
, &ip
->i_flags
)) {
1345 if (inode
->i_nlink
|| sb_rdonly(sb
))
1348 if (test_bit(GIF_ALLOC_FAILED
, &ip
->i_flags
)) {
1349 BUG_ON(!gfs2_glock_is_locked_by_me(ip
->i_gl
));
1350 gfs2_holder_mark_uninitialized(&gh
);
1354 if (test_bit(GIF_DEFERRED_DELETE
, &ip
->i_flags
))
1357 /* Deletes should never happen under memory pressure anymore. */
1358 if (WARN_ON_ONCE(current
->flags
& PF_MEMALLOC
))
1361 /* Must not read inode block until block type has been verified */
1362 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, GL_SKIP
, &gh
);
1363 if (unlikely(error
)) {
1364 glock_clear_object(ip
->i_iopen_gh
.gh_gl
, ip
);
1365 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1366 gfs2_glock_dq_uninit(&ip
->i_iopen_gh
);
1370 if (gfs2_inode_already_deleted(ip
->i_gl
, ip
->i_no_formal_ino
))
1372 error
= gfs2_check_blk_type(sdp
, ip
->i_no_addr
, GFS2_BLKST_UNLINKED
);
1376 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
1377 error
= gfs2_inode_refresh(ip
);
1383 * The inode may have been recreated in the meantime.
1389 if (gfs2_holder_initialized(&ip
->i_iopen_gh
) &&
1390 test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
)) {
1391 if (!gfs2_upgrade_iopen_glock(inode
)) {
1392 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1397 if (S_ISDIR(inode
->i_mode
) &&
1398 (ip
->i_diskflags
& GFS2_DIF_EXHASH
)) {
1399 error
= gfs2_dir_exhash_dealloc(ip
);
1405 error
= gfs2_ea_dealloc(ip
);
1410 if (!gfs2_is_stuffed(ip
)) {
1411 error
= gfs2_file_dealloc(ip
);
1416 /* We're about to clear the bitmap for the dinode, but as soon as we
1417 do, gfs2_create_inode can create another inode at the same block
1418 location and try to set gl_object again. We clear gl_object here so
1419 that subsequent inode creates don't see an old gl_object. */
1420 glock_clear_object(ip
->i_gl
, ip
);
1421 error
= gfs2_dinode_dealloc(ip
);
1422 gfs2_inode_remember_delete(ip
->i_gl
, ip
->i_no_formal_ino
);
1426 gfs2_log_flush(sdp
, ip
->i_gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
1427 GFS2_LFC_EVICT_INODE
);
1428 metamapping
= gfs2_glock2aspace(ip
->i_gl
);
1429 if (test_bit(GLF_DIRTY
, &ip
->i_gl
->gl_flags
)) {
1430 filemap_fdatawrite(metamapping
);
1431 filemap_fdatawait(metamapping
);
1433 write_inode_now(inode
, 1);
1434 gfs2_ail_flush(ip
->i_gl
, 0);
1436 error
= gfs2_trans_begin(sdp
, 0, sdp
->sd_jdesc
->jd_blocks
);
1439 /* Needs to be done before glock release & also in a transaction */
1440 truncate_inode_pages(&inode
->i_data
, 0);
1441 truncate_inode_pages(metamapping
, 0);
1442 gfs2_trans_end(sdp
);
1445 if (gfs2_rs_active(&ip
->i_res
))
1446 gfs2_rs_deltree(&ip
->i_res
);
1448 if (gfs2_holder_initialized(&gh
)) {
1449 glock_clear_object(ip
->i_gl
, ip
);
1450 gfs2_glock_dq_uninit(&gh
);
1452 if (error
&& error
!= GLR_TRYFAILED
&& error
!= -EROFS
)
1453 fs_warn(sdp
, "gfs2_evict_inode: %d\n", error
);
1455 truncate_inode_pages_final(&inode
->i_data
);
1457 gfs2_assert_warn(sdp
, ip
->i_qadata
->qa_ref
== 0);
1458 gfs2_rs_delete(ip
, NULL
);
1459 gfs2_ordered_del_inode(ip
);
1461 gfs2_dir_hash_inval(ip
);
1463 glock_clear_object(ip
->i_gl
, ip
);
1464 wait_on_bit_io(&ip
->i_flags
, GIF_GLOP_PENDING
, TASK_UNINTERRUPTIBLE
);
1465 gfs2_glock_add_to_lru(ip
->i_gl
);
1466 gfs2_glock_put_eventually(ip
->i_gl
);
1469 if (gfs2_holder_initialized(&ip
->i_iopen_gh
)) {
1470 struct gfs2_glock
*gl
= ip
->i_iopen_gh
.gh_gl
;
1472 glock_clear_object(gl
, ip
);
1473 if (test_bit(HIF_HOLDER
, &ip
->i_iopen_gh
.gh_iflags
)) {
1474 ip
->i_iopen_gh
.gh_flags
|= GL_NOCACHE
;
1475 gfs2_glock_dq(&ip
->i_iopen_gh
);
1477 gfs2_glock_hold(gl
);
1478 gfs2_holder_uninit(&ip
->i_iopen_gh
);
1479 gfs2_glock_put_eventually(gl
);
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 gfs2_holder_mark_uninitialized(&ip
->i_iopen_gh
);
1493 memset(&ip
->i_res
, 0, sizeof(ip
->i_res
));
1494 RB_CLEAR_NODE(&ip
->i_res
.rs_node
);
1496 return &ip
->i_inode
;
1499 static void gfs2_free_inode(struct inode
*inode
)
1501 kmem_cache_free(gfs2_inode_cachep
, GFS2_I(inode
));
1504 const struct super_operations gfs2_super_ops
= {
1505 .alloc_inode
= gfs2_alloc_inode
,
1506 .free_inode
= gfs2_free_inode
,
1507 .write_inode
= gfs2_write_inode
,
1508 .dirty_inode
= gfs2_dirty_inode
,
1509 .evict_inode
= gfs2_evict_inode
,
1510 .put_super
= gfs2_put_super
,
1511 .sync_fs
= gfs2_sync_fs
,
1512 .freeze_super
= gfs2_freeze
,
1513 .thaw_super
= gfs2_unfreeze
,
1514 .statfs
= gfs2_statfs
,
1515 .drop_inode
= gfs2_drop_inode
,
1516 .show_options
= gfs2_show_options
,